{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load in \n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the \"../input/\" directory.\n# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n\nimport os\nprint(os.listdir(\"../input\"))\n\n# Any results you write to the current directory are saved as output.","execution_count":1,"outputs":[{"output_type":"stream","text":"['trains1', 'iwildcam-2019-fgvc6', 'reshape32x32']\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"######WITHOUT RESHAPE 32X32","execution_count":2,"outputs":[]},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"train= pd.read_csv(\"../input/iwildcam-2019-fgvc6/train.csv\")\ntest= pd.read_csv(\"../input/iwildcam-2019-fgvc6/test.csv\")\nsample_submission= pd.read_csv(\"../input/iwildcam-2019-fgvc6/sample_submission.csv\")\n#print(\"train.shape:\", train.shape)\nprint(\"test.shape:\", test.shape)\nprint(\"sample_submmission.shape:\", sample_submission.shape)\n\n#train_images = '../input/train_images/*'\n#test_images = '../input/test_images/*'","execution_count":3,"outputs":[{"output_type":"stream","text":"test.shape: (153730, 10)\nsample_submmission.shape: (153730, 2)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"import cv2\nimport glob\nimport matplotlib.pyplot as plt\nimport tqdm\nimport tensorflow as tf\nfrom tensorflow.python.framework import ops\nimport scipy\nfrom scipy import ndimage\nimport math\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import confusion_matrix, roc_auc_score\nfrom PIL import Image","execution_count":4,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Get ids and labels\ntrain_id = train['file_name']\nlabels = train['category_id']\ntest_id = sample_submission['Id']\n\nimg = plt.imread('../input/iwildcam-2019-fgvc6/train_images/'+ train['file_name'][0])\nimg.shape","execution_count":5,"outputs":[{"output_type":"execute_result","execution_count":5,"data":{"text/plain":"(747, 1024, 3)"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# The TEST data, load data:\nx_test_arr = np.load('../input/reshape32x32/X_test.npy')\nprint('x_test_arr shape:', x_test_arr.shape)\nprint(x_test_arr.shape[0], 'test samples')","execution_count":6,"outputs":[{"output_type":"stream","text":"x_test_arr shape: (153730, 32, 32, 3)\n153730 test samples\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# Convert the TEST images to float and scale it to a range of 0 to 1\nx_test = x_test_arr.astype('float32')\nx_test /= 255.\n\nprint(\"x_test.shape:\",x_test.shape)","execution_count":7,"outputs":[{"output_type":"stream","text":"x_test.shape: (153730, 32, 32, 3)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"x_trains1 = np.load('../input/trains1/x_trains1.npy')\ny_trains1 = np.load('../input/trains1/y_trains1.npy')\nprint(\"x_trains1.shape:\",x_trains1.shape)\nprint(\"y_trains1.shape:\",y_trains1.shape)","execution_count":8,"outputs":[{"output_type":"stream","text":"x_trains1.shape: (96167, 32, 32, 3)\ny_trains1.shape: (96167, 23)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"# split between train_set and dev_set \nx_train, x_dev, y_train, y_dev = train_test_split(x_trains1, y_trains1, test_size = 0.050, random_state = 32)\n\nprint(\"x_train.shape:\",x_train.shape)\nprint(\"y_train.shape:\",y_train.shape)\nprint(\"x_dev.shape:\",x_dev.shape)\nprint(\"y_dev.shape:\",y_dev.shape)\n\nprint( \"GENERATE Testsets: \")\nprint( \"----------------- \")\n\n# split de test_set in several test_sets\nx_testa, x_testb = train_test_split(x_test, test_size = 0.5)\nx_test1, x_test2 = train_test_split(x_testa, test_size = 0.5)\nx_test3, x_test4 = train_test_split(x_testb, test_size = 0.5)\n\nprint(\"x_test1.shape:\",x_test1.shape)\nprint(\"x_test2.shape:\",x_test2.shape)\nprint(\"x_test3.shape:\",x_test3.shape)\nprint(\"x_test4.shape:\",x_test4.shape)\n","execution_count":9,"outputs":[{"output_type":"stream","text":"x_train.shape: (91358, 32, 32, 3)\ny_train.shape: (91358, 23)\nx_dev.shape: (4809, 32, 32, 3)\ny_dev.shape: (4809, 23)\nGENERATE Testsets: \n----------------- \nx_test1.shape: (38432, 32, 32, 3)\nx_test2.shape: (38433, 32, 32, 3)\nx_test3.shape: (38432, 32, 32, 3)\nx_test4.shape: (38433, 32, 32, 3)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"### CCN with Tensorflow","execution_count":10,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def create_placeholders(n_H0, n_W0, n_C0, n_y):\n    \"\"\"\n    Creates the placeholders for the tensorflow session.\n    \n    Arguments:\n    n_H0 -- scalar, height of an input image\n    n_W0 -- scalar, width of an input image\n    n_C0 -- scalar, number of channels of the input\n    n_y -- scalar, number of classes\n        \n    Returns:\n    X -- placeholder for the data input, of shape [None, n_H0, n_W0, n_C0] and dtype \"float\"\n    Y -- placeholder for the input labels, of shape [None, n_y] and dtype \"float\"\n    \"\"\"\n    X = tf.placeholder(tf.float32, shape=(None, n_H0, n_W0, n_C0)) \n    Y = tf.placeholder(tf.float32, shape=(None, n_y))\n    \n    return X, Y\n\ndef initialize_parameters():\n    \"\"\"\n    Initializes weight parameters to build a neural network with tensorflow. The shapes are:\n                        W : [fc, fc, Nc_1, Nc]\n    Returns:\n    parameters -- a dictionary of tensors containing W1 W2\n    \"\"\"\n    \n    tf.set_random_seed(1)                              # so that your \"random\" numbers match ours\n\n    W1 = tf.get_variable(\"W1\", [4, 4, 3, 32], initializer = tf.contrib.layers.xavier_initializer(seed = 0))\n    W2 = tf.get_variable(\"W2\", [2, 2, 32, 64], initializer = tf.contrib.layers.xavier_initializer(seed = 0))\n\n    parameters = {\"W1\": W1,\n                  \"W2\": W2}\n    \n    return parameters\n\ndef forward_propagation(X, parameters):\n    \"\"\"\n    Implements the forward propagation for the model:\n    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n    \n    Returns:\n    Z3 -- the output of the last LINEAR unit\n    \"\"\" \n    # Retrieve the parameters from the dictionary \"parameters\" \n    W1 = parameters['W1']\n    W2 = parameters['W2']\n    \n    # CONV2D: stride of 1, padding 'SAME'\n    Z1 = tf.nn.conv2d(X,W1, strides = [1,1,1,1], padding = 'SAME')\n    # RELU\n    A1 = tf.nn.relu(Z1)\n    # MAXPOOL: window 8x8, sride 8, padding 'SAME'\n    P1 = tf.nn.max_pool(A1, ksize = [1,8,8,1], strides = [1,8,8,1], padding = 'SAME')\n    # CONV2D: filters W2, stride 1, padding 'SAME'\n    Z2 = tf.nn.conv2d(P1,W2, strides = [1,1,1,1], padding = 'SAME')\n    # RELU\n    A2 = tf.nn.relu(Z2)\n    # MAXPOOL: window 4x4, stride 4, padding 'SAME'\n    P2 = tf.nn.max_pool(A2, ksize = [1,4,4,1], strides = [1,4,4,1], padding = 'SAME')\n    # FLATTEN\n    P2 = tf.contrib.layers.flatten(P2)\n    # FULLY-CONNECTED without non-linear activation function (not not call softmax).\n    # 23 neurons in output layer. Hint: one of the arguments should be \"activation_fn=None\" \n    Z3 = tf.contrib.layers.fully_connected(P2, 23,activation_fn=None)\n    return Z3\n\ndef compute_cost(Z3, Y):\n    \"\"\"\n    Computes the cost\n    \n    Returns:\n    cost - Tensor of the cost function\n    \"\"\"\n    cost = tf.reduce_mean(tf.losses.mean_squared_error(Y, Z3))\n    \n    return cost","execution_count":11,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def random_mini_batches(X, Y, mini_batch_size = 64, seed = 0):\n    \"\"\"\n    Creates a list of random minibatches from (X, Y)\n    \n    Arguments:\n    X -- input data, of shape (input size, number of examples) (m, Hi, Wi, Ci)\n    Y -- true \"label\" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples) (m, n_y)\n    mini_batch_size - size of the mini-batches, integer\n    seed -- this is only for the purpose of grading, so that you're \"random minibatches are the same as ours.\n    \n    Returns:\n    mini_batches -- list of synchronous (mini_batch_X, mini_batch_Y)\n    \"\"\"\n    \n    m = X.shape[0]                  # number of training examples\n    mini_batches = []\n    np.random.seed(seed)\n    \n    # Step 1: Shuffle (X, Y)\n    permutation = list(np.random.permutation(m))\n    shuffled_X = X[permutation,:,:,:]\n    shuffled_Y = Y[permutation,:]\n\n    # Step 2: Partition (shuffled_X, shuffled_Y). Minus the end case.\n    num_complete_minibatches = math.floor(m/mini_batch_size) # number of mini batches of size mini_batch_size in your partitionning\n    for k in range(0, num_complete_minibatches):\n        mini_batch_X = shuffled_X[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:,:,:]\n        mini_batch_Y = shuffled_Y[k * mini_batch_size : k * mini_batch_size + mini_batch_size,:]\n        mini_batch = (mini_batch_X, mini_batch_Y)\n        mini_batches.append(mini_batch)\n    \n    # Handling the end case (last mini-batch < mini_batch_size)\n    if m % mini_batch_size != 0:\n        mini_batch_X = shuffled_X[num_complete_minibatches * mini_batch_size : m,:,:,:]\n        mini_batch_Y = shuffled_Y[num_complete_minibatches * mini_batch_size : m,:]\n        mini_batch = (mini_batch_X, mini_batch_Y)\n        mini_batches.append(mini_batch)\n    \n    return mini_batches","execution_count":12,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def model(X_train, Y_train, X_test, Y_test, X_test_test ,X_test_test1, X_test_test2,X_test_test3,X_test_test4, learning_rate = 0.009,num_epochs = 20, minibatch_size = 64, print_cost = True):\n    \"\"\"\n    Implements a three-layer ConvNet in Tensorflow:\n    CONV2D -> RELU -> MAXPOOL -> CONV2D -> RELU -> MAXPOOL -> FLATTEN -> FULLYCONNECTED\n    \n    Arguments:\n    num_epochs -- number of epochs of the optimization loop\n    minibatch_size -- size of a minibatch\n    print_cost -- True to print the cost every 100 epochs\n    \n    Returns:\n    train_accuracy -- real number, accuracy on the train set (X_train)\n    test_accuracy -- real number, testing accuracy on the test set (X_test)\n    parameters -- parameters learnt by the model. They can then be used to predict.\n    \"\"\"\n    \n    ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables\n    tf.set_random_seed(1)                             # to keep results consistent (tensorflow seed)\n    seed = 3                                          # to keep results consistent (numpy seed)\n    (m, n_H0, n_W0, n_C0) = X_train.shape             \n    n_y = Y_train.shape[1]                            \n    costs = []                                        # To keep track of the cost\n    \n    # Create Placeholders of the correct shape\n    X, Y = create_placeholders(n_H0, n_W0, n_C0, n_y)\n\n    # Inilitialize parameters \n    parameters = initialize_parameters()\n    \n    # Forward propagation: Build the forward propagation in the tensorflow graph\n    Z3 = forward_propagation(X, parameters)\n    \n    # Cost function: Add cost function to tensorflow graph\n    cost = compute_cost(Z3, Y)\n    \n    # Backpropagation: Define the tensorflow optimizer. Use an AdamOptimizer that minimizes the cost.\n    optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)\n    \n    # Initialize all the variables globally\n    init = tf.global_variables_initializer()\n     \n    # Start the session to compute the tensorflow graph\n    with tf.Session() as sess:\n        \n        # Run the initialization\n        sess.run(init)\n        \n        # Do the training loop\n        for epoch in range(num_epochs):\n\n            minibatch_cost = 0.\n            num_minibatches = int(m / minibatch_size) # number of minibatches of size minibatch_size in the train set\n            seed = seed + 1\n            minibatches = random_mini_batches(X_train, Y_train, minibatch_size, seed)\n\n            for minibatch in minibatches:\n\n                # Select a minibatch\n                (minibatch_X, minibatch_Y) = minibatch\n                # IMPORTANT: The line that runs the graph on a minibatch.\n                # Run the session to execute the optimizer and the cost, the feedict should contain a minibatch for (X,Y).\n                _ , temp_cost = sess.run([optimizer,cost], feed_dict ={X:minibatch_X, Y:minibatch_Y})\n                 \n                minibatch_cost += temp_cost / num_minibatches\n                \n            # Print the cost every epoch\n            if print_cost == True and epoch % 5 == 0:\n                print (\"Cost after epoch %i: %f\" % (epoch, minibatch_cost))\n            if print_cost == True and epoch % 1 == 0:\n                costs.append(minibatch_cost)\n                                      \n        \n        # plot the cost\n        plt.plot(np.squeeze(costs))\n        plt.ylabel('cost')\n        plt.xlabel('iterations (per tens)')\n        plt.title(\"Learning rate =\" + str(learning_rate))\n        plt.show()\n\n        # Calculate the correct predictions\n        predict_op = tf.argmax(Z3,1)\n        correct_prediction = tf.equal(predict_op, tf.argmax(Y, 1))\n        \n        # Calculate accuracy on the test set\n        accuracy = tf.reduce_mean(tf.cast(correct_prediction, \"float\"))\n        \n        if X_train.shape[0]>30000:\n            train_accuracy = accuracy.eval({X: X_train[:25000], Y: Y_train[:25000]})\n            number_for_train_accuracy=25000\n        else:\n            train_accuracy = accuracy.eval({X: X_train, Y: Y_train})\n            number_for_train_accuracy=X_train.shape[0]\n        if X_test.shape[0] >25000:\n            test_accuracy = accuracy.eval({X: X_test[:25000], Y: Y_test[:25000]})\n            number_for_test_accuracy=25000\n        else:\n            test_accuracy = accuracy.eval({X: X_test, Y: Y_test})     \n            number_for_test_accuracy=X_test.shape[0]\n            \n        print(\"Train Accuracy:\", train_accuracy)\n        print(\"Dev Accuracy:\", test_accuracy)\n        \n            # Calculate Prediction in test_test set\n        test_results=[]\n        \n        prediction1=predict_op.eval({X: X_test_test1})\n        test_results.extend(prediction1) \n\n        prediction2=predict_op.eval({X: X_test_test2})\n        test_results.extend(prediction2)\n       \n        prediction3=predict_op.eval({X: X_test_test3})\n        test_results.extend(prediction3) \n       \n        prediction4=predict_op.eval({X: X_test_test4})\n        test_results.extend(prediction4)\n        \n        submission = pd.DataFrame({'Id':sample_submission[\"Id\"][:X_test_test.shape[0]],'Predicted':test_results})# test_results.reshape(-1).tolist()})\n        submission.to_csv(\"submission_got_it11.csv\", index=False)\n        print(\"Used in training set:\", x_train.shape[0],\"elements\")\n        print(\"Used in validation set:\", x_dev.shape[0],\"elements\")\n        print(\"Used in prediction set:\", len(test_results),\"elements\")\n        print(\"Used for train accuracy:\",number_for_train_accuracy, \"elements\")\n        print(\"Used for dev accuracy:\",number_for_test_accuracy, \"elements\")\n        print(submission.head())\n        print(\"Summary of predictions:\")\n        print(submission.Predicted.value_counts())\n\n        return train_accuracy, test_accuracy, parameters","execution_count":13,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"_, _, parameters = model(x_train, y_train, x_dev, y_dev, x_test, x_test1, x_test2, x_test3, x_test4, learning_rate = 0.0050,num_epochs = 130, minibatch_size = 64, print_cost = True)","execution_count":14,"outputs":[{"output_type":"stream","text":"\nWARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\nFor more information, please see:\n  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n  * https://github.com/tensorflow/addons\nIf you depend on functionality not listed there, please file an issue.\n\nWARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nColocations handled automatically by placer.\nWARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/contrib/layers/python/layers/layers.py:1624: flatten (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\nInstructions for updating:\nUse keras.layers.flatten instead.\nWARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/losses/losses_impl.py:667: to_float (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nUse tf.cast instead.\nCost after epoch 0: 0.026543\nCost after epoch 5: 0.021424\nCost after epoch 10: 0.020612\nCost after epoch 15: 0.020231\nCost after epoch 20: 0.019991\nCost after epoch 25: 0.019760\nCost after epoch 30: 0.019578\nCost after epoch 35: 0.019465\nCost after epoch 40: 0.019314\nCost after epoch 45: 0.019230\nCost after epoch 50: 0.019189\nCost after epoch 55: 0.019075\nCost after epoch 60: 0.018999\nCost after epoch 65: 0.018957\nCost after epoch 70: 0.018951\nCost after epoch 75: 0.018831\nCost after epoch 80: 0.018845\nCost after epoch 85: 0.018805\nCost after epoch 90: 0.018743\nCost after epoch 95: 0.018735\nCost after epoch 100: 0.018661\nCost after epoch 105: 0.018651\nCost after epoch 110: 0.018602\nCost after epoch 115: 0.018598\nCost after epoch 120: 0.018598\nCost after epoch 125: 0.018530\nCost after epoch 130: 0.018534\nCost after epoch 135: 0.018525\nCost after epoch 140: 0.018479\nCost after epoch 145: 0.018529\n","name":"stdout"},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{}},{"output_type":"stream","text":"Train Accuracy: 0.70912\nDev Accuracy: 0.6997297\nUsed in training set: 91358 elements\nUsed in validation set: 4809 elements\nUsed in prediction set: 153730 elements\nUsed for train accuracy: 25000 elements\nUsed for dev accuracy: 4809 elements\n                                     Id  Predicted\n0  b005e5b2-2c0b-11e9-bcad-06f10d5896c4         13\n1  f2347cfe-2c11-11e9-bcad-06f10d5896c4          0\n2  27cf8d26-2c0e-11e9-bcad-06f10d5896c4          8\n3  f82f52c7-2c1d-11e9-bcad-06f10d5896c4          0\n4  e133f50d-2c1c-11e9-bcad-06f10d5896c4          0\nSummary of predictions:\n0     98427\n19    11108\n1      8000\n4      7911\n8      7674\n3      5935\n13     5341\n11     3652\n17     2111\n18     1868\n16     1703\nName: Predicted, dtype: int64\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(os.listdir(\"../working\"))","execution_count":15,"outputs":[{"output_type":"stream","text":"['submission_got_it11.csv', '.ipynb_checkpoints', '__notebook_source__.ipynb']\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.4","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}