{"cells":[{"metadata":{},"cell_type":"markdown","source":"### This kernel was created to the <a target=\"_blank\" href=\"https://www.kaggle.com/c/LANL-Earthquake-Prediction\">LANL Earthquake Prediction</a> competition.\n### Here we plot the raw data and then aplly a Convolution Neural Network on the images."},{"metadata":{"trusted":true},"cell_type":"code","source":"import os\nimport cv2\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport warnings\nwarnings.filterwarnings(\"ignore\")\nfrom IPython.display import Image\nfrom keras.models import Sequential\nfrom keras.layers import Conv2D\nfrom keras.layers import MaxPooling2D\nfrom keras.layers import Flatten\nfrom keras.layers import Dense\nfrom keras.layers import Dropout, Activation, BatchNormalization\nfrom keras import regularizers\nfrom keras.callbacks import EarlyStopping\nfrom keras.preprocessing.image import ImageDataGenerator\nfrom sklearn.metrics import mean_absolute_error","execution_count":34,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Here is an example of image that will be the input of the CNN:"},{"metadata":{"trusted":true},"cell_type":"code","source":"Image(\"../input/lanlimages/images/images/training_set/val_0/3828-2.913799.jpg\") # The time to failure of this segment is at the file name (2.913799)","execution_count":22,"outputs":[{"output_type":"execute_result","execution_count":22,"data":{"image/jpeg":"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\n","text/plain":"<IPython.core.display.Image object>"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"img_width = 72\nimg_height = 72\nTRAIN_DIR = '../input/lanlimages/images/images/training_set/val_'\nTEST_DIR = '../input/lanlimages/images/images/test_set/'\ntest_images = [TEST_DIR+i for i in os.listdir(TEST_DIR)]","execution_count":23,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"folds = 5\ntrain_images = [[],[],[],[],[]]\nfor fold in range(folds):\n    train_images[fold] = []\n    for i in os.listdir(TRAIN_DIR + str(fold)):\n        train_images[fold].append(TRAIN_DIR + str(fold) + '/' + i)","execution_count":24,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"val_X_cnn = []\nval_y_cnn = []\ntrain_X_cnn = []\ntrain_y_cnn = []\nseg_id_val_cnn = [[],[],[],[],[]]\nseg_id_train_cnn = [[],[],[],[],[]]\nseg_id_test_cnn = []\n\nval_X_cnn.append(train_images[0])\nval_y_cnn.append(np.zeros(len(val_X_cnn[0])))\ntrain_X_cnn.append(train_images[1]+train_images[2]+train_images[3]+train_images[4])\ntrain_y_cnn.append(np.zeros(len(train_X_cnn[0])))\n\nval_X_cnn.append(train_images[1])\nval_y_cnn.append(np.zeros(len(val_X_cnn[1])))\ntrain_X_cnn.append(train_images[0]+train_images[2]+train_images[3]+train_images[4])\ntrain_y_cnn.append(np.zeros(len(train_X_cnn[1])))\n\nval_X_cnn.append(train_images[2])\nval_y_cnn.append(np.zeros(len(val_X_cnn[2])))\ntrain_X_cnn.append(train_images[0]+train_images[1]+train_images[3]+train_images[4])\ntrain_y_cnn.append(np.zeros(len(train_X_cnn[2])))\n\nval_X_cnn.append(train_images[3])\nval_y_cnn.append(np.zeros(len(val_X_cnn[3])))\ntrain_X_cnn.append(train_images[0]+train_images[1]+train_images[2]+train_images[4])\ntrain_y_cnn.append(np.zeros(len(train_X_cnn[3])))\n\nval_X_cnn.append(train_images[4])\nval_y_cnn.append(np.zeros(len(val_X_cnn[4])))\ntrain_X_cnn.append(train_images[0]+train_images[1]+train_images[2]+train_images[3])\ntrain_y_cnn.append(np.zeros(len(train_X_cnn[4])))","execution_count":25,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def prepare_data(list_of_images, dataset):\n    \"\"\"\n    Returns two arrays:\n        x is an array of images\n        y is an array of labels\n    \"\"\"\n    x = [] # images as arrays\n    y = [] # labels\n    seg_id = []\n    \n    for image in list_of_images:\n        x.append(cv2.imread(image,cv2.IMREAD_GRAYSCALE))\n        if dataset != 'test':\n            y.append(float(image.split('-')[-1][:-4])) # [:-4] is to remove the file extension\n        \n        if dataset == 'validation':\n            seg_id.append(image.split('/')[-1].split('-')[0])\n        \n        if dataset == 'test':\n            seg_id.append(image.split('/')[-1].split('.')[0])\n            \n    return x, y, seg_id","execution_count":26,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for fold in range(folds):\n    train_X_cnn[fold], train_y_cnn[fold], seg_id_train_cnn[fold] = prepare_data(train_X_cnn[fold], 'training') #seg_id_train will be []\n    val_X_cnn[fold], val_y_cnn[fold], seg_id_val_cnn[fold] = prepare_data(val_X_cnn[fold], 'validation')\ntest_X_cnn, test_y_cnn, seg_id_test_cnn = prepare_data(test_images, 'test')  #test_y will be []","execution_count":27,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_X_cnn = np.array(train_X_cnn)\nval_X_cnn = np.array(val_X_cnn)\ntest_X_cnn = np.array(test_X_cnn)","execution_count":28,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_X_cnn = train_X_cnn.reshape(train_X_cnn.shape[0], train_X_cnn.shape[1], train_X_cnn.shape[2], train_X_cnn.shape[3], 1)\nval_X_cnn = val_X_cnn.reshape(val_X_cnn.shape[0], val_X_cnn.shape[1], val_X_cnn.shape[2], val_X_cnn.shape[3], 1)\ntest_X_cnn = test_X_cnn.reshape(test_X_cnn.shape[0], test_X_cnn.shape[1], test_X_cnn.shape[2], 1)","execution_count":29,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_X_cnn[0].shape, val_X_cnn[0].shape, test_X_cnn.shape","execution_count":30,"outputs":[{"output_type":"execute_result","execution_count":30,"data":{"text/plain":"((3352, 72, 72, 1), (838, 72, 72, 1), (2624, 72, 72, 1))"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"nb_train_samples = train_X_cnn[0].shape[0]\nnb_validation_samples = val_X_cnn[0].shape[0]\nbatch_size = 64","execution_count":31,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"oof_cnn = np.zeros(len(train_X_cnn[0])+len(val_X_cnn[0]))\nall_y_cnn = np.zeros(len(oof_cnn))\npredictions_cnn = np.zeros(len(test_X_cnn))\n\nfor fold in range (folds):\n    print('fold: ', fold)\n    print('----------')\n    # Initialising the CNN\n    model = Sequential()\n    # Step 1 - Convolution\n    model.add(Conv2D(32, (5, 5), input_shape = (72, 72, 1)))\n    model.add(BatchNormalization())\n    model.add(Activation('relu'))\n    # Step 2 - Pooling\n    model.add(MaxPooling2D(pool_size = (2, 2)))\n    # Adding a second convolutional layer\n    model.add(Conv2D(64, (3, 3), use_bias=False))\n    model.add(BatchNormalization())\n    model.add(Activation('relu'))\n    model.add(MaxPooling2D(pool_size = (2, 2)))\n    # Step 3 - Flattening\n    model.add(Flatten())\n    # Step 4 - Full connection\n    model.add(Dense(units = 2056, kernel_regularizer=regularizers.l2(0.001)))\n    model.add(Dropout(rate=0.3))\n    model.add(Activation('relu'))\n    # Step 5 - Output Layer\n    model.add(Dense(units = 1, activation = 'linear'))\n    # Compiling the CNN\n    model.compile(optimizer = 'Adam', loss = 'mean_absolute_error')\n    train_datagen = ImageDataGenerator(rescale=1./255)\n    val_datagen = ImageDataGenerator(rescale=1./255)\n    test_datagen = ImageDataGenerator(rescale=1./255)\n    train_generator = train_datagen.flow(train_X_cnn[fold], train_y_cnn[fold], batch_size=batch_size, shuffle=False)\n    validation_generator = val_datagen.flow(val_X_cnn[fold], val_y_cnn[fold], batch_size=batch_size, shuffle=False)\n    test_generator = test_datagen.flow(test_X_cnn, batch_size=batch_size, shuffle=False)\n    # EarlyStopping\n    es = EarlyStopping(monitor='val_loss', patience=8, mode='auto', restore_best_weights=True)\n    # Fitting\n    model.fit_generator(train_generator, steps_per_epoch=nb_train_samples // batch_size, callbacks=[es],\n                        epochs=40, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size)\n    # Predicting\n    index_start = len(val_X_cnn[0])*fold\n    index_end = index_start + len(val_X_cnn[0])\n    oof_cnn[index_start:index_end] = model.predict_generator(generator=validation_generator, steps=len(validation_generator), verbose=1).reshape(1,-1)\n    all_y_cnn[index_start:index_end] = val_y_cnn[fold]\n    predictions_cnn += model.predict_generator(generator=test_generator, steps=len(test_generator), verbose=1)[:,0] / folds\n\noof_cnn = np.where(oof_cnn < 0, 0, oof_cnn) # Removing negative predictions\npredictions_cnn = np.where(predictions_cnn < 0, 0, predictions_cnn) # Removing negative predictions\nprint('CV MAE: {}'.format(mean_absolute_error(all_y_cnn, oof_cnn)))","execution_count":32,"outputs":[{"output_type":"stream","text":"fold:  0\n----------\nEpoch 1/1\n52/52 [==============================] - 62s 1s/step - loss: 6.0825 - val_loss: 6.3880\n14/14 [==============================] - 4s 292ms/step\n41/41 [==============================] - 11s 279ms/step\nfold:  1\n----------\nEpoch 1/1\n52/52 [==============================] - 61s 1s/step - loss: 5.5950 - val_loss: 4.0698\n14/14 [==============================] - 4s 280ms/step\n41/41 [==============================] - 11s 257ms/step\nfold:  2\n----------\nEpoch 1/1\n52/52 [==============================] - 61s 1s/step - loss: 5.7288 - val_loss: 5.1672\n14/14 [==============================] - 4s 281ms/step\n41/41 [==============================] - 11s 260ms/step\nfold:  3\n----------\nEpoch 1/1\n52/52 [==============================] - 61s 1s/step - loss: 5.8671 - val_loss: 6.1970\n14/14 [==============================] - 4s 286ms/step\n41/41 [==============================] - 11s 256ms/step\nfold:  4\n----------\nEpoch 1/1\n52/52 [==============================] - 61s 1s/step - loss: 6.3656 - val_loss: 4.7777\n14/14 [==============================] - 4s 304ms/step\n41/41 [==============================] - 11s 270ms/step\nCV MAE: 4.296993799755136\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"g = sns.jointplot(x=all_y_cnn,y=oof_cnn,kind='hex')\nlims = [18,0]\ng.ax_joint.plot(lims, lims)","execution_count":38,"outputs":[{"output_type":"execute_result","execution_count":38,"data":{"text/plain":"[<matplotlib.lines.Line2D at 0x7f5fac45e438>]"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x432 with 3 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{},"cell_type":"markdown","source":"## Submission"},{"metadata":{"trusted":true},"cell_type":"code","source":"submission = pd.read_csv('../input/LANL-Earthquake-Prediction/sample_submission.csv', index_col='seg_id')\nsubmission.time_to_failure = predictions_cnn\nsubmission.to_csv('submission.csv',index=True)","execution_count":39,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Conclusion\n#### This technique give us a reasonable result, considering that we are not using any numerical features. Besides, we can create a more complex neural network combining a MLP (numerical features) with a CNN (images), this can be done with the Keras functional API."}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.6.7"}},"nbformat":4,"nbformat_minor":1}