{"cells":[{"metadata":{},"cell_type":"markdown","source":"CNN ( CNN 3layer + FC ) + 3channel level"},{"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\nimport matplotlib.pyplot as plt\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","execution_count":19,"outputs":[]},{"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 = 256\nline_width = 7\n\ncolors = [(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(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(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(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(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(raw_strokes, size=size, lw=lw)\n    x = x.reshape((len(df), size, size, 3)).astype(np.float32)\n    return x\n\n\n\n\ntrain_datagen = image_generator(size=img_size, batchsize=batchsize,ks=99)\nfrom keras.applications.resnet50 import ResNet50, preprocess_input\ndef test_generator(img_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(raw_strokes, size=img_size, lw=lw)\n            yield x, preprocess_input(x).astype(np.float32)\n            \ntest_datagen = test_generator(img_size, batchsize, line_width)\n\n\nSTEPS = 1200\nepochs = 15","execution_count":17,"outputs":[{"output_type":"stream","text":"Number of labels: 340\n","name":"stdout"}]},{"metadata":{},"cell_type":"markdown","source":"TEST data를 통해 시각화 - 컬리입힘. stroke 하는 시간을 기준으로 하여 "},{"metadata":{"trusted":true},"cell_type":"code","source":"test_datagen = test_generator(img_size, batchsize, line_width)\nx, xi = next(test_datagen)\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()\nfig.savefig('gs.png', dpi=300)\nplt.show();","execution_count":20,"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)\n\n\nx_valid = df_to_image_array(valid_df, img_size)\ny_valid = keras.utils.to_categorical(valid_df.y, num_classes=NCATS)\nprint(x_valid.shape)","execution_count":24,"outputs":[{"output_type":"stream","text":"(30000, 80, 80, 3)\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"import keras\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.models import Model\nfrom keras.models import Sequential\n\nfrom keras.metrics import top_k_categorical_accuracy\nfrom keras.callbacks import ModelCheckpoint, ReduceLROnPlateau, EarlyStopping\n\ncnn_model = Sequential()\ncnn_model.add(Conv2D(32, kernel_size=(3, 3), padding='same', activation='relu', input_shape=(img_size, img_size,3)))\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":27,"outputs":[{"output_type":"stream","text":"_________________________________________________________________\nLayer (type)                 Output Shape              Param #   \n=================================================================\nconv2d_18 (Conv2D)           (None, 80, 80, 32)        896       \n_________________________________________________________________\nmax_pooling2d_17 (MaxPooling (None, 40, 40, 32)        0         \n_________________________________________________________________\nconv2d_19 (Conv2D)           (None, 40, 40, 64)        18496     \n_________________________________________________________________\nmax_pooling2d_18 (MaxPooling (None, 20, 20, 64)        0         \n_________________________________________________________________\ndropout_12 (Dropout)         (None, 20, 20, 64)        0         \n_________________________________________________________________\nconv2d_20 (Conv2D)           (None, 20, 20, 64)        36928     \n_________________________________________________________________\nmax_pooling2d_19 (MaxPooling (None, 10, 10, 64)        0         \n_________________________________________________________________\ndropout_13 (Dropout)         (None, 10, 10, 64)        0         \n_________________________________________________________________\nflatten_4 (Flatten)          (None, 6400)              0         \n_________________________________________________________________\ndense_7 (Dense)              (None, 680)               4352680   \n_________________________________________________________________\ndropout_14 (Dropout)         (None, 680)               0         \n_________________________________________________________________\ndense_8 (Dense)              (None, 340)               231540    \n=================================================================\nTotal params: 4,640,540\nTrainable params: 4,640,540\nNon-trainable params: 0\n_________________________________________________________________\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"from keras.preprocessing.image import ImageDataGenerator\nfrom keras.metrics import top_k_categorical_accuracy\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\nhist = cnn_model.fit_generator(\n    train_datagen, steps_per_epoch=STEPS, epochs=1, verbose=1,\n    validation_data=(x_valid, y_valid),\n    callbacks = callbacks\n)","execution_count":29,"outputs":[{"output_type":"stream","text":"Epoch 1/2\n1200/1200 [==============================] - 304s 253ms/step - loss: 2.0447 - acc: 0.5243 - top_3_accuracy: 0.7215 - val_loss: 12.1108 - val_acc: 0.2445 - val_top_3_accuracy: 0.9420\nEpoch 2/2\n   3/1200 [..............................] - ETA: 52s - loss: 1.9900 - acc: 0.5430 - top_3_accuracy: 0.7344","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 [==============================] - 299s 249ms/step - loss: 1.9572 - acc: 0.5433 - top_3_accuracy: 0.7387 - val_loss: 13.2120 - val_acc: 0.1767 - val_top_3_accuracy: 0.9310\n","name":"stdout"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"cnnmodel_json = cnn_model.to_json()\nwith open(\"cnn_model.json\", \"w\") as json_file : \n    json_file.write(cnnmodel_json)\n\n\n\ncnn_model.save_weights(\"cnn_color.h5\")\nprint(\"Saved model to disk\")","execution_count":30,"outputs":[{"output_type":"stream","text":"Saved model to disk\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}