{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"resnet-lstm-flickr-v3.ipynb","provenance":[],"collapsed_sections":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"accelerator":"GPU"},"cells":[{"cell_type":"markdown","metadata":{"id":"jVZj7qrM1EdH","colab_type":"text"},"source":["### ResNet-LSTM\n","- Augment dataset using Flickr images (use only still images from the EmotiW video clips)\n","- ResNet-50 (standard)\n","- LSTM\n","\n","Best Model:\n","- epoch 6: loss: 1.0660 - accuracy: 0.4564 - val_loss: 1.0929 - val_accuracy: 0.4402\n","\n","Notes:\n","- May have too many parameters\n"]},{"cell_type":"code","metadata":{"id":"sNI9YJehDOYd","colab_type":"code","outputId":"6ebeee46-a128-42c3-9e26-b4a00f8697e9","executionInfo":{"status":"ok","timestamp":1590256958522,"user_tz":420,"elapsed":42412,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":124}},"source":["from google.colab import drive\n","drive.mount('/content/drive')\n","\n"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n","\n","Enter your authorization code:\n","··········\n","Mounted at /content/drive\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"uUJ3z_twUrI9","colab_type":"code","colab":{}},"source":["import os\n","import numpy as np\n","import matplotlib.pyplot as plt\n","import tensorflow as tf\n"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"ryzDii47sEv6","colab_type":"code","colab":{}},"source":["!cp 'drive/My Drive/cs231n-project/datasets/emotiw/train_frames.tar.gz' ."],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"2TJ2_a0X9W9h","colab_type":"code","colab":{}},"source":["!tar -xzf train_frames.tar.gz"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"IWIAQddxMo5-","colab_type":"code","colab":{}},"source":["!cp 'drive/My Drive/cs231n-project/datasets/emotiw/val_frames.tar.gz' .\n","!tar -xzf val_frames.tar.gz"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"xdjXH6tOyA7S","colab_type":"code","colab":{}},"source":["!cp 'drive/My Drive/cs231n-project/datasets/flickr.tar.gz' .\n","!tar -xzf flickr.tar.gz"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"8nohApcF9os7","colab_type":"code","outputId":"fb8c6920-57fc-457d-9cff-015c05507ac6","executionInfo":{"status":"ok","timestamp":1590258384998,"user_tz":420,"elapsed":71853,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":52}},"source":["!ls"],"execution_count":0,"outputs":[{"output_type":"stream","text":["drive\tflickr.tar.gz  train_frames\t    val_frames\n","flickr\tsample_data    train_frames.tar.gz  val_frames.tar.gz\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"SqVJ-DkjGo4K","colab_type":"code","outputId":"7f155860-5e1e-4eb1-968e-ccb62a82229a","executionInfo":{"status":"ok","timestamp":1590222627380,"user_tz":420,"elapsed":213554,"user":{"displayName":"Tom Tom Jin","photoUrl":"","userId":"01893011177174686364"}},"colab":{"base_uri":"https://localhost:8080/","height":306}},"source":["!nvidia-smi"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Sat May 23 08:30:23 2020       \n","+-----------------------------------------------------------------------------+\n","| NVIDIA-SMI 440.82       Driver Version: 418.67       CUDA Version: 10.1     |\n","|-------------------------------+----------------------+----------------------+\n","| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n","| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n","|===============================+======================+======================|\n","|   0  Tesla P100-PCIE...  Off  | 00000000:00:04.0 Off |                    0 |\n","| N/A   41C    P0    27W / 250W |      0MiB / 16280MiB |      0%      Default |\n","+-------------------------------+----------------------+----------------------+\n","                                                                               \n","+-----------------------------------------------------------------------------+\n","| Processes:                                                       GPU Memory |\n","|  GPU       PID   Type   Process name                             Usage      |\n","|=============================================================================|\n","|  No running processes found                                                 |\n","+-----------------------------------------------------------------------------+\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"h34fRdSBQuas","colab_type":"code","colab":{}},"source":["import numpy as np\n","import random\n","import cv2\n","from os import listdir\n","from os.path import isfile, join\n","\n","class DataGenerator(tf.keras.utils.Sequence):\n","    \"\"\"\n","    Generates data based on a directory of frames\n","    \"\"\"\n","    def __init__(self, dir, flickr_dir, batch_size=32, frames_to_use=-1, shuffle=True):\n","        self.frames_to_use = frames_to_use\n","        self.batch_size = batch_size\n","        self.dir = dir\n","        self.flickr_dir = flickr_dir\n","        self.shuffle = shuffle\n","        self.classes = self.find_classes()\n","        self.video_names, self.video_to_class, self.num_samples, self.min_frames = self.find_samples()\n","        self.on_epoch_end()\n","        print(f\"Found {self.num_samples} frames belonging to {len(self.video_names)} videos belonging to {len(self.classes)} classes.\")\n","        print(f\"Min frames determined to be {self.min_frames}\")\n","\n","    def find_classes(self):\n","        category_folders = [f for f in listdir(self.dir) if not isfile(join(self.dir, f))]\n","        return sorted(list(set(category_folders)))\n","\n","    def find_samples(self):\n","        \"\"\"\n","        Returns the following video frame structure:\n","\n","        {\n","            \"vid1\": [\n","                \"frame1.jpg\",\n","                \"frame2.jpg\",\n","                ...\n","            ]\n","        }\n","\n","        \"\"\"\n","        num_samples = 0\n","        min_frames = -1\n","        video_map = []\n","        vid_to_cat = {}\n","        completed_videos = {}\n","        category_folders = [f for f in listdir(self.dir) if not isfile(join(self.dir, f))]\n","        for category_folder in category_folders:\n","            cat_path = join(self.dir, category_folder)\n","            frames = [f for f in listdir(cat_path) if isfile(join(cat_path, f))]\n","            for frame in frames:\n","                # frame = frame_101_7.mp4_8.jpg\n","                frame_arr = frame.split(\".mp4_\")\n","                if frame_arr[0] not in completed_videos:\n","                    vid_name = join(cat_path, frame)\n","                    vid_to_cat[vid_name] = category_folder\n","                    video_map.append(vid_name)\n","                    completed_videos[frame_arr[0]] = True\n","\n","        if self.flickr_dir is not None:\n","            # Inject the Flickr photos\n","            category_folders = [f for f in listdir(self.flickr_dir) if not isfile(join(self.flickr_dir, f))]\n","            for category_folder in category_folders:\n","                cat_path = join(self.flickr_dir, category_folder)\n","                photos = [f for f in listdir(cat_path) if isfile(join(cat_path, f))]\n","                for photo in photos:\n","                    photo = join(cat_path, photo)\n","                    if category_folder == \"positive\":\n","                        vid_to_cat[photo] = \"1\"\n","                    if category_folder == \"neutral\":\n","                        vid_to_cat[photo] = \"2\"\n","                    if category_folder == \"negative\":\n","                        vid_to_cat[photo] = \"3\"\n","                    video_map.append(photo)\n","\n","        return video_map, vid_to_cat, len(vid_to_cat), min_frames\n","\n","    def __len__(self):\n","        \"\"\"\n","        Denotes the number of batches per epoch\n","        \"\"\"\n","        return int(np.floor(self.num_samples / self.batch_size))\n","\n","    def __getitem__(self, index):\n","        \"\"\"\n","        Generate one batch of data\n","        \"\"\"\n","        video_names = self.video_names[index*self.batch_size:(index+1)*self.batch_size]\n","\n","        # print(f\"Working on batch {index} with {len(video_names)} videos\")\n","        X = np.zeros((len(video_names), IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)\n","        y = []\n","        i = 0\n","        for vid in video_names:\n","            # print(\"   \" + frame)\n","            img = cv2.imread(vid)\n","            img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n","            img = cv2.resize(img, (IMG_WIDTH, IMG_HEIGHT), interpolation = cv2.INTER_CUBIC)\n","            X[i, :, :, :] = img\n","\n","            y.append(int(self.video_to_class[vid]) - 1)\n","            # print(f\"{vid} - {int(self.video_to_class[vid]) - 1}\")\n","            i += 1\n","        y = np.array(y)\n","        return X, tf.keras.utils.to_categorical(y, num_classes=len(self.classes))\n","\n","    def on_epoch_end(self):\n","        # print(\"on_epoch_end\")\n","        if self.shuffle == True:\n","            np.random.shuffle(self.video_names)\n","\n","\n"],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"yQSLMAheB0hg","colab_type":"code","colab":{}},"source":["#\n","# CONFIGURATION\n","#\n","# Define any constants for the model here\n","#\n","\n","IMG_WIDTH = 480\n","IMG_HEIGHT = 320\n","BATCH_SIZE = 32\n","BASE_NAME = \"resnet50\"\n","MODEL_NAME = \"resnet-lstm-flickr-v3\""],"execution_count":0,"outputs":[]},{"cell_type":"code","metadata":{"id":"a0Q2ZNUPoblv","colab_type":"code","outputId":"8dbd8609-8cd0-4581-c033-b7c5cf3ca5e0","executionInfo":{"status":"ok","timestamp":1590259680707,"user_tz":420,"elapsed":8015,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":86}},"source":["train_generator = DataGenerator(\"train_frames\", \"flickr\", batch_size=BATCH_SIZE)\n","validation_generator = DataGenerator(\"val_frames\", None, batch_size=BATCH_SIZE)\n","\n","X, y = train_generator.__getitem__(0)\n"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Found 12836 frames belonging to 12836 videos belonging to 3 classes.\n","Min frames determined to be -1\n","Found 766 frames belonging to 766 videos belonging to 3 classes.\n","Min frames determined to be -1\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"SeNZR0rRVr_x","colab_type":"code","outputId":"5546b0fd-db06-4c15-c27c-086b272e2eae","executionInfo":{"status":"ok","timestamp":1590259690259,"user_tz":420,"elapsed":2579,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":274}},"source":["def show_batch(image_batch, label_batch):\n","    plt.figure(figsize=(30,30))\n","    for n in range(4):\n","          ax = plt.subplot(5,5,n+1)\n","          plt.imshow(image_batch[n])\n","          plt.title(label_batch[n])\n","          plt.axis('off')\n","image_batch, label_batch = train_generator.__getitem__(1)\n","show_batch(image_batch, label_batch)"],"execution_count":0,"outputs":[{"output_type":"stream","text":["/usr/local/lib/python3.6/dist-packages/matplotlib/text.py:1165: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n","  if s != self._text:\n"],"name":"stderr"},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 2160x2160 with 4 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"1Jsw0mhWWPLP","colab_type":"code","outputId":"c60173b1-38c3-40c2-f6af-6e4f59a19023","executionInfo":{"status":"ok","timestamp":1590259781730,"user_tz":420,"elapsed":6710,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":416}},"source":["from pathlib import Path\n","\n","IMG_SHAPE = (IMG_HEIGHT, IMG_WIDTH, 3)\n","\n","Path(f\"drive/My Drive/checkpoints/{MODEL_NAME}\").mkdir(parents=True, exist_ok=True)\n","checkpoint_path = \"drive/My Drive/checkpoints/\" + MODEL_NAME + \"/cp-{epoch:04d}.ckpt\"\n","\n","# Create a callback that saves the model's weights every 1 epochs\n","cp_callback = tf.keras.callbacks.ModelCheckpoint(\n","    filepath=checkpoint_path, \n","    verbose=1,\n","    save_weights_only=True,\n","    period=1)\n","\n","def create_model(inputs):\n","    # Extract ResNet part of the model\n","    base_model = get_base_model()\n","    base_model.trainable = False\n","    x = base_model(inputs)\n","    x = tf.keras.layers.Flatten()(x)\n","    x = tf.keras.layers.Dense(256, activation='relu')(x)\n","    x = tf.keras.layers.Dropout(0.5)(x)\n","    x = tf.keras.layers.Dense(256, activation='relu')(x)\n","    x = tf.keras.layers.Dense(3, activation='softmax')(x)\n","\n","    model = tf.keras.Model(inputs=inputs, outputs=x)\n","    model.compile(optimizer='adam',\n","                  loss = 'categorical_crossentropy',\n","                  metrics=['accuracy'])\n","    return model\n","\n","def get_base_model(model_name=\"resnet50\"):\n","    if model_name == 'inception_v3':\n","        return tf.keras.applications.InceptionV3(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'xception':\n","        return tf.keras.applications.Xception(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'vgg16':\n","        return tf.keras.applications.VGG16(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'vgg19':\n","        return tf.keras.applications.VGG19(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'resnet50':\n","        return tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    else:\n","        raise ValueError(f\"Cannot find base model {model_name}\")\n","\n","inputs = tf.keras.Input(shape=(IMG_HEIGHT, IMG_WIDTH, 3))\n","model = create_model(inputs)\n","model.summary()\n","\n","\n"],"execution_count":0,"outputs":[{"output_type":"stream","text":["WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n","Model: \"model_4\"\n","_________________________________________________________________\n","Layer (type)                 Output Shape              Param #   \n","=================================================================\n","input_10 (InputLayer)        [(None, 320, 480, 3)]     0         \n","_________________________________________________________________\n","resnet50 (Model)             (None, 10, 15, 2048)      23587712  \n","_________________________________________________________________\n","flatten (Flatten)            (None, 307200)            0         \n","_________________________________________________________________\n","dense_10 (Dense)             (None, 256)               78643456  \n","_________________________________________________________________\n","dropout_3 (Dropout)          (None, 256)               0         \n","_________________________________________________________________\n","dense_11 (Dense)             (None, 256)               65792     \n","_________________________________________________________________\n","dense_12 (Dense)             (None, 3)                 771       \n","=================================================================\n","Total params: 102,297,731\n","Trainable params: 78,710,019\n","Non-trainable params: 23,587,712\n","_________________________________________________________________\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"FQ8vLSyJXYco","colab_type":"code","outputId":"f03dbecb-ed04-4387-8c73-256358fc4106","executionInfo":{"status":"ok","timestamp":1590259791015,"user_tz":420,"elapsed":15979,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":34}},"source":["initial_epochs = 30\n","\n","# Try evaluating the model for a few rounds\n","loss0, accuracy0 = model.evaluate(validation_generator, steps = 3)"],"execution_count":0,"outputs":[{"output_type":"stream","text":["3/3 [==============================] - 0s 128ms/step - loss: 1.6773 - accuracy: 0.2917\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"4zNv1uzSQwvw","colab_type":"code","outputId":"0cf52e6f-0c32-4b78-ad61-05d3e97eab23","executionInfo":{"status":"ok","timestamp":1590259794992,"user_tz":420,"elapsed":978,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":34}},"source":["validation_generator.batch_size"],"execution_count":0,"outputs":[{"output_type":"execute_result","data":{"text/plain":["32"]},"metadata":{"tags":[]},"execution_count":46}]},{"cell_type":"code","metadata":{"id":"AgFMltHSXdt4","colab_type":"code","outputId":"de8d5a32-088b-46aa-86f9-b3eab64d3d75","executionInfo":{"status":"error","timestamp":1590262575265,"user_tz":420,"elapsed":2778185,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":1000}},"source":["import pickle\n","history = model.fit(\n","          train_generator,\n","          epochs=initial_epochs,\n","          callbacks=[cp_callback],\n","          validation_data=validation_generator\n",")\n","\n","with open(f\"drive/My Drive/checkpoints/{MODEL_NAME}/history.pkl\", 'wb') as handle:\n","    pickle.dump(history.history, handle)"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Epoch 1/30\n","401/401 [==============================] - ETA: 0s - loss: 4.2207 - accuracy: 0.4236\n","Epoch 00001: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0001.ckpt\n","401/401 [==============================] - 164s 409ms/step - loss: 4.2207 - accuracy: 0.4236 - val_loss: 1.1467 - val_accuracy: 0.4144\n","Epoch 2/30\n","401/401 [==============================] - ETA: 0s - loss: 1.2007 - accuracy: 0.4657\n","Epoch 00002: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0002.ckpt\n","401/401 [==============================] - 164s 409ms/step - loss: 1.2007 - accuracy: 0.4657 - val_loss: 1.1901 - val_accuracy: 0.3818\n","Epoch 3/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1985 - accuracy: 0.4717\n","Epoch 00003: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0003.ckpt\n","401/401 [==============================] - 155s 386ms/step - loss: 1.1985 - accuracy: 0.4717 - val_loss: 1.1442 - val_accuracy: 0.4185\n","Epoch 4/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1958 - accuracy: 0.4580\n","Epoch 00004: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0004.ckpt\n","401/401 [==============================] - 154s 384ms/step - loss: 1.1958 - accuracy: 0.4580 - val_loss: 1.1390 - val_accuracy: 0.4062\n","Epoch 5/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1774 - accuracy: 0.4572\n","Epoch 00005: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0005.ckpt\n","401/401 [==============================] - 153s 381ms/step - loss: 1.1774 - accuracy: 0.4572 - val_loss: 1.4063 - val_accuracy: 0.3845\n","Epoch 6/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0660 - accuracy: 0.4564\n","Epoch 00006: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0006.ckpt\n","401/401 [==============================] - 152s 378ms/step - loss: 1.0660 - accuracy: 0.4564 - val_loss: 1.0929 - val_accuracy: 0.4402\n","Epoch 7/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1674 - accuracy: 0.4437\n","Epoch 00007: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0007.ckpt\n","401/401 [==============================] - 151s 376ms/step - loss: 1.1674 - accuracy: 0.4437 - val_loss: 1.1744 - val_accuracy: 0.3845\n","Epoch 8/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1232 - accuracy: 0.4374\n","Epoch 00008: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0008.ckpt\n","401/401 [==============================] - 151s 376ms/step - loss: 1.1232 - accuracy: 0.4374 - val_loss: 1.1544 - val_accuracy: 0.3954\n","Epoch 9/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0712 - accuracy: 0.4423\n","Epoch 00009: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0009.ckpt\n","401/401 [==============================] - 153s 381ms/step - loss: 1.0712 - accuracy: 0.4423 - val_loss: 1.1014 - val_accuracy: 0.4321\n","Epoch 10/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1139 - accuracy: 0.4360\n","Epoch 00010: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0010.ckpt\n","401/401 [==============================] - 155s 387ms/step - loss: 1.1139 - accuracy: 0.4360 - val_loss: 1.1579 - val_accuracy: 0.3927\n","Epoch 11/30\n","401/401 [==============================] - ETA: 0s - loss: 1.2379 - accuracy: 0.4281\n","Epoch 00011: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0011.ckpt\n","401/401 [==============================] - 153s 382ms/step - loss: 1.2379 - accuracy: 0.4281 - val_loss: 1.1480 - val_accuracy: 0.3872\n","Epoch 12/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0681 - accuracy: 0.4262\n","Epoch 00012: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0012.ckpt\n","401/401 [==============================] - 154s 384ms/step - loss: 1.0681 - accuracy: 0.4262 - val_loss: 1.1180 - val_accuracy: 0.4443\n","Epoch 13/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0849 - accuracy: 0.4378\n","Epoch 00013: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0013.ckpt\n","401/401 [==============================] - 156s 389ms/step - loss: 1.0849 - accuracy: 0.4378 - val_loss: 1.1628 - val_accuracy: 0.3886\n","Epoch 14/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0813 - accuracy: 0.4137\n","Epoch 00014: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0014.ckpt\n","401/401 [==============================] - 157s 390ms/step - loss: 1.0813 - accuracy: 0.4137 - val_loss: 1.1624 - val_accuracy: 0.3791\n","Epoch 15/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0470 - accuracy: 0.4228\n","Epoch 00015: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0015.ckpt\n","401/401 [==============================] - 158s 394ms/step - loss: 1.0470 - accuracy: 0.4228 - val_loss: 1.1679 - val_accuracy: 0.3899\n","Epoch 16/30\n","401/401 [==============================] - ETA: 0s - loss: 1.0913 - accuracy: 0.4249\n","Epoch 00016: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0016.ckpt\n","401/401 [==============================] - 158s 393ms/step - loss: 1.0913 - accuracy: 0.4249 - val_loss: 1.1674 - val_accuracy: 0.3872\n","Epoch 17/30\n","401/401 [==============================] - ETA: 0s - loss: 1.1304 - accuracy: 0.4186\n","Epoch 00017: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0017.ckpt\n","401/401 [==============================] - 158s 393ms/step - loss: 1.1304 - accuracy: 0.4186 - val_loss: 1.1699 - val_accuracy: 0.3899\n","Epoch 18/30\n","316/401 [======================>.......] - ETA: 31s - loss: 1.0534 - accuracy: 0.4234"],"name":"stdout"},{"output_type":"error","ename":"KeyboardInterrupt","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m<ipython-input-47-84db2157ec20>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m           \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minitial_epochs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m           \u001b[0mcallbacks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcp_callback\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m           \u001b[0mvalidation_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mvalidation_generator\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      7\u001b[0m )\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     64\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_method_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_in_multi_worker_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;31m# Running inside `run_distribute_coordinator` already.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m    846\u001b[0m                 batch_size=batch_size):\n\u001b[1;32m    847\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 848\u001b[0;31m               \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    849\u001b[0m               \u001b[0;31m# Catch OutOfRangeError for Datasets of unknown size.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    850\u001b[0m               \u001b[0;31m# This blocks until the batch has finished executing.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    578\u001b[0m         \u001b[0mxla_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    579\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 580\u001b[0;31m       \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    581\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    582\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mtracing_count\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    609\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    610\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 611\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    612\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    613\u001b[0m       \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2418\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2419\u001b[0m       \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2420\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2421\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2422\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m   1663\u001b[0m          if isinstance(t, (ops.Tensor,\n\u001b[1;32m   1664\u001b[0m                            resource_variable_ops.BaseResourceVariable))),\n\u001b[0;32m-> 1665\u001b[0;31m         self.captured_inputs)\n\u001b[0m\u001b[1;32m   1666\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1667\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_call_flat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcancellation_manager\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1744\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1745\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[0;32m-> 1746\u001b[0;31m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[1;32m   1747\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m   1748\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    596\u001b[0m               \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    597\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 598\u001b[0;31m               ctx=ctx)\n\u001b[0m\u001b[1;32m    599\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    600\u001b[0m           outputs = execute.execute_with_cancellation(\n","\u001b[0;32m/usr/local/lib/python3.6/dist-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0;32m---> 60\u001b[0;31m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[1;32m     61\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mKeyboardInterrupt\u001b[0m: "]}]},{"cell_type":"code","metadata":{"id":"uW68lI3WCVTK","colab_type":"code","outputId":"dd429017-6ff3-4610-c598-57457315684f","executionInfo":{"status":"ok","timestamp":1590262741659,"user_tz":420,"elapsed":7255,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":347}},"source":["from pathlib import Path\n","\n","IMG_SHAPE = (IMG_HEIGHT, IMG_WIDTH, 3)\n","\n","Path(f\"drive/My Drive/checkpoints/{MODEL_NAME}\").mkdir(parents=True, exist_ok=True)\n","checkpoint_path = \"drive/My Drive/checkpoints/\" + MODEL_NAME + \"/cp-{epoch:04d}.ckpt\"\n","\n","# Create a callback that saves the model's weights every 1 epochs\n","cp_callback = tf.keras.callbacks.ModelCheckpoint(\n","    filepath=checkpoint_path, \n","    verbose=1,\n","    save_weights_only=True,\n","    period=1)\n","\n","def create_model(inputs):\n","    # Extract ResNet part of the model\n","    base_model = get_base_model()\n","    base_model.trainable = False\n","    x = base_model(inputs)\n","    x = tf.keras.layers.GlobalAveragePooling2D()(x)\n","    x = tf.keras.layers.Dense(256, activation='relu')(x)\n","    x = tf.keras.layers.Dense(3, activation='softmax')(x)\n","\n","    model = tf.keras.Model(inputs=inputs, outputs=x)\n","    model.compile(optimizer='adam',\n","                  loss = 'categorical_crossentropy',\n","                  metrics=['accuracy'])\n","    return model\n","\n","def get_base_model(model_name=\"resnet50\"):\n","    if model_name == 'inception_v3':\n","        return tf.keras.applications.InceptionV3(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'xception':\n","        return tf.keras.applications.Xception(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'vgg16':\n","        return tf.keras.applications.VGG16(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'vgg19':\n","        return tf.keras.applications.VGG19(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    elif model_name == 'resnet50':\n","        return tf.keras.applications.ResNet50(weights='imagenet', include_top=False, input_shape=IMG_SHAPE)\n","    else:\n","        raise ValueError(f\"Cannot find base model {model_name}\")\n","\n","inputs = tf.keras.Input(shape=(IMG_HEIGHT, IMG_WIDTH, 3))\n","model = create_model(inputs)\n","model.summary()\n","\n","\n"],"execution_count":0,"outputs":[{"output_type":"stream","text":["WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n","Model: \"model_6\"\n","_________________________________________________________________\n","Layer (type)                 Output Shape              Param #   \n","=================================================================\n","input_14 (InputLayer)        [(None, 320, 480, 3)]     0         \n","_________________________________________________________________\n","resnet50 (Model)             (None, 10, 15, 2048)      23587712  \n","_________________________________________________________________\n","global_average_pooling2d_1 ( (None, 2048)              0         \n","_________________________________________________________________\n","dense_14 (Dense)             (None, 256)               524544    \n","_________________________________________________________________\n","dense_15 (Dense)             (None, 3)                 771       \n","=================================================================\n","Total params: 24,113,027\n","Trainable params: 525,315\n","Non-trainable params: 23,587,712\n","_________________________________________________________________\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"eqe7KJ5tCyFO","colab_type":"code","outputId":"0c8d8cd5-3273-43db-8910-2b8f287410a3","executionInfo":{"status":"ok","timestamp":1590267324631,"user_tz":420,"elapsed":4576888,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":1000}},"source":["import pickle\n","history = model.fit(\n","          train_generator,\n","          epochs=initial_epochs,\n","          callbacks=[cp_callback],\n","          validation_data=validation_generator\n",")\n","\n","with open(f\"drive/My Drive/checkpoints/{MODEL_NAME}/history-v2.pkl\", 'wb') as handle:\n","    pickle.dump(history.history, handle)"],"execution_count":0,"outputs":[{"output_type":"stream","text":["Epoch 1/30\n","401/401 [==============================] - ETA: 0s - loss: 0.8585 - accuracy: 0.6001\n","Epoch 00001: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0001.ckpt\n","401/401 [==============================] - 159s 396ms/step - loss: 0.8585 - accuracy: 0.6001 - val_loss: 1.0852 - val_accuracy: 0.4579\n","Epoch 2/30\n","401/401 [==============================] - ETA: 0s - loss: 0.7274 - accuracy: 0.6714\n","Epoch 00002: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0002.ckpt\n","401/401 [==============================] - 147s 366ms/step - loss: 0.7274 - accuracy: 0.6714 - val_loss: 1.0216 - val_accuracy: 0.5054\n","Epoch 3/30\n","401/401 [==============================] - ETA: 0s - loss: 0.6670 - accuracy: 0.7050\n","Epoch 00003: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0003.ckpt\n","401/401 [==============================] - 145s 362ms/step - loss: 0.6670 - accuracy: 0.7050 - val_loss: 1.0709 - val_accuracy: 0.5041\n","Epoch 4/30\n","401/401 [==============================] - ETA: 0s - loss: 0.6284 - accuracy: 0.7262\n","Epoch 00004: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0004.ckpt\n","401/401 [==============================] - 146s 365ms/step - loss: 0.6284 - accuracy: 0.7262 - val_loss: 1.0805 - val_accuracy: 0.4878\n","Epoch 5/30\n","401/401 [==============================] - ETA: 0s - loss: 0.5785 - accuracy: 0.7537\n","Epoch 00005: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0005.ckpt\n","401/401 [==============================] - 149s 372ms/step - loss: 0.5785 - accuracy: 0.7537 - val_loss: 1.1329 - val_accuracy: 0.5136\n","Epoch 6/30\n","401/401 [==============================] - ETA: 0s - loss: 0.5409 - accuracy: 0.7752\n","Epoch 00006: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0006.ckpt\n","401/401 [==============================] - 152s 378ms/step - loss: 0.5409 - accuracy: 0.7752 - val_loss: 1.2294 - val_accuracy: 0.4511\n","Epoch 7/30\n","401/401 [==============================] - ETA: 0s - loss: 0.5062 - accuracy: 0.7857\n","Epoch 00007: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0007.ckpt\n","401/401 [==============================] - 152s 380ms/step - loss: 0.5062 - accuracy: 0.7857 - val_loss: 1.0549 - val_accuracy: 0.5258\n","Epoch 8/30\n","401/401 [==============================] - ETA: 0s - loss: 0.4666 - accuracy: 0.8070\n","Epoch 00008: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0008.ckpt\n","401/401 [==============================] - 151s 375ms/step - loss: 0.4666 - accuracy: 0.8070 - val_loss: 1.1189 - val_accuracy: 0.5109\n","Epoch 9/30\n","401/401 [==============================] - ETA: 0s - loss: 0.4215 - accuracy: 0.8275\n","Epoch 00009: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0009.ckpt\n","401/401 [==============================] - 151s 377ms/step - loss: 0.4215 - accuracy: 0.8275 - val_loss: 1.2276 - val_accuracy: 0.4796\n","Epoch 10/30\n","401/401 [==============================] - ETA: 0s - loss: 0.3985 - accuracy: 0.8379\n","Epoch 00010: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0010.ckpt\n","401/401 [==============================] - 152s 379ms/step - loss: 0.3985 - accuracy: 0.8379 - val_loss: 1.2976 - val_accuracy: 0.4851\n","Epoch 11/30\n","401/401 [==============================] - ETA: 0s - loss: 0.3593 - accuracy: 0.8537\n","Epoch 00011: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0011.ckpt\n","401/401 [==============================] - 151s 376ms/step - loss: 0.3593 - accuracy: 0.8537 - val_loss: 1.2514 - val_accuracy: 0.4986\n","Epoch 12/30\n","401/401 [==============================] - ETA: 0s - loss: 0.3356 - accuracy: 0.8639\n","Epoch 00012: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0012.ckpt\n","401/401 [==============================] - 153s 382ms/step - loss: 0.3356 - accuracy: 0.8639 - val_loss: 1.4739 - val_accuracy: 0.4620\n","Epoch 13/30\n","401/401 [==============================] - ETA: 0s - loss: 0.2989 - accuracy: 0.8790\n","Epoch 00013: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0013.ckpt\n","401/401 [==============================] - 154s 384ms/step - loss: 0.2989 - accuracy: 0.8790 - val_loss: 1.5021 - val_accuracy: 0.4783\n","Epoch 14/30\n","401/401 [==============================] - ETA: 0s - loss: 0.2712 - accuracy: 0.8922\n","Epoch 00014: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0014.ckpt\n","401/401 [==============================] - 155s 388ms/step - loss: 0.2712 - accuracy: 0.8922 - val_loss: 1.5489 - val_accuracy: 0.4660\n","Epoch 15/30\n","401/401 [==============================] - ETA: 0s - loss: 0.2504 - accuracy: 0.9015\n","Epoch 00015: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0015.ckpt\n","401/401 [==============================] - 149s 372ms/step - loss: 0.2504 - accuracy: 0.9015 - val_loss: 1.5228 - val_accuracy: 0.4986\n","Epoch 16/30\n","401/401 [==============================] - ETA: 0s - loss: 0.2229 - accuracy: 0.9134\n","Epoch 00016: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0016.ckpt\n","401/401 [==============================] - 150s 375ms/step - loss: 0.2229 - accuracy: 0.9134 - val_loss: 1.6758 - val_accuracy: 0.4470\n","Epoch 17/30\n","401/401 [==============================] - ETA: 0s - loss: 0.2104 - accuracy: 0.9181\n","Epoch 00017: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0017.ckpt\n","401/401 [==============================] - 152s 378ms/step - loss: 0.2104 - accuracy: 0.9181 - val_loss: 1.6589 - val_accuracy: 0.4769\n","Epoch 18/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1941 - accuracy: 0.9259\n","Epoch 00018: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0018.ckpt\n","401/401 [==============================] - 150s 375ms/step - loss: 0.1941 - accuracy: 0.9259 - val_loss: 1.7925 - val_accuracy: 0.4701\n","Epoch 19/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1798 - accuracy: 0.9327\n","Epoch 00019: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0019.ckpt\n","401/401 [==============================] - 151s 376ms/step - loss: 0.1798 - accuracy: 0.9327 - val_loss: 1.7705 - val_accuracy: 0.4769\n","Epoch 20/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1599 - accuracy: 0.9408\n","Epoch 00020: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0020.ckpt\n","401/401 [==============================] - 150s 374ms/step - loss: 0.1599 - accuracy: 0.9408 - val_loss: 1.7541 - val_accuracy: 0.4769\n","Epoch 21/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1448 - accuracy: 0.9473\n","Epoch 00021: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0021.ckpt\n","401/401 [==============================] - 156s 389ms/step - loss: 0.1448 - accuracy: 0.9473 - val_loss: 1.8680 - val_accuracy: 0.4674\n","Epoch 22/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1444 - accuracy: 0.9460\n","Epoch 00022: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0022.ckpt\n","401/401 [==============================] - 155s 387ms/step - loss: 0.1444 - accuracy: 0.9460 - val_loss: 2.0226 - val_accuracy: 0.4647\n","Epoch 23/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1346 - accuracy: 0.9504\n","Epoch 00023: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0023.ckpt\n","401/401 [==============================] - 153s 383ms/step - loss: 0.1346 - accuracy: 0.9504 - val_loss: 1.7672 - val_accuracy: 0.5095\n","Epoch 24/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1163 - accuracy: 0.9595\n","Epoch 00024: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0024.ckpt\n","401/401 [==============================] - 153s 383ms/step - loss: 0.1163 - accuracy: 0.9595 - val_loss: 2.1582 - val_accuracy: 0.4769\n","Epoch 25/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1235 - accuracy: 0.9535\n","Epoch 00025: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0025.ckpt\n","401/401 [==============================] - 153s 381ms/step - loss: 0.1235 - accuracy: 0.9535 - val_loss: 2.1306 - val_accuracy: 0.4565\n","Epoch 26/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1078 - accuracy: 0.9623\n","Epoch 00026: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0026.ckpt\n","401/401 [==============================] - 152s 378ms/step - loss: 0.1078 - accuracy: 0.9623 - val_loss: 2.1352 - val_accuracy: 0.4660\n","Epoch 27/30\n","401/401 [==============================] - ETA: 0s - loss: 0.0956 - accuracy: 0.9678\n","Epoch 00027: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0027.ckpt\n","401/401 [==============================] - 155s 385ms/step - loss: 0.0956 - accuracy: 0.9678 - val_loss: 2.2228 - val_accuracy: 0.4565\n","Epoch 28/30\n","401/401 [==============================] - ETA: 0s - loss: 0.0995 - accuracy: 0.9666\n","Epoch 00028: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0028.ckpt\n","401/401 [==============================] - 154s 385ms/step - loss: 0.0995 - accuracy: 0.9666 - val_loss: 2.2473 - val_accuracy: 0.4443\n","Epoch 29/30\n","401/401 [==============================] - ETA: 0s - loss: 0.1031 - accuracy: 0.9620\n","Epoch 00029: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0029.ckpt\n","401/401 [==============================] - 153s 382ms/step - loss: 0.1031 - accuracy: 0.9620 - val_loss: 2.6501 - val_accuracy: 0.4552\n","Epoch 30/30\n","401/401 [==============================] - ETA: 0s - loss: 0.0928 - accuracy: 0.9659\n","Epoch 00030: saving model to drive/My Drive/checkpoints/resnet-lstm-flickr-v3/cp-0030.ckpt\n","401/401 [==============================] - 153s 381ms/step - loss: 0.0928 - accuracy: 0.9659 - val_loss: 2.3124 - val_accuracy: 0.4837\n"],"name":"stdout"}]},{"cell_type":"code","metadata":{"id":"PRKEAnmdaCPB","colab_type":"code","outputId":"72177a77-3e23-44aa-ba06-fd0c5a5cb785","executionInfo":{"status":"ok","timestamp":1590267857381,"user_tz":420,"elapsed":2289,"user":{"displayName":"Tom Jin","photoUrl":"","userId":"17151951874441774370"}},"colab":{"base_uri":"https://localhost:8080/","height":513}},"source":["acc = history.history['accuracy']\n","val_acc = history.history['val_accuracy']\n","\n","loss = history.history['loss']\n","val_loss = history.history['val_loss']\n","\n","\n","plt.figure(figsize=(8, 8))\n","plt.subplot(2, 1, 1)\n","plt.plot(acc, label='Training Accuracy')\n","plt.plot(val_acc, label='Validation Accuracy')\n","plt.legend(loc='lower right')\n","plt.ylabel('Accuracy')\n","plt.title('Training and Validation Accuracy')\n","\n","plt.subplot(2, 1, 2)\n","plt.plot(loss, label='Training Loss')\n","plt.plot(val_loss, label='Validation Loss')\n","plt.legend(loc='upper right')\n","plt.ylabel('Cross Entropy')\n","plt.title('Training and Validation Loss')\n","plt.xlabel('epoch')\n","plt.show()\n","\n","model.save(f\"drive/My Drive/checkpoints/{MODEL_NAME}/m1.h5\")\n"],"execution_count":0,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["<Figure size 576x576 with 2 Axes>"]},"metadata":{"tags":[],"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"v1_9AgE9j0ZG","colab_type":"code","colab":{}},"source":[""],"execution_count":0,"outputs":[]}]}