{"cells":[{"metadata":{},"cell_type":"markdown","source":"![image.png](data:image/png;base64,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)","execution_count":null},{"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\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 read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 5GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## IMPORTS:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"import tensorflow as tf\ntf.test.gpu_device_name()","execution_count":null,"outputs":[]},{"metadata":{"_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","trusted":true},"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n%matplotlib inline \nimport cv2\nimport os\nfrom tqdm import tqdm","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Checking Out Inception","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"from keras.applications.inception_v3 import InceptionV3\nmodel = InceptionV3()\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Getting Tensorflow Read","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"from tensorflow.keras.preprocessing.image import load_img\nfrom tensorflow.keras.preprocessing.image import img_to_array\nfrom tensorflow.keras.applications.inception_v3 import preprocess_input\nfrom tensorflow.keras.applications.inception_v3 import decode_predictions","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Loading Images:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"chair = []\n\nfor filepath in tqdm(os.listdir('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/chair/')):\n    src = cv2.imread('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/chair/{0}'.format(filepath),1)\n    src = cv2.resize(src, (256, 256))\n    chair.append(src)\n\nchair = np.array(chair)\n\nbed = []\n\nfor filepath in tqdm(os.listdir('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/bed/')):\n    src = cv2.imread('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/table/{0}'.format(filepath),1)\n    src = cv2.resize(src, (256, 256))\n    bed.append(src)\n\nbed = np.array(bed)\n\ntable = []\n\nfor filepath in tqdm(os.listdir('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/table/')):\n    src = cv2.imread('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/table/{0}'.format(filepath),1)\n    src = cv2.resize(src, (256, 256))\n    table.append(src)\n\ntable = np.array(table)\n\nsofa = []\n\nfor filepath in tqdm(os.listdir('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/sofa/')):\n    src = cv2.imread('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/sofa/{0}'.format(filepath),1)\n    src = cv2.resize(src, (256, 256))\n    sofa.append(src)\n\nsofa = np.array(sofa)\n\nswivle_chair = []\n\nfor filepath in tqdm(os.listdir('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/swivelchair/')):\n    src = cv2.imread('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/train/swivelchair/{0}'.format(filepath),1)\n    src = cv2.resize(src, (256, 256))\n    swivle_chair.append(src)\n\nswivle_chair = np.array(swivle_chair)\n\n\nprint(chair.shape, table.shape, bed.shape, swivle_chair.shape, sofa.shape)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Trying out Inception V3","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"image = chair[0]\n\nplt.imshow(image)\n\nimage = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))\n\nimage = preprocess_input(image)\n\nmodel = InceptionV3()\n\nyhat = model.predict(image)\n\nlabel = decode_predictions(yhat)\n\nlabel = label[0][0]\nprint('%s (%.5f%%)' % (label[1], label[2]*100))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Let's take a look at the yhat raw","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"print(yhat.shape, '\\n', yhat)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Finally Building A Transferlearning Model, I have no clue how to submit from a Kaggle Kernel","execution_count":null},{"metadata":{},"cell_type":"markdown","source":"### Building The Training Set:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"x = np.array([i for i in chair] + [i for i in table] + [i for i in bed] + [i for i in swivle_chair] + [i for i in sofa])\ny_sparse = np.array([1 for _ in range(chair.shape[0])] + [4 for _ in range(table.shape[0])] + [0 for _ in range(bed.shape[0])] + [3 for _ in range(swivle_chair.shape[0])] + [2 for _ in range(sofa.shape[0])])\ny_encoded = []\n\nfor i in y_sparse:\n    a = [0 for _ in range(5)]\n    a[i] = 1\n    y_encoded.append(a)\ny_encoded = np.array(y_encoded)\n\nprint(x.shape, y_encoded.shape)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Building The Model","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"from tensorflow.keras.models import Model\nfrom tensorflow.keras.layers import Dense\nfrom tensorflow.keras.layers import Flatten, GlobalAveragePooling2D, Concatenate, Dropout\nimport tensorflow as tf","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model = InceptionV3(include_top=False, input_shape=(256, 256, 3))\nmodel.trainable = True\n\ngap1 = GlobalAveragePooling2D()(model.layers[-1].output)\nflat1 = Flatten()(gap1)\nclass1 = Dense(1024, activation='relu')(flat1)\nclass1 = Dropout(0.1)(class1)\nclass2 = Dense(256, activation='relu')(class1)\nclass2 = Dropout(0.1)(class2)\nclass3 = Dense(32, activation='relu')(class2)\noutput = Dense(5, activation='softmax')(class3)\n\nmodel = Model(inputs=model.inputs, outputs=output)\n\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['acc'])","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Training it","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"model.fit(x, y_encoded, epochs=5, validation_split=0.1, shuffle=True)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Preparing Submission:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"test = []\nfiles = sorted(os.listdir('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/test/'))\nfor filepath in tqdm(files):\n    src = cv2.imread('/kaggle/input/day-3-kaggle-competition/data_comp/data_comp/test/{0}'.format(filepath),1)\n    src = cv2.resize(src, (256, 256))\n    test.append(src)\n\ntest = np.array(test)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"y_pred = model.predict(test, verbose=1)\ny_peed = [np.argmax(i) for i in y_pred]\nsubmission = pd.DataFrame({'image': files, 'target':y_peed})\nsubmission.to_csv('submission_basic.csv', index=False)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Spicing Up the Model for LoLs:","execution_count":null},{"metadata":{"trusted":true},"cell_type":"code","source":"model1 = InceptionV3(include_top=False, input_shape=(256, 256, 3))\nmodel1.trainable = True\n\ngap1 = GlobalAveragePooling2D()(model1.layers[-1].output)\nflat1 = Flatten()(gap1)\nout1 = Dense(1024, activation='relu')(flat1)\n\ninput2 = tf.keras.layers.Input([256, 256, 3])\nx = tf.keras.applications.inception_v3.preprocess_input(input2)\nmodel2 = tf.keras.applications.InceptionV3()\nout2 = model2(x)\n\nmergedOut = Concatenate()([out1,out2])\nclass1 = Dense(1024, activation='relu')(mergedOut)\nclass1 = Dropout(0.1)(class1)\nclass1 = Dense(1024, activation='relu')(class1)\nclass1 = Dropout(0.1)(class1)\nclass1 = Dense(516, activation='relu')(class1)\nclass1 = Dropout(0.1)(class1)\nclass2 = Dense(256, activation='relu')(class1)\nclass2 = Dropout(0.1)(class2)\nclass3 = Dense(32, activation='relu')(class2)\noutput = Dense(5, activation='softmax')(class3)\n\n\nmodel = Model(inputs=[model1.inputs, input2], outputs=[output])\nmodel.summary()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['acc'])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(x.shape, y_encoded.shape)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model.fit([x, x], y_encoded, epochs=250, shuffle=True, batch_size=32, validation_split=0.15)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}