{"cells":[{"metadata":{},"cell_type":"markdown","source":"제가 만든 모델은 \n 1.  1 COLOR CHANNEL 기반으로 MOBILENET 모델을 만들고 \n 2.  1 COLOR CHANNEL 기반으로 CNN 모델을 만든다.\n 3.  1,2에서 얻은 모델을 앙상블한다. \n 4.  앙상블한 결과를 최종 결과로 제출한다. \n\n이렇게 구성되어 있습니다. \n"},{"metadata":{},"cell_type":"markdown","source":"DP_DIR 이라는 PATH 에는 TRAIN DATA의 일부가 VALIDATION SET으로  작용하기 위해 들어있습니다.\nhttps://www.kaggle.com/gaborfodor/shuffle-csvs 이 분의 코드의 결과 값들입니다.\n대략적으로 말하면 각각의 CATEGORY 인 CSV파일에 대해 전부 실시합니다. ( 즉 340개의 CATEGORY에 대해서 ) \n 1. 각 CATEGORY의 한 CSV파일에서 KEY_ID를 고른다. \n 2. 이 때 KEY_ID의 끝에 2자리를 기준으로 같은 것들을 하나의 파일로 묶는다. 어디로? TRAIN_K34 이런식으로. "},{"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 \nfrom glob import glob\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport ast\nimport re\nimport keras\nimport cv2\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\nfrom tqdm import tqdm\nimport os\nprint(os.listdir(\"../input\"))\nBASE_SIZE = 256\nDP_DIR = '../input/shuffle-csvs/'\nINPUT_DIR = '../input/quickdraw-doodle-recognition/'\nNCSVS = 100\nNCATS = 340\n","execution_count":1,"outputs":[{"output_type":"stream","text":"Using TensorFlow backend.\n","name":"stderr"},{"output_type":"stream","text":"['quickdraw-doodle-recognition', 'shuffle-csvs']\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"from keras.preprocessing.image import ImageDataGenerator\nfrom keras.metrics import top_k_categorical_accuracy\nfrom keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping\nfrom keras.applications.resnet50 import ResNet50, preprocess_input\nfrom keras.layers import Dense, Activation, Flatten, Dropout\nfrom keras.models import Sequential, Model\nfrom keras.optimizers import SGD, Adam\nimport matplotlib.pyplot as plt\n\nfrom keras import backend as K\nfrom keras.layers import Conv2D, MaxPooling2D\nfrom keras.layers import Input, Dense, Activation, Dropout, Flatten\nfrom keras.layers import Reshape, Lambda, BatchNormalization\nfrom keras.layers.merge import add, concatenate\nfrom keras.metrics import top_k_categorical_accuracy","execution_count":2,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"먼저 CATEGORY 별로 데이터를 끌어오기 위해서는 CSV 파일의 이름들을 수정할 필요가 있습니다. 그래서 띄어쓰기 대신에 _으로 대체했습니다. \ndraw_cv2_color 라는 함수는 stroke가 주어지면 그것을 색깔이 있는 사진으로 바꾸는 함수입니다.\n이 때 색깔을 칠하는 기준은 stroke를 거듭해나갈 때마다 색깔이 바뀌도록 해놓았습니다. 그래서 stroke의 번째 수 마다 color의 index가 되게끔 했습닏다. \n\n그렇기 때문에 color가 존재하기 때문에 (imgwidth , imgheight, 3) 이러한 형태이어야 합니다. \n그래서 image_generator_color 함수에서 x[i,:,:,:] 이런식으로 initialize를 해주었습니다.\n또한 reshape 해줄때도 (len(df), size, size, 3)) 이런 형태가 되게끔 했습니다."},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"classes_path = os.listdir(INPUT_DIR + 'train_simplified/')\nclasses_path = sorted(classes_path, key=lambda s: s.lower())\nclass_dict = {x[:-4].replace(\" \", \"_\"):i for i, x in enumerate(classes_path)}\nlabels = {x[:-4].replace(\" \", \"_\") for i, x in enumerate(classes_path)}\n\nn_labels = len(labels)\nprint(\"Number of labels: {}\".format(n_labels))\n\nfileList = glob(INPUT_DIR + \"train_simplified/*.csv\")\n\n\nBASE_SIZE = 256\n\nimg_size = 80\nbatchsize = 512\nline_width = 7\n\n","execution_count":3,"outputs":[{"output_type":"stream","text":"Number of labels: 340\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"colors = [(255, 0, 0) , (255, 255, 0),  (128, 255, 0),  (0, 255, 0), (0, 255, 128), (0, 255, 255), \n          (0, 128, 255), (0, 0, 255), (128, 0, 255), (255, 0, 255)]\n\ndef draw_cv2_color(raw_strokes, size=256, lw=7, time_color=True):\n    img = np.zeros((BASE_SIZE, BASE_SIZE, 3), np.uint8)\n    for t, stroke in enumerate(raw_strokes):\n        for i in range(len(stroke[0]) - 1):\n            color = colors[min(t, len(colors)-1)]\n            _ = cv2.line(img, (stroke[0][i], stroke[1][i]),\n                         (stroke[0][i + 1], stroke[1][i + 1]), color, lw, lineType=cv2.LINE_AA)\n    if size != BASE_SIZE:\n        return cv2.resize(img, (size, size))\n    else:\n        return img\n\n    \ndef image_generator_color(size, batchsize, ks, lw=6):\n    while True:\n        for k in np.random.permutation(ks):\n            filename = os.path.join(DP_DIR, 'train_k{}.csv.gz'.format(k))\n            for df in pd.read_csv(filename, chunksize=batchsize):\n                df['drawing'] = df['drawing'].apply(ast.literal_eval)\n                x = np.zeros((len(df), size, size,3))\n                for i, raw_strokes in enumerate(df.drawing.values):\n                    x[i,:,:,:] = draw_cv2_color(raw_strokes, size=size, lw=lw)\n                x = x / 255.\n                x = x.reshape((len(df), size, size, 3)).astype(np.float32)\n                y = keras.utils.to_categorical(df.y, num_classes=NCATS)\n                yield x, y\n\ndef df_to_image_array_color(df, size, lw=6):\n    df['drawing'] = df['drawing'].apply(ast.literal_eval)\n    x = np.zeros((len(df), size, size,3))\n    for i, raw_strokes in enumerate(df.drawing.values):\n        x[i,:,:,:] = draw_cv2_color(raw_strokes, size=size, lw=lw)\n    x = x.reshape((len(df), size, size, 3)).astype(np.float32)\n    return x\n\ntrain_datagen_color = image_generator_color(size=img_size, batchsize=batchsize,ks=99)\n\n","execution_count":4,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"이번에는 color가 없는 monotone 한 image를 만들기 위한 코드입니다. \ndraw_cv2 는 draw_cv2_color 와 다르게 color를 넣는 부분이 없습니다. 그저 stroke를 잇고, color는 255로 동일합니다. \n따라서 initialize할 때도 ((len(df), size, size)) 와 같이 생겼습니다. \nreshape을 해줄 때도 (len(df), size, size, 1)) 에서 color channel이 1이 되게끔 했습니다.  "},{"metadata":{"trusted":true},"cell_type":"code","source":"\n\ndef draw_cv2(raw_strokes, size=256, lw=6):\n    img = np.zeros((BASE_SIZE, BASE_SIZE), np.uint8)\n    for stroke in raw_strokes:\n        for i in range(len(stroke[0]) - 1):\n            _ = cv2.line(img, (stroke[0][i], stroke[1][i]), (stroke[0][i + 1], stroke[1][i + 1]), 255, lw)\n    if size != BASE_SIZE:\n        return cv2.resize(img, (size, size))\n    else:\n        return img","execution_count":5,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#ADD DATA AUGMENTATION TO BOOST\ndef image_generator(size, batchsize, ks, lw=6):\n    while True:\n        for k in np.random.permutation(ks):\n            filename = os.path.join(DP_DIR, 'train_k{}.csv.gz'.format(k))\n            for df in pd.read_csv(filename, chunksize=batchsize):\n                df['drawing'] = df['drawing'].apply(ast.literal_eval)\n                x = np.zeros((len(df), size, size))\n                for i, raw_strokes in enumerate(df.drawing.values):\n                    x[i] = draw_cv2(raw_strokes, size=size, lw=lw)\n                x = x / 255.\n                x = x.reshape((len(df), size, size, 1)).astype(np.float32)\n                y = keras.utils.to_categorical(df.y, num_classes=NCATS)\n                yield x, y\n\ndef df_to_image_array(df, size=img_size, lw=6):\n    df['drawing'] = df['drawing'].apply(ast.literal_eval)\n    x = np.zeros((len(df), size, size))\n    for i, raw_strokes in enumerate(df.drawing.values):\n        x[i] = draw_cv2(raw_strokes, size=size, lw=lw)\n    x = x / 255.\n    x = x.reshape((len(df), size, size, 1)).astype(np.float32)\n    return x\ntrain_datagen = image_generator(size=img_size, batchsize=batchsize,ks=99)","execution_count":11,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"아래 코드는 test data에 대해서 그림을 그려보는 코드입니다. 위의 color를 넣어서 stroke를 img화 한 것들을 표현한 것입니다. \n(간단화 시각화)\ncolor를 주기 위해서 위와 동일한 방식으로 진행했습니다."},{"metadata":{"trusted":true},"cell_type":"code","source":"def test_generator_color(size, batchsize, lw=6):\n    while True:\n        for df in pd.read_csv(os.path.join(INPUT_DIR,\"test_simplified.csv\"), chunksize=batchsize):\n            df['drawing'] = df['drawing'].apply(ast.literal_eval)\n            x = np.zeros((len(df), img_size, img_size, 3))\n            for i, raw_strokes in enumerate(df.drawing.values):\n                x[i, :, :, :] = draw_cv2_color(raw_strokes, size=img_size, lw=lw)\n            yield x, preprocess_input(x).astype(np.float32)\n            \ntest_datagen_color = test_generator_color(img_size, batchsize, line_width)\n\nx, xi = next(test_datagen_color)\nn = 8\nfig, axs = plt.subplots(nrows=n, ncols=n, sharex=True, sharey=True, figsize=(12, 12))\nfor i in range(n**2):\n    ax = axs[i // n, i % n]\n    ax.imshow(x[i])\n    ax.axis('off')\nplt.tight_layout()\n\nplt.show();","execution_count":13,"outputs":[{"output_type":"stream","text":"Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\nClipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n","name":"stderr"},{"output_type":"display_data","data":{"text/plain":"<Figure size 864x864 with 64 Axes>","image/png":"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\n"},"metadata":{}}]},{"metadata":{"trusted":true},"cell_type":"code","source":"import ast\nimport re\nimport keras\nimport cv2\n\nvalid_df = pd.read_csv(os.path.join(DP_DIR, 'train_k{}.csv.gz'.format(NCSVS - 1)), nrows=30000)\ny_valid = keras.utils.to_categorical(valid_df.y, num_classes=NCATS)\nx_valid = df_to_image_array(valid_df, img_size)\n","execution_count":8,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"이 모델은 color 가 없는 CNN 모델입니다. 보시다시피 CNN layer 3개를 쌓았고, maxpooling을 하였고, overfitting을 방지하기 위한 dropout을 2,3번째 layer에 주었습니다.\n그리고 나서 fully connected layer를 만들어주었습니다. 이 때 총 class가 340개라서 680개의 히든 노드를 만들고, dropout을 0.5로 했습니다. "},{"metadata":{"trusted":true},"cell_type":"code","source":"\ncnn_model = Sequential()\ncnn_model.add(Conv2D(32, kernel_size=(3, 3), padding='same', activation='relu', input_shape=(img_size, img_size, 1)))\ncnn_model.add(MaxPooling2D(pool_size=(2, 2)))\n\ncnn_model.add(Conv2D(64, kernel_size=(3, 3), padding='same', activation='relu'))\ncnn_model.add(MaxPooling2D(pool_size=(2, 2)))\ncnn_model.add(Dropout(0.2))\n\ncnn_model.add(Conv2D(64, kernel_size=(3, 3), padding='same', activation='relu'))\ncnn_model.add(MaxPooling2D(pool_size=(2, 2)))\ncnn_model.add(Dropout(0.1))\n\n\ncnn_model.add(Flatten())\ncnn_model.add(Dense(680, activation='relu'))\ncnn_model.add(Dropout(0.5))\ncnn_model.add(Dense(n_labels, activation='softmax'))\ncnn_model.summary()","execution_count":9,"outputs":[{"output_type":"stream","text":"WARNING: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/keras/backend/tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\nInstructions for updating:\nPlease use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n_________________________________________________________________\nLayer (type)                 Output Shape              Param #   \n=================================================================\nconv2d_1 (Conv2D)            (None, 80, 80, 32)        320       \n_________________________________________________________________\nmax_pooling2d_1 (MaxPooling2 (None, 40, 40, 32)        0         \n_________________________________________________________________\nconv2d_2 (Conv2D)            (None, 40, 40, 64)        18496     \n_________________________________________________________________\nmax_pooling2d_2 (MaxPooling2 (None, 20, 20, 64)        0         \n_________________________________________________________________\ndropout_1 (Dropout)          (None, 20, 20, 64)        0         \n_________________________________________________________________\nconv2d_3 (Conv2D)            (None, 20, 20, 64)        36928     \n_________________________________________________________________\nmax_pooling2d_3 (MaxPooling2 (None, 10, 10, 64)        0         \n_________________________________________________________________\ndropout_2 (Dropout)          (None, 10, 10, 64)        0         \n_________________________________________________________________\nflatten_1 (Flatten)          (None, 6400)              0         \n_________________________________________________________________\ndense_1 (Dense)              (None, 680)               4352680   \n_________________________________________________________________\ndropout_3 (Dropout)          (None, 680)               0         \n_________________________________________________________________\ndense_2 (Dense)              (None, 340)               231540    \n=================================================================\nTotal params: 4,639,964\nTrainable params: 4,639,964\nNon-trainable params: 0\n_________________________________________________________________\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"위의 모델과 구조적으로 같은 모델인데, input shape을 (img_size, img_size, 3) 으로 함으로써 color input을 받을 수 있게 조정했습니다. "},{"metadata":{"trusted":true},"cell_type":"code","source":"\nSTEPS = 1200\nepochs = 15\n\ndef top_3_accuracy(x,y): \n    t3 = top_k_categorical_accuracy(x,y, 3)\n    return t3\n\nreduceLROnPlat = ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=3, \n                                   verbose=1, mode='auto', min_delta=0.005, cooldown=5, min_lr=0.0001)\nearlystop = EarlyStopping(monitor='val_top_3_accuracy', mode='max', patience=5) \ncallbacks = [reduceLROnPlat, earlystop]\n\ncnn_model.compile(loss='categorical_crossentropy',\n              optimizer='adam',\n              metrics=['accuracy', top_3_accuracy])\n\n\ncnn_hist = cnn_model.fit_generator(\n    train_datagen, steps_per_epoch=STEPS, epochs=epochs, verbose=1,\n    validation_data=(x_valid, y_valid),\n    callbacks = callbacks\n)","execution_count":14,"outputs":[{"output_type":"stream","text":"WARNING:tensorflow:From /opt/conda/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\nInstructions for updating:\nUse tf.cast instead.\nEpoch 1/2\n1200/1200 [==============================] - 311s 259ms/step - loss: 3.0294 - acc: 0.3498 - top_3_accuracy: 0.5289 - val_loss: 2.0008 - val_acc: 0.5399 - val_top_3_accuracy: 0.7322\nEpoch 2/2\n   2/1200 [..............................] - ETA: 1:28 - loss: 2.4685 - acc: 0.4580 - top_3_accuracy: 0.6455","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/keras/callbacks.py:1109: RuntimeWarning: Reduce LR on plateau conditioned on metric `val_categorical_accuracy` which is not available. Available metrics are: val_loss,val_acc,val_top_3_accuracy,loss,acc,top_3_accuracy,lr\n  (self.monitor, ','.join(list(logs.keys()))), RuntimeWarning\n","name":"stderr"},{"output_type":"stream","text":"1200/1200 [==============================] - 306s 255ms/step - loss: 2.2077 - acc: 0.4942 - top_3_accuracy: 0.6917 - val_loss: 1.8016 - val_acc: 0.5854 - val_top_3_accuracy: 0.7703\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"모바일 넷이라는 pretrained 된 모델을 사용해보았습니다. resnet 이라는 모델도 사용해보았으나, mobile net이 더 성능이 좋아서 이 모델을 사용하게 되었습니다.\n또한 mobile net을 color가 있는 channel에서도 사용해보았는데, color가 없을 때 더 성능이 좋았기 때문에 1 channel인 경우에만 mobile net을 사용하게 되었습니다. \n\n모델의 구조는 mobile net의 구조와 학습된 가중치를 이용합니다. 그리고 나서 dense layer를 통해서 마지막 fully connected layer를 구성합니다. "},{"metadata":{"trusted":true},"cell_type":"code","source":"\n\nfrom keras.applications import MobileNet\n\nbase_model = MobileNet(input_shape=(img_size, img_size, 1), include_top=False, weights=None, classes=n_labels)\n\n# add a global spatial average pooling layer\nx = base_model.output\nx = Flatten()(x)\n# let's add a fully-connected layer\nx = Dense(1024, activation='relu')(x)\npredictions = Dense(n_labels, activation='softmax')(x)\n# this is the model we will train\nmobile_model = Model(inputs=base_model.input, outputs=predictions)\n\nmobile_model.compile(optimizer=Adam(lr=1e-4), loss='categorical_crossentropy',\n              metrics=['accuracy', top_3_accuracy])\n\ncallbacks = [\n    ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=5,\n                      min_delta=0.005, mode='max', cooldown=3, verbose=1)\n]\n\nmobile_hist = mobile_model.fit_generator(\n    train_datagen, steps_per_epoch=STEPS, epochs=epochs, verbose=1,\n    validation_data=(x_valid, y_valid),\n    callbacks = callbacks\n)","execution_count":15,"outputs":[{"output_type":"stream","text":"Epoch 1/2\n1200/1200 [==============================] - 419s 349ms/step - loss: 4.9467 - acc: 0.0546 - top_3_accuracy: 0.1207 - val_loss: 4.3185 - val_acc: 0.1156 - val_top_3_accuracy: 0.2315\nEpoch 2/2\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/keras/callbacks.py:1109: RuntimeWarning: Reduce LR on plateau conditioned on metric `val_categorical_accuracy` which is not available. Available metrics are: val_loss,val_acc,val_top_3_accuracy,loss,acc,top_3_accuracy,lr\n  (self.monitor, ','.join(list(logs.keys()))), RuntimeWarning\n","name":"stderr"},{"output_type":"stream","text":"1200/1200 [==============================] - 412s 343ms/step - loss: 3.4927 - acc: 0.2398 - top_3_accuracy: 0.4120 - val_loss: 2.9890 - val_acc: 0.3231 - val_top_3_accuracy: 0.5205\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"1 color channel 을 기반으로 하여 cnn 모델과 mobile net모델을 적합했습니다.\n대용량의 데이터이기 때문에 그냥 fit을 사용하지 않았고, fit_generator을 활용해서 image generator의 함수에서 batch 단위로 제공되는 데이터를 적합했습니다. "},{"metadata":{},"cell_type":"markdown","source":"위에서 구성된 2가지 모델을 합쳐서 predict 했습니다. \n\n사실 앙상블에 여러종류가 있고 효과적인 앙상블 method가 boosting이라서 boosting을 구현해보고 싶었으나, 각각의 모델들이 딥러닝 모델인 만큼 헤비하기 때문에 본래 boosting의 취지에 어긋나기 때문에 사용하지 않았습니다.\n그래서 stacking 앙상블 모형을 사용하는것도 고려해보았지만, 각각의 딥러닝 모델들의 아웃풋을 고려하여 meta model을 학습시키는 데에도 시간이 오래걸릴 것 같고, meta model을 만들만큼 여러 base model을 \n만들여력이 없었기 때문에 stacking 앙상블은 사용하지 않았습니다. \n\n그래서 그저 단순하게 각각의 모델들이 각 row에 대해 예측한 embedding 값들을 합쳐서 total embedding 벡터를 기준으로 softmax 함수를 적용해보았습니다. \npred_cnn  + pred_mobile 을 더하는 행위가 바로 앙상블하는 것입니다. "},{"metadata":{"trusted":true},"cell_type":"code","source":"pred_results = []\nchunksize = 10000\nreader = pd.read_csv(INPUT_DIR + 'test_simplified.csv', chunksize=chunksize)\nfor chunk in tqdm(reader):\n    imgs = df_to_image_array(chunk,img_size)\n    pred_cnn = cnn_model.predict(imgs,verbose=1)\n    pred_mobile = mobile_model.predict(imgs, verbose=1)\n    top_3 =  np.argsort(-(pred_cnn + pred_mobile))[:, 0:3]  \n    pred_results.append(top_3)\nprint(\"Finished test predictions...\")\n\nreverse_dict = {v: k for k, v in class_dict.items()}\npred_results = np.concatenate(pred_results)\nprint(\"Finished data prep...\")\n\n\n\n'''\n(2199, 340)\n(112199, 3)\n'''\n\npreds_df = pd.DataFrame({'first': pred_results[:,0], 'second': pred_results[:,1], 'third': pred_results[:,2]})\npreds_df = preds_df.replace(reverse_dict)\n\npreds_df['words'] = preds_df['first'] + \" \" + preds_df['second'] + \" \" + preds_df['third']\n\nsub = pd.read_csv(INPUT_DIR + 'sample_submission.csv', index_col=['key_id'])\nsub['word'] = preds_df.words.values\nsub.to_csv('1class_per_label_proto.csv')\nsub.head()","execution_count":16,"outputs":[{"output_type":"stream","text":"\r0it [00:00, ?it/s]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 134us/step\n10000/10000 [==============================] - 3s 281us/step\n","name":"stdout"},{"output_type":"stream","text":"\r1it [00:10, 10.12s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 100us/step\n10000/10000 [==============================] - 2s 222us/step\n","name":"stdout"},{"output_type":"stream","text":"\r2it [00:18,  9.73s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 96us/step\n10000/10000 [==============================] - 2s 221us/step\n","name":"stdout"},{"output_type":"stream","text":"\r3it [00:27,  9.51s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 96us/step\n10000/10000 [==============================] - 2s 221us/step\n","name":"stdout"},{"output_type":"stream","text":"\r4it [00:36,  9.27s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 96us/step\n10000/10000 [==============================] - 2s 221us/step\n","name":"stdout"},{"output_type":"stream","text":"\r5it [00:45,  9.19s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 96us/step\n10000/10000 [==============================] - 2s 222us/step\n","name":"stdout"},{"output_type":"stream","text":"\r6it [00:54,  9.14s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 99us/step\n10000/10000 [==============================] - 2s 222us/step\n","name":"stdout"},{"output_type":"stream","text":"\r7it [01:03,  9.03s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 95us/step\n10000/10000 [==============================] - 2s 222us/step\n","name":"stdout"},{"output_type":"stream","text":"\r8it [01:12,  9.03s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 97us/step\n10000/10000 [==============================] - 2s 221us/step\n","name":"stdout"},{"output_type":"stream","text":"\r9it [01:21,  9.03s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 96us/step\n10000/10000 [==============================] - 2s 221us/step\n","name":"stdout"},{"output_type":"stream","text":"\r10it [01:30,  8.93s/it]","name":"stderr"},{"output_type":"stream","text":"10000/10000 [==============================] - 1s 96us/step\n10000/10000 [==============================] - 2s 221us/step\n","name":"stdout"},{"output_type":"stream","text":"\r11it [01:39,  8.95s/it]","name":"stderr"},{"output_type":"stream","text":"2199/2199 [==============================] - 0s 102us/step\n2199/2199 [==============================] - 1s 239us/step\n","name":"stdout"},{"output_type":"stream","text":"\r12it [01:41,  6.86s/it]","name":"stderr"},{"output_type":"stream","text":"Finished test predictions...\nFinished data prep...\n","name":"stdout"},{"output_type":"stream","text":"\n","name":"stderr"},{"output_type":"execute_result","execution_count":16,"data":{"text/plain":"                                                  word\nkey_id                                                \n9000003627287624               radio snorkel motorbike\n9000010688666847             sandwich hockey_puck pool\n9000023642890129  grass The_Great_Wall_of_China castle\n9000038588854897                    mountain tent nail\n9000052667981386           fireplace campfire scissors","text/html":"<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>word</th>\n    </tr>\n    <tr>\n      <th>key_id</th>\n      <th></th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>9000003627287624</th>\n      <td>radio snorkel motorbike</td>\n    </tr>\n    <tr>\n      <th>9000010688666847</th>\n      <td>sandwich hockey_puck pool</td>\n    </tr>\n    <tr>\n      <th>9000023642890129</th>\n      <td>grass The_Great_Wall_of_China castle</td>\n    </tr>\n    <tr>\n      <th>9000038588854897</th>\n      <td>mountain tent nail</td>\n    </tr>\n    <tr>\n      <th>9000052667981386</th>\n      <td>fireplace campfire scissors</td>\n    </tr>\n  </tbody>\n</table>\n</div>"},"metadata":{}}]},{"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}