├── example.png ├── LICENSE ├── README.md └── encoder_decoder.ipynb /example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/faizahkureshi232/imagetospeech/HEAD/example.png -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 Faizah Mahendinawaz Kureshi 4 | 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to deal 8 | in the Software without restriction, including without limitation the rights 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 | copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in all 14 | copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 | SOFTWARE. 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Speech-enabled Image Narration: Assistance for the Visually Impaired 2 | 3 | ## Overview 4 | This project focuses on enabling accessibility for visually impaired individuals by automating the generation of descriptive captions for images and providing these descriptions through audio narration. The solution integrates advanced machine learning techniques in image processing, natural language understanding, and speech synthesis. 5 | 6 | ## Features 7 | - **Image Feature Extraction**: Utilizes the InceptionV3 CNN model to extract high-level image features. 8 | - **Semantic Word Embeddings**: Employs GloVe embeddings to enhance the language representation. 9 | - **Caption Generation**: Generates meaningful and contextually relevant captions using an LSTM-based decoder. 10 | - **Speech Narration**: Converts generated captions into audio using Text-to-Speech (TTS) technology. 11 | 12 | ## Architecture 13 | The system follows an encoder-decoder paradigm: 14 | 1. **Image Input**: Accepts images as input. 15 | 2. **Feature Extraction**: InceptionV3 CNN extracts image features. 16 | 3. **Language Representation**: GloVe embeddings provide semantic word vectors. 17 | 4. **Caption Generation**: LSTM decoder generates captions using image features and word embeddings. 18 | 5. **Text-to-Speech Conversion**: TTS converts captions to speech. 19 | 6. **Audio Output**: Delivers the generated description as audio for user accessibility. 20 | 21 | 22 | ## Technologies Used 23 | - **Python**: Programming language 24 | - **TensorFlow/Keras**: For building and training the CNN and LSTM models 25 | - **GloVe**: Pre-trained word embeddings for language representation 26 | - **Text-to-Speech (TTS)**: For converting text captions into speech 27 | - **Flask/Django (Optional)**: For deploying the application 28 | - **NumPy, Pandas, Matplotlib**: For data handling and visualization 29 | 30 | ## Installation 31 | 1. Clone this repository: 32 | ```bash 33 | git clone https://github.com/faizahkureshi232/imagetospeech.git 34 | cd project-name 35 | 36 | 37 | 2. Download the pre-trained models: 38 | 39 | - InceptionV3 weights 40 | - GloVe word embeddings 41 | 42 | 3. Run the application: 43 | 44 | bash 45 | 46 | Copy code 47 | 48 | `eval.ipnby` 49 | 50 | Usage 51 | ----- 52 | 53 | 1. Upload an image through the interface or specify the image path in the script. 54 | 2. The system will generate a descriptive caption. 55 | 3. The caption will be converted into speech and played as audio. 56 | 57 | Sample Results 58 | -------------- 59 | 60 | - Input Image: [example.png] 61 | - Generated Caption: "A Dog Running through the." 62 | - Audio Output: Speech narration of the generated caption. 63 | 64 | Future Enhancements 65 | ------------------- 66 | 67 | - Integration with real-time image capture (e.g., through a smartphone camera). 68 | - Support for multiple languages in Text-to-Speech. 69 | - Advanced customization for user-specific accessibility needs. 70 | 71 | Contributing 72 | ------------ 73 | 74 | Contributions are welcome! Please follow these steps: 75 | 76 | 1. Fork the repository. 77 | 2. Create a feature branch: 78 | 79 | bash 80 | 81 | Copy code 82 | 83 | `git checkout -b feature-name` 84 | 85 | 3. Commit your changes: 86 | 87 | bash 88 | 89 | Copy code 90 | 91 | `git commit -m "Add feature description"` 92 | 93 | 4. Push to the branch: 94 | 95 | bash 96 | 97 | Copy code 98 | 99 | `git push origin feature-name` 100 | 101 | 5. Create a pull request. 102 | 103 | License 104 | ------- 105 | 106 | This project is licensed under the MIT License. See `LICENSE` for more details. 107 | 108 | Acknowledgements 109 | ---------------- 110 | 111 | - InceptionV3 for feature extraction. 112 | - [GloVe](https://nlp.stanford.edu/projects/glove/) for pre-trained word embeddings. 113 | - OpenAI and community resources for inspiration and support. 114 | 115 | * * * * * 116 | 117 | Feel free to suggest improvements or report issues in the repository! 118 | -------------------------------------------------------------------------------- /encoder_decoder.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 31, 6 | "metadata": { 7 | "id": "XTs0q-TgmiSt" 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "import numpy as np\n", 12 | "import pandas as pd\n", 13 | "import string\n", 14 | "import matplotlib.pyplot as plt\n", 15 | "from tqdm import tqdm\n", 16 | "from PIL import Image\n", 17 | "import pickle\n", 18 | "from pickle import dump, load\n", 19 | "import time\n", 20 | "import os\n", 21 | "\n", 22 | "import torch\n", 23 | "import tensorflow as tf\n", 24 | "import keras\n", 25 | "from keras.applications.inception_v3 import InceptionV3\n", 26 | "from keras.models import Model\n", 27 | "from keras.preprocessing import image\n" 28 | ] 29 | }, 30 | { 31 | "cell_type": "code", 32 | "execution_count": 3, 33 | "metadata": { 34 | "colab": { 35 | "base_uri": "https://localhost:8080/" 36 | }, 37 | "id": "CUXJPFGAXRkf", 38 | "outputId": "7467f855-5c11-4386-80a8-3e6574bab59e" 39 | }, 40 | "outputs": [ 41 | { 42 | "name": "stdout", 43 | "output_type": "stream", 44 | "text": [ 45 | "Mounted at /content/gdrive\n" 46 | ] 47 | } 48 | ], 49 | "source": [ 50 | "from google.colab import drive\n", 51 | "drive.mount('/content/gdrive')" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 4, 57 | "metadata": { 58 | "colab": { 59 | "base_uri": "https://localhost:8080/" 60 | }, 61 | "id": "K5QOJ1aomdsM", 62 | "outputId": "ae4b0bdc-fa20-4174-b2cc-5e707b5c96af" 63 | }, 64 | "outputs": [ 65 | { 66 | "name": "stdout", 67 | "output_type": "stream", 68 | "text": [ 69 | "Device: cuda\n" 70 | ] 71 | } 72 | ], 73 | "source": [ 74 | "num_gpus = torch.cuda.device_count()\n", 75 | "if num_gpus > 0:\n", 76 | " device = 'cuda'\n", 77 | "else:\n", 78 | " device = 'cpu'\n", 79 | "\n", 80 | "print('Device: ', device)" 81 | ] 82 | }, 83 | { 84 | "cell_type": "markdown", 85 | "metadata": { 86 | "id": "vQqEhCDonewY" 87 | }, 88 | "source": [ 89 | "### **1. Data Preprocessing and Cleaning**" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 6, 95 | "metadata": { 96 | "id": "jS2AsHKmnFdK" 97 | }, 98 | "outputs": [], 99 | "source": [ 100 | "# Function to load the file and read its text\n", 101 | "def load_caption(filename):\n", 102 | " file = open(filename, 'r')\n", 103 | " read_text = file.read()\n", 104 | " file.close()\n", 105 | " return read_text\n", 106 | "\n", 107 | "# Cleaning captions - Removing punctuation, converting to lowercase, single-character words and numeric values\n", 108 | "def clean_text(text):\n", 109 | " caption = text.lower()\n", 110 | " translator = str.maketrans('', '', string.punctuation) # Removes punctuation using the translator method defined below\n", 111 | " caption = caption.translate(translator)\n", 112 | "\n", 113 | " desc_list = \"\"\n", 114 | " for word in caption.split():\n", 115 | " if len(word) >= 1 and word.isdigit() == False:\n", 116 | " desc_list += \" \" + word\n", 117 | "\n", 118 | " caption = desc_list\n", 119 | " return caption\n", 120 | "\n", 121 | "\n", 122 | "# Creating a dataframe from the text files\n", 123 | "def create_dataframe(text):\n", 124 | " data = []\n", 125 | " descriptions = {} # Dictionary with image as the key and a list of all the five captions as value\n", 126 | " for sentence in text.split('\\n'):\n", 127 | " splits = sentence.split('\\t')\n", 128 | "\n", 129 | " if len(splits) != 1:\n", 130 | " idx = splits[0].split('#')\n", 131 | " data.append(idx + [splits[1].lower()])\n", 132 | " img_idx = idx[0].split('.')[0]\n", 133 | " text = splits[1]\n", 134 | " caption = clean_text(text) # Cleaning text using the function defined \n", 135 | " \n", 136 | " if img_idx not in descriptions.keys():\n", 137 | " descriptions[img_idx] = list() \n", 138 | " descriptions[img_idx].append(caption)\n", 139 | "\n", 140 | " else:\n", 141 | " continue\n", 142 | " return data, descriptions\n" 143 | ] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": { 148 | "id": "6-CpTb1eClJO" 149 | }, 150 | "source": [ 151 | "#### An example of raw data - Image ID with caption number and assoiated captions\n", 152 | "\n", 153 | "#### The text file contains raw captions for the Dataset. The first column denotes the image ID with the caption number (0 - 4)" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 7, 159 | "metadata": { 160 | "colab": { 161 | "base_uri": "https://localhost:8080/" 162 | }, 163 | "id": "nr4I8C12ouY1", 164 | "outputId": "cb964eb8-5609-4a39-d0e7-5245ee7a310f" 165 | }, 166 | "outputs": [ 167 | { 168 | "name": "stdout", 169 | "output_type": "stream", 170 | "text": [ 171 | "1000268201_693b08cb0e.jpg#0\tA child in a pink dress is climbing up a set of stairs in an entry way .\n", 172 | "1000268201_693b08cb0e.jpg#1\tA girl going into a wooden building .\n", 173 | "1000268201_693b08cb0e.jpg#2\tA little girl climbing into a wooden playhouse .\n", 174 | "1000268201_693b08cb0e.jpg#3\tA little girl climbing the stairs to her playhouse .\n", 175 | "1000268201_693b08cb0e.jpg#4\tA little girl in a pink dress going into a wooden cabin .\n" 176 | ] 177 | } 178 | ], 179 | "source": [ 180 | "text = load_caption('/content/gdrive/MyDrive/Deep_Learning/Flickr8k_text/Flickr8k.token.txt')\n", 181 | "print(text[:410])" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 8, 187 | "metadata": { 188 | "colab": { 189 | "base_uri": "https://localhost:8080/", 190 | "height": 218 191 | }, 192 | "id": "eYqDkHEfzyJ6", 193 | "outputId": "e6dca51c-8c02-4fb4-9f46-b875072dc9b4" 194 | }, 195 | "outputs": [ 196 | { 197 | "name": "stdout", 198 | "output_type": "stream", 199 | "text": [ 200 | "Number of unique images (datapoints): 8092\n" 201 | ] 202 | }, 203 | { 204 | "data": { 205 | "text/html": [ 206 | "
\n", 207 | "\n", 220 | "\n", 221 | " \n", 222 | " \n", 223 | " \n", 224 | " \n", 225 | " \n", 226 | " \n", 227 | " \n", 228 | " \n", 229 | " \n", 230 | " \n", 231 | " \n", 232 | " \n", 233 | " \n", 234 | " \n", 235 | " \n", 236 | " \n", 237 | " \n", 238 | " \n", 239 | " \n", 240 | " \n", 241 | " \n", 242 | " \n", 243 | " \n", 244 | " \n", 245 | " \n", 246 | " \n", 247 | " \n", 248 | " \n", 249 | " \n", 250 | " \n", 251 | " \n", 252 | " \n", 253 | " \n", 254 | " \n", 255 | " \n", 256 | " \n", 257 | " \n", 258 | " \n", 259 | " \n", 260 | " \n", 261 | "
imageindexcaption
01000268201_693b08cb0e.jpg0a child in a pink dress is climbing up a set o...
11000268201_693b08cb0e.jpg1a girl going into a wooden building .
21000268201_693b08cb0e.jpg2a little girl climbing into a wooden playhouse .
31000268201_693b08cb0e.jpg3a little girl climbing the stairs to her playh...
41000268201_693b08cb0e.jpg4a little girl in a pink dress going into a woo...
\n", 262 | "
" 263 | ], 264 | "text/plain": [ 265 | " image ... caption\n", 266 | "0 1000268201_693b08cb0e.jpg ... a child in a pink dress is climbing up a set o...\n", 267 | "1 1000268201_693b08cb0e.jpg ... a girl going into a wooden building .\n", 268 | "2 1000268201_693b08cb0e.jpg ... a little girl climbing into a wooden playhouse .\n", 269 | "3 1000268201_693b08cb0e.jpg ... a little girl climbing the stairs to her playh...\n", 270 | "4 1000268201_693b08cb0e.jpg ... a little girl in a pink dress going into a woo...\n", 271 | "\n", 272 | "[5 rows x 3 columns]" 273 | ] 274 | }, 275 | "execution_count": 8, 276 | "metadata": { 277 | "tags": [] 278 | }, 279 | "output_type": "execute_result" 280 | } 281 | ], 282 | "source": [ 283 | "data, dictionary = create_dataframe(text)\n", 284 | "df = pd.DataFrame(data, columns=['image', 'index', 'caption'])\n", 285 | "images_vector = np.unique(df.image.values)\n", 286 | "print('Number of unique images (datapoints): ', len(images_vector))\n", 287 | "df.head(5)" 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": { 293 | "id": "SLaAXaVxC85p" 294 | }, 295 | "source": [ 296 | "#### A dictionary key as Image ID and its 5 captions" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 9, 302 | "metadata": { 303 | "colab": { 304 | "base_uri": "https://localhost:8080/" 305 | }, 306 | "id": "pOZ9fnhIPv7A", 307 | "outputId": "aa7551b9-3329-4d10-c4e0-b3e69e156c9a" 308 | }, 309 | "outputs": [ 310 | { 311 | "data": { 312 | "text/plain": [ 313 | "array(['a child in a pink dress is climbing up a set of stairs in an entry way .',\n", 314 | " 'a girl going into a wooden building .',\n", 315 | " 'a little girl climbing into a wooden playhouse .',\n", 316 | " 'a little girl climbing the stairs to her playhouse .',\n", 317 | " 'a little girl in a pink dress going into a wooden cabin .',\n", 318 | " 'a black dog and a spotted dog are fighting',\n", 319 | " 'a black dog and a tri-colored dog playing with each other on the road .',\n", 320 | " 'a black dog and a white dog with brown spots are staring at each other in the street .',\n", 321 | " 'two dogs of different breeds looking at each other on the road .',\n", 322 | " 'two dogs on pavement moving toward each other .',\n", 323 | " 'a little girl covered in paint sits in front of a painted rainbow with her hands in a bowl .',\n", 324 | " 'a little girl is sitting in front of a large painted rainbow .',\n", 325 | " 'a small girl in the grass plays with fingerpaints in front of a white canvas with a rainbow on it .',\n", 326 | " 'there is a girl with pigtails sitting in front of a rainbow painting .',\n", 327 | " 'young girl with pigtails painting outside in the grass .'],\n", 328 | " dtype=object)" 329 | ] 330 | }, 331 | "execution_count": 9, 332 | "metadata": { 333 | "tags": [] 334 | }, 335 | "output_type": "execute_result" 336 | } 337 | ], 338 | "source": [ 339 | "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", 340 | "df.caption.values[:15]" 341 | ] 342 | }, 343 | { 344 | "cell_type": "markdown", 345 | "metadata": { 346 | "id": "H3l5KFhYBb1t" 347 | }, 348 | "source": [ 349 | "#### Preprocessing images for the InceptionV3 model\n", 350 | "1. Resizing the images to 299 x 299\n", 351 | "2. Using keras process_input method to normalize the pixel values between -1 to 1" 352 | ] 353 | }, 354 | { 355 | "cell_type": "code", 356 | "execution_count": 10, 357 | "metadata": { 358 | "id": "zlTcJQQT7Ojt" 359 | }, 360 | "outputs": [], 361 | "source": [ 362 | "def load_image_preprocess(img_path):\n", 363 | " img = tf.io.read_file(img_path)\n", 364 | " img = tf.image.decode_jpeg(img, channels = 3)\n", 365 | " img = tf.image.resize(img, (299, 299)) # Resizing the image to 299 * 299\n", 366 | "\n", 367 | " # Preprocessing the input using preprocess_input method: Normalizing the pixel values between -1 t0 1\n", 368 | " img = tf.keras.applications.inception_v3.preprocess_input(img)\n", 369 | " return img, img_path\n", 370 | "\n", 371 | "# Method to create a list of image paths\n", 372 | "def create_images_vector(images_vector, root):\n", 373 | " paths = []\n", 374 | " for img in images_vector:\n", 375 | " paths.append(root + img)\n", 376 | " return paths\n", 377 | "\n", 378 | "root = '/content/gdrive/MyDrive/Deep_Learning/Flickr8k_Dataset/Flicker8k_Dataset/' \n", 379 | "list_image_paths = create_images_vector(images_vector, root)" 380 | ] 381 | }, 382 | { 383 | "cell_type": "code", 384 | "execution_count": null, 385 | "metadata": { 386 | "colab": { 387 | "base_uri": "https://localhost:8080/", 388 | "height": 304 389 | }, 390 | "id": "EwtbSLFKAXp1", 391 | "outputId": "c7c7c4cb-16e5-42a4-a912-f2a143121205" 392 | }, 393 | "outputs": [ 394 | { 395 | "name": "stderr", 396 | "output_type": "stream", 397 | "text": [ 398 | "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" 399 | ] 400 | }, 401 | { 402 | "name": "stdout", 403 | "output_type": "stream", 404 | "text": [ 405 | "(299, 299, 3)\n" 406 | ] 407 | }, 408 | { 409 | "data": { 410 | "image/png": "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", 411 | "text/plain": [ 412 | "
" 413 | ] 414 | }, 415 | "metadata": { 416 | "needs_background": "light", 417 | "tags": [] 418 | }, 419 | "output_type": "display_data" 420 | } 421 | ], 422 | "source": [ 423 | "demo_img, img_path = load_image_preprocess(root + images_vector[2])\n", 424 | "plt.imshow(demo_img)\n", 425 | "print(demo_img.shape)" 426 | ] 427 | }, 428 | { 429 | "cell_type": "code", 430 | "execution_count": 11, 431 | "metadata": { 432 | "colab": { 433 | "base_uri": "https://localhost:8080/" 434 | }, 435 | "id": "azNPyZWJxI-D", 436 | "outputId": "f667ce65-b80d-4601-a736-1914d9c3032c" 437 | }, 438 | "outputs": [ 439 | { 440 | "name": "stdout", 441 | "output_type": "stream", 442 | "text": [ 443 | "1346 /content/gdrive/MyDrive/Deep_Learning/Flickr8k_Dataset/Flicker8k_Dataset/2258277193_586949ec62.jpg.1\n" 444 | ] 445 | } 446 | ], 447 | "source": [ 448 | "# Additional code to remove a non-existing training data image present in our text file\n", 449 | "\n", 450 | "find = '/content/gdrive/MyDrive/Deep_Learning/Flickr8k_Dataset/Flicker8k_Dataset/2258277193_586949ec62.jpg.1'\n", 451 | "for i, val in enumerate(list_image_paths):\n", 452 | " if find == val:\n", 453 | " print(i, val)\n", 454 | " list_image_paths[i] = root + '2258277193_586949ec62.jpg'\n", 455 | "\n", 456 | "del list_image_paths[1346]" 457 | ] 458 | }, 459 | { 460 | "cell_type": "markdown", 461 | "metadata": { 462 | "id": "6AvihAc4xYcP" 463 | }, 464 | "source": [ 465 | "#### Splitting train, validate and test data" 466 | ] 467 | }, 468 | { 469 | "cell_type": "code", 470 | "execution_count": 36, 471 | "metadata": { 472 | "colab": { 473 | "base_uri": "https://localhost:8080/" 474 | }, 475 | "id": "LXh65aUNwHvZ", 476 | "outputId": "96c6a03a-fe28-4d6a-c37c-b8abfc3eca58" 477 | }, 478 | "outputs": [ 479 | { 480 | "name": "stdout", 481 | "output_type": "stream", 482 | "text": [ 483 | "Length of train, validate and test data: 6000 1000 1000\n" 484 | ] 485 | } 486 | ], 487 | "source": [ 488 | "# Creating separate train, validate and test image lists\n", 489 | "train_images_path = '/content/gdrive/MyDrive/Deep_Learning/Flickr8k_text/Flickr_8k.trainImages.txt'\n", 490 | "train_text = open(train_images_path, 'r').read().strip().split('\\n')\n", 491 | "train_images = create_images_vector(train_text, root)\n", 492 | "\n", 493 | "test_images_path = '/content/gdrive/MyDrive/Deep_Learning/Flickr8k_text/Flickr_8k.testImages.txt'\n", 494 | "test_txt = open(test_images_path, 'r').read().strip().split('\\n')\n", 495 | "test_images = create_images_vector(test_txt, root)\n", 496 | "\n", 497 | "validate_images_path = '/content/gdrive/MyDrive/Deep_Learning/Flickr8k_text/Flickr_8k.devImages.txt'\n", 498 | "validate_images = open(validate_images_path, 'r').read().strip().split('\\n')\n", 499 | "validate_images = create_images_vector(validate_images, root)\n", 500 | "\n", 501 | "print('Length of train, validate and test data: ', len(train_images), len(validate_images), len(test_images))" 502 | ] 503 | }, 504 | { 505 | "cell_type": "markdown", 506 | "metadata": { 507 | "id": "QYZwKJbU97KN" 508 | }, 509 | "source": [ 510 | "#### Preprocessing captions for the decoder model" 511 | ] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": 37, 516 | "metadata": { 517 | "id": "2RbVr05nxHZ2" 518 | }, 519 | "outputs": [], 520 | "source": [ 521 | "# Loading captions in a dictionary only for the training images\n", 522 | "train_dictionary = {}\n", 523 | "test_dictionary = {} # Implementing for later BLEU Analysis\n", 524 | "\n", 525 | "# Adding and tokens --- decide either to all_captions list or dictionary \n", 526 | "for key in dictionary.keys():\n", 527 | " key_updated = key + '.jpg'\n", 528 | " if key_updated in train_text:\n", 529 | " train_dictionary[key] = list()\n", 530 | "\n", 531 | " for c in dictionary[key]:\n", 532 | " caption = '' + ''.join(c) + ' '\n", 533 | " train_dictionary[key].append(caption)\n", 534 | " \n", 535 | " if key_updated in test_txt:\n", 536 | " test_dictionary[key] = list()\n", 537 | "\n", 538 | " for c in dictionary[key]:\n", 539 | " test_dictionary[key].append(c)" 540 | ] 541 | }, 542 | { 543 | "cell_type": "markdown", 544 | "metadata": { 545 | "id": "udCWScDCPXRt" 546 | }, 547 | "source": [ 548 | "#### Defining utility functions for Captions processing" 549 | ] 550 | }, 551 | { 552 | "cell_type": "code", 553 | "execution_count": 14, 554 | "metadata": { 555 | "id": "sZKlQNL895x3" 556 | }, 557 | "outputs": [], 558 | "source": [ 559 | "# A list of all the captions in the dataframe\n", 560 | "def create_captions_list(dictionary):\n", 561 | " all_captions = []\n", 562 | " for key in dictionary.keys():\n", 563 | " for c in dictionary[key]:\n", 564 | " all_captions.append(c)\n", 565 | " return all_captions\n", 566 | "\n", 567 | "def max_length(captions):\n", 568 | " lengths = []\n", 569 | " for caption in captions:\n", 570 | " lengths.append(len(caption.split()))\n", 571 | " return max(lengths)" 572 | ] 573 | }, 574 | { 575 | "cell_type": "code", 576 | "execution_count": 15, 577 | "metadata": { 578 | "colab": { 579 | "base_uri": "https://localhost:8080/" 580 | }, 581 | "id": "GSToJ38JGzER", 582 | "outputId": "228a39c5-b32a-4a54-b0bf-5ff6f82f26a1" 583 | }, 584 | "outputs": [ 585 | { 586 | "name": "stdout", 587 | "output_type": "stream", 588 | "text": [ 589 | "Original Vocabulary size: 7597\n", 590 | "Vocabulary size after removing low frequency words: 1654\n", 591 | "Maximum length of a caption in the corpus is: 37\n" 592 | ] 593 | } 594 | ], 595 | "source": [ 596 | "# Creating a Vocabulary of all the unique tokens in the corpus\n", 597 | "vocab = set()\n", 598 | "train_all_captions = create_captions_list(train_dictionary)\n", 599 | "max_caption = max_length(train_all_captions)\n", 600 | "\n", 601 | "for key in train_dictionary.keys():\n", 602 | " [vocab.update(caption.split()) for caption in train_dictionary[key]]\n", 603 | "print('Original Vocabulary size: ', len(vocab))\n", 604 | "\n", 605 | "# Consider only words which occur at least 10 times in the corpus\n", 606 | "threshold = 10\n", 607 | "counts = {}\n", 608 | "num_sentence = 0\n", 609 | "for sent in train_all_captions:\n", 610 | " num_sentence += 1\n", 611 | " for token in sent.split(' '):\n", 612 | " counts[token] = counts.get(token, 0) + 1\n", 613 | "\n", 614 | "vocab = [word for word in counts if counts[word] >= threshold]\n", 615 | "print('Vocabulary size after removing low frequency words: ', len(vocab))\n", 616 | "print('Maximum length of a caption in the corpus is: ', max_caption)" 617 | ] 618 | }, 619 | { 620 | "cell_type": "code", 621 | "execution_count": 16, 622 | "metadata": { 623 | "colab": { 624 | "base_uri": "https://localhost:8080/" 625 | }, 626 | "id": "Z9WmsayyZREz", 627 | "outputId": "a334b02d-1806-438a-cc4b-278485ecfc5b" 628 | }, 629 | "outputs": [ 630 | { 631 | "name": "stdout", 632 | "output_type": "stream", 633 | "text": [ 634 | "Index of token is 1 and token is 15\n" 635 | ] 636 | } 637 | ], 638 | "source": [ 639 | "# Python dictionaries to map tokens to index \n", 640 | "token_to_idx, idx_to_token = {}, {} \n", 641 | "\n", 642 | "index = 1\n", 643 | "for token in vocab:\n", 644 | " token_to_idx[token] = index\n", 645 | " idx_to_token[index] = token\n", 646 | " index += 1\n", 647 | "\n", 648 | "print(f\"Index of token is {token_to_idx['']} and token is {token_to_idx['']}\")" 649 | ] 650 | }, 651 | { 652 | "cell_type": "markdown", 653 | "metadata": { 654 | "id": "LtX2kxtdoMSU" 655 | }, 656 | "source": [ 657 | "### **2. GLoVe embeddings**" 658 | ] 659 | }, 660 | { 661 | "cell_type": "code", 662 | "execution_count": null, 663 | "metadata": { 664 | "colab": { 665 | "base_uri": "https://localhost:8080/" 666 | }, 667 | "id": "Tt6LCPV4oL_O", 668 | "outputId": "3cb5842f-6ad3-452c-9c24-cba3238d70f5" 669 | }, 670 | "outputs": [ 671 | { 672 | "name": "stdout", 673 | "output_type": "stream", 674 | "text": [ 675 | "--2021-05-18 19:23:25-- http://nlp.stanford.edu/data/glove.6B.zip\n", 676 | "Resolving nlp.stanford.edu (nlp.stanford.edu)... 171.64.67.140\n", 677 | "Connecting to nlp.stanford.edu (nlp.stanford.edu)|171.64.67.140|:80... connected.\n", 678 | "HTTP request sent, awaiting response... 302 Found\n", 679 | "Location: https://nlp.stanford.edu/data/glove.6B.zip [following]\n", 680 | "--2021-05-18 19:23:25-- https://nlp.stanford.edu/data/glove.6B.zip\n", 681 | "Connecting to nlp.stanford.edu (nlp.stanford.edu)|171.64.67.140|:443... connected.\n", 682 | "HTTP request sent, awaiting response... 301 Moved Permanently\n", 683 | "Location: http://downloads.cs.stanford.edu/nlp/data/glove.6B.zip [following]\n", 684 | "--2021-05-18 19:23:25-- http://downloads.cs.stanford.edu/nlp/data/glove.6B.zip\n", 685 | "Resolving downloads.cs.stanford.edu (downloads.cs.stanford.edu)... 171.64.64.22\n", 686 | "Connecting to downloads.cs.stanford.edu (downloads.cs.stanford.edu)|171.64.64.22|:80... connected.\n", 687 | "HTTP request sent, awaiting response... 200 OK\n", 688 | "Length: 862182613 (822M) [application/zip]\n", 689 | "Saving to: ‘glove.6B.zip’\n", 690 | "\n", 691 | "glove.6B.zip 100%[===================>] 822.24M 5.07MB/s in 2m 43s \n", 692 | "\n", 693 | "2021-05-18 19:26:09 (5.03 MB/s) - ‘glove.6B.zip’ saved [862182613/862182613]\n", 694 | "\n" 695 | ] 696 | } 697 | ], 698 | "source": [ 699 | "!wget http://nlp.stanford.edu/data/glove.6B.zip\n", 700 | "!unzip -q glove.6B.zip" 701 | ] 702 | }, 703 | { 704 | "cell_type": "code", 705 | "execution_count": null, 706 | "metadata": { 707 | "colab": { 708 | "base_uri": "https://localhost:8080/" 709 | }, 710 | "id": "EZR6Q6wt8LZH", 711 | "outputId": "295f19cd-877f-4bc1-dcfa-11422c4013d7" 712 | }, 713 | "outputs": [ 714 | { 715 | "name": "stdout", 716 | "output_type": "stream", 717 | "text": [ 718 | "Found 400000 word vectors.\n" 719 | ] 720 | } 721 | ], 722 | "source": [ 723 | "# Using Keras pre-trained GLOVE word-embeddings (dimension: 200)\n", 724 | "\n", 725 | "path_to_glove_file = os.path.join(\n", 726 | " os.path.expanduser(\"~\"), \"/content/glove.6B.200d.txt\"\n", 727 | ")\n", 728 | "\n", 729 | "embeddings_index = {}\n", 730 | "with open(path_to_glove_file) as f:\n", 731 | " for line in f:\n", 732 | " word, coefs = line.split(maxsplit=1)\n", 733 | " coefs = np.fromstring(coefs, \"f\", sep=\" \")\n", 734 | " embeddings_index[word] = coefs\n", 735 | "\n", 736 | "print(\"Found %s word vectors.\" % len(embeddings_index))" 737 | ] 738 | }, 739 | { 740 | "cell_type": "code", 741 | "execution_count": 20, 742 | "metadata": { 743 | "id": "G9KbDjhAs4pA" 744 | }, 745 | "outputs": [], 746 | "source": [ 747 | "embeddings_size = 200\n", 748 | "vocab_size = len(vocab) + 1" 749 | ] 750 | }, 751 | { 752 | "cell_type": "code", 753 | "execution_count": null, 754 | "metadata": { 755 | "colab": { 756 | "base_uri": "https://localhost:8080/" 757 | }, 758 | "id": "di0QmSi28z1H", 759 | "outputId": "5d37bc0d-cb66-4b5c-fc61-247a1e86a483" 760 | }, 761 | "outputs": [ 762 | { 763 | "name": "stderr", 764 | "output_type": "stream", 765 | "text": [ 766 | "100%|██████████| 1654/1654 [00:00<00:00, 309345.35it/s]\n" 767 | ] 768 | } 769 | ], 770 | "source": [ 771 | "embeddings = np.zeros((vocab_size, embeddings_size))\n", 772 | "\n", 773 | "for token, idx in tqdm(token_to_idx.items()):\n", 774 | " if token in embeddings_index:\n", 775 | " vector = embeddings_index[token]\n", 776 | " embeddings[idx] = vector" 777 | ] 778 | }, 779 | { 780 | "cell_type": "markdown", 781 | "metadata": { 782 | "id": "TXThDYmdBRue" 783 | }, 784 | "source": [ 785 | "Checkpoint: Saving the embeddings matrix" 786 | ] 787 | }, 788 | { 789 | "cell_type": "code", 790 | "execution_count": 34, 791 | "metadata": { 792 | "colab": { 793 | "base_uri": "https://localhost:8080/" 794 | }, 795 | "id": "Np0EQYz-_cXT", 796 | "outputId": "59c07478-d5da-48d0-882d-0a9481693c02" 797 | }, 798 | "outputs": [ 799 | { 800 | "name": "stdout", 801 | "output_type": "stream", 802 | "text": [ 803 | "Size of embeddings matrix: (1655, 200)\n" 804 | ] 805 | } 806 | ], 807 | "source": [ 808 | "print('Size of embeddings matrix: ', embeddings.shape)\n", 809 | "with open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/embeddings.pkl', 'wb') as embeddings_file:\n", 810 | " pickle.dump(embeddings, embeddings_file)\n", 811 | "\n", 812 | "with open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/token_to_idx.pkl', 'wb') as token_idx_file:\n", 813 | " pickle.dump(token_to_idx, token_idx_file)\n", 814 | "\n", 815 | "with open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/idx_to_token.pkl', 'wb') as idx_token_file:\n", 816 | " pickle.dump(idx_to_token, idx_token_file)" 817 | ] 818 | }, 819 | { 820 | "cell_type": "markdown", 821 | "metadata": { 822 | "id": "dDu8LfveH5yH" 823 | }, 824 | "source": [ 825 | "### **3. Encoder: InceptionV3 model**\n", 826 | "> Creating an instance of the InceptionV3 architecture pretrained on ImageNet\n", 827 | "\n", 828 | "> Extracting the feature vector from the last convolutional layer of shape (8 x 8 x 2048): Parameter include_top set to False" 829 | ] 830 | }, 831 | { 832 | "cell_type": "markdown", 833 | "metadata": { 834 | "id": "GuO6RAjMV_K6" 835 | }, 836 | "source": [ 837 | "#### Method 1: Feature Extraction (without tensorFlow's parallel computation)" 838 | ] 839 | }, 840 | { 841 | "cell_type": "code", 842 | "execution_count": null, 843 | "metadata": { 844 | "id": "IFVsxxJoaZrr" 845 | }, 846 | "outputs": [], 847 | "source": [ 848 | "# Fit the encoder model to the training and validation dataset\n", 849 | "model = InceptionV3(weights = 'imagenet')\n", 850 | "model_new = Model(model.input, model.layers[-2].output)\n", 851 | "\n", 852 | "def preprocess(image_path):\n", 853 | " img = image.load_img(image_path, target_size=(299, 299))\n", 854 | " x = image.img_to_array(img)\n", 855 | " x = np.expand_dims(x, axis=0)\n", 856 | " img = tf.keras.applications.inception_v3.preprocess_input(x)\n", 857 | " return x" 858 | ] 859 | }, 860 | { 861 | "cell_type": "code", 862 | "execution_count": null, 863 | "metadata": { 864 | "id": "en1RGB0yfYEl" 865 | }, 866 | "outputs": [], 867 | "source": [ 868 | "features_dict = {}\n", 869 | "\n", 870 | "start = time.time()\n", 871 | "for img_path in tqdm(test_images):\n", 872 | " pre_img = preprocess(img_path)\n", 873 | " features = model_new(pre_img)\n", 874 | " features = np.reshape(features, features.shape[1])\n", 875 | "\n", 876 | " features_dict[img_path] = features\n", 877 | "\n", 878 | "end = time.time()\n", 879 | "print('Time taken to generate features vector (train data): ', (end - start)/60)" 880 | ] 881 | }, 882 | { 883 | "cell_type": "markdown", 884 | "metadata": { 885 | "id": "BGvef8EKV75r" 886 | }, 887 | "source": [ 888 | "#### Method 2: Feature Extraction (with TensorFLow's batch processing)" 889 | ] 890 | }, 891 | { 892 | "cell_type": "code", 893 | "execution_count": null, 894 | "metadata": { 895 | "colab": { 896 | "base_uri": "https://localhost:8080/" 897 | }, 898 | "id": "nAN0se2UIBBR", 899 | "outputId": "081e2f9e-c868-4d75-f1a9-499c73990f4b" 900 | }, 901 | "outputs": [ 902 | { 903 | "name": "stdout", 904 | "output_type": "stream", 905 | "text": [ 906 | "Model: \"model\"\n", 907 | "__________________________________________________________________________________________________\n", 908 | "Layer (type) Output Shape Param # Connected to \n", 909 | "==================================================================================================\n", 910 | "input_1 (InputLayer) [(None, None, None, 0 \n", 911 | "__________________________________________________________________________________________________\n", 912 | "conv2d (Conv2D) (None, None, None, 3 864 input_1[0][0] \n", 913 | "__________________________________________________________________________________________________\n", 914 | "batch_normalization (BatchNorma (None, None, None, 3 96 conv2d[0][0] \n", 915 | "__________________________________________________________________________________________________\n", 916 | "activation (Activation) (None, None, None, 3 0 batch_normalization[0][0] \n", 917 | "__________________________________________________________________________________________________\n", 918 | "conv2d_1 (Conv2D) (None, None, None, 3 9216 activation[0][0] \n", 919 | "__________________________________________________________________________________________________\n", 920 | "batch_normalization_1 (BatchNor (None, None, None, 3 96 conv2d_1[0][0] \n", 921 | "__________________________________________________________________________________________________\n", 922 | "activation_1 (Activation) (None, None, None, 3 0 batch_normalization_1[0][0] \n", 923 | "__________________________________________________________________________________________________\n", 924 | "conv2d_2 (Conv2D) (None, None, None, 6 18432 activation_1[0][0] \n", 925 | "__________________________________________________________________________________________________\n", 926 | "batch_normalization_2 (BatchNor (None, None, None, 6 192 conv2d_2[0][0] \n", 927 | "__________________________________________________________________________________________________\n", 928 | "activation_2 (Activation) (None, None, None, 6 0 batch_normalization_2[0][0] \n", 929 | "__________________________________________________________________________________________________\n", 930 | "max_pooling2d (MaxPooling2D) (None, None, None, 6 0 activation_2[0][0] \n", 931 | "__________________________________________________________________________________________________\n", 932 | "conv2d_3 (Conv2D) (None, None, None, 8 5120 max_pooling2d[0][0] \n", 933 | "__________________________________________________________________________________________________\n", 934 | "batch_normalization_3 (BatchNor (None, None, None, 8 240 conv2d_3[0][0] \n", 935 | "__________________________________________________________________________________________________\n", 936 | "activation_3 (Activation) (None, None, None, 8 0 batch_normalization_3[0][0] \n", 937 | "__________________________________________________________________________________________________\n", 938 | "conv2d_4 (Conv2D) (None, None, None, 1 138240 activation_3[0][0] \n", 939 | "__________________________________________________________________________________________________\n", 940 | "batch_normalization_4 (BatchNor (None, None, None, 1 576 conv2d_4[0][0] \n", 941 | "__________________________________________________________________________________________________\n", 942 | "activation_4 (Activation) (None, None, None, 1 0 batch_normalization_4[0][0] \n", 943 | "__________________________________________________________________________________________________\n", 944 | "max_pooling2d_1 (MaxPooling2D) (None, None, None, 1 0 activation_4[0][0] \n", 945 | "__________________________________________________________________________________________________\n", 946 | "conv2d_8 (Conv2D) (None, None, None, 6 12288 max_pooling2d_1[0][0] \n", 947 | "__________________________________________________________________________________________________\n", 948 | "batch_normalization_8 (BatchNor (None, None, None, 6 192 conv2d_8[0][0] \n", 949 | "__________________________________________________________________________________________________\n", 950 | "activation_8 (Activation) (None, None, None, 6 0 batch_normalization_8[0][0] \n", 951 | "__________________________________________________________________________________________________\n", 952 | "conv2d_6 (Conv2D) (None, None, None, 4 9216 max_pooling2d_1[0][0] \n", 953 | "__________________________________________________________________________________________________\n", 954 | "conv2d_9 (Conv2D) (None, None, None, 9 55296 activation_8[0][0] \n", 955 | "__________________________________________________________________________________________________\n", 956 | "batch_normalization_6 (BatchNor (None, None, None, 4 144 conv2d_6[0][0] \n", 957 | "__________________________________________________________________________________________________\n", 958 | "batch_normalization_9 (BatchNor (None, None, None, 9 288 conv2d_9[0][0] \n", 959 | "__________________________________________________________________________________________________\n", 960 | "activation_6 (Activation) (None, None, None, 4 0 batch_normalization_6[0][0] \n", 961 | "__________________________________________________________________________________________________\n", 962 | "activation_9 (Activation) (None, None, None, 9 0 batch_normalization_9[0][0] \n", 963 | "__________________________________________________________________________________________________\n", 964 | "average_pooling2d (AveragePooli (None, None, None, 1 0 max_pooling2d_1[0][0] \n", 965 | "__________________________________________________________________________________________________\n", 966 | "conv2d_5 (Conv2D) (None, None, None, 6 12288 max_pooling2d_1[0][0] \n", 967 | "__________________________________________________________________________________________________\n", 968 | "conv2d_7 (Conv2D) (None, None, None, 6 76800 activation_6[0][0] \n", 969 | "__________________________________________________________________________________________________\n", 970 | "conv2d_10 (Conv2D) (None, None, None, 9 82944 activation_9[0][0] \n", 971 | "__________________________________________________________________________________________________\n", 972 | "conv2d_11 (Conv2D) (None, None, None, 3 6144 average_pooling2d[0][0] \n", 973 | "__________________________________________________________________________________________________\n", 974 | "batch_normalization_5 (BatchNor (None, None, None, 6 192 conv2d_5[0][0] \n", 975 | "__________________________________________________________________________________________________\n", 976 | "batch_normalization_7 (BatchNor (None, None, None, 6 192 conv2d_7[0][0] \n", 977 | "__________________________________________________________________________________________________\n", 978 | "batch_normalization_10 (BatchNo (None, None, None, 9 288 conv2d_10[0][0] \n", 979 | "__________________________________________________________________________________________________\n", 980 | "batch_normalization_11 (BatchNo (None, None, None, 3 96 conv2d_11[0][0] \n", 981 | "__________________________________________________________________________________________________\n", 982 | "activation_5 (Activation) (None, None, None, 6 0 batch_normalization_5[0][0] \n", 983 | "__________________________________________________________________________________________________\n", 984 | "activation_7 (Activation) (None, None, None, 6 0 batch_normalization_7[0][0] \n", 985 | "__________________________________________________________________________________________________\n", 986 | "activation_10 (Activation) (None, None, None, 9 0 batch_normalization_10[0][0] \n", 987 | "__________________________________________________________________________________________________\n", 988 | "activation_11 (Activation) (None, None, None, 3 0 batch_normalization_11[0][0] \n", 989 | "__________________________________________________________________________________________________\n", 990 | "mixed0 (Concatenate) (None, None, None, 2 0 activation_5[0][0] \n", 991 | " activation_7[0][0] \n", 992 | " activation_10[0][0] \n", 993 | " activation_11[0][0] \n", 994 | "__________________________________________________________________________________________________\n", 995 | "conv2d_15 (Conv2D) (None, None, None, 6 16384 mixed0[0][0] \n", 996 | "__________________________________________________________________________________________________\n", 997 | "batch_normalization_15 (BatchNo (None, None, None, 6 192 conv2d_15[0][0] \n", 998 | "__________________________________________________________________________________________________\n", 999 | "activation_15 (Activation) (None, None, None, 6 0 batch_normalization_15[0][0] \n", 1000 | "__________________________________________________________________________________________________\n", 1001 | "conv2d_13 (Conv2D) (None, None, None, 4 12288 mixed0[0][0] \n", 1002 | "__________________________________________________________________________________________________\n", 1003 | "conv2d_16 (Conv2D) (None, None, None, 9 55296 activation_15[0][0] \n", 1004 | "__________________________________________________________________________________________________\n", 1005 | "batch_normalization_13 (BatchNo (None, None, None, 4 144 conv2d_13[0][0] \n", 1006 | "__________________________________________________________________________________________________\n", 1007 | "batch_normalization_16 (BatchNo (None, None, None, 9 288 conv2d_16[0][0] \n", 1008 | "__________________________________________________________________________________________________\n", 1009 | "activation_13 (Activation) (None, None, None, 4 0 batch_normalization_13[0][0] \n", 1010 | "__________________________________________________________________________________________________\n", 1011 | "activation_16 (Activation) (None, None, None, 9 0 batch_normalization_16[0][0] \n", 1012 | "__________________________________________________________________________________________________\n", 1013 | "average_pooling2d_1 (AveragePoo (None, None, None, 2 0 mixed0[0][0] \n", 1014 | "__________________________________________________________________________________________________\n", 1015 | "conv2d_12 (Conv2D) (None, None, None, 6 16384 mixed0[0][0] \n", 1016 | "__________________________________________________________________________________________________\n", 1017 | "conv2d_14 (Conv2D) (None, None, None, 6 76800 activation_13[0][0] \n", 1018 | "__________________________________________________________________________________________________\n", 1019 | "conv2d_17 (Conv2D) (None, None, None, 9 82944 activation_16[0][0] \n", 1020 | "__________________________________________________________________________________________________\n", 1021 | "conv2d_18 (Conv2D) (None, None, None, 6 16384 average_pooling2d_1[0][0] \n", 1022 | "__________________________________________________________________________________________________\n", 1023 | "batch_normalization_12 (BatchNo (None, None, None, 6 192 conv2d_12[0][0] \n", 1024 | "__________________________________________________________________________________________________\n", 1025 | "batch_normalization_14 (BatchNo (None, None, None, 6 192 conv2d_14[0][0] \n", 1026 | "__________________________________________________________________________________________________\n", 1027 | "batch_normalization_17 (BatchNo (None, None, None, 9 288 conv2d_17[0][0] \n", 1028 | "__________________________________________________________________________________________________\n", 1029 | "batch_normalization_18 (BatchNo (None, None, None, 6 192 conv2d_18[0][0] \n", 1030 | "__________________________________________________________________________________________________\n", 1031 | "activation_12 (Activation) (None, None, None, 6 0 batch_normalization_12[0][0] \n", 1032 | "__________________________________________________________________________________________________\n", 1033 | "activation_14 (Activation) (None, None, None, 6 0 batch_normalization_14[0][0] \n", 1034 | "__________________________________________________________________________________________________\n", 1035 | "activation_17 (Activation) (None, None, None, 9 0 batch_normalization_17[0][0] \n", 1036 | "__________________________________________________________________________________________________\n", 1037 | "activation_18 (Activation) (None, None, None, 6 0 batch_normalization_18[0][0] \n", 1038 | "__________________________________________________________________________________________________\n", 1039 | "mixed1 (Concatenate) (None, None, None, 2 0 activation_12[0][0] \n", 1040 | " activation_14[0][0] \n", 1041 | " activation_17[0][0] \n", 1042 | " activation_18[0][0] \n", 1043 | "__________________________________________________________________________________________________\n", 1044 | "conv2d_22 (Conv2D) (None, None, None, 6 18432 mixed1[0][0] \n", 1045 | "__________________________________________________________________________________________________\n", 1046 | "batch_normalization_22 (BatchNo (None, None, None, 6 192 conv2d_22[0][0] \n", 1047 | "__________________________________________________________________________________________________\n", 1048 | "activation_22 (Activation) (None, None, None, 6 0 batch_normalization_22[0][0] \n", 1049 | "__________________________________________________________________________________________________\n", 1050 | "conv2d_20 (Conv2D) (None, None, None, 4 13824 mixed1[0][0] \n", 1051 | "__________________________________________________________________________________________________\n", 1052 | "conv2d_23 (Conv2D) (None, None, None, 9 55296 activation_22[0][0] \n", 1053 | "__________________________________________________________________________________________________\n", 1054 | "batch_normalization_20 (BatchNo (None, None, None, 4 144 conv2d_20[0][0] \n", 1055 | "__________________________________________________________________________________________________\n", 1056 | "batch_normalization_23 (BatchNo (None, None, None, 9 288 conv2d_23[0][0] \n", 1057 | "__________________________________________________________________________________________________\n", 1058 | "activation_20 (Activation) (None, None, None, 4 0 batch_normalization_20[0][0] \n", 1059 | "__________________________________________________________________________________________________\n", 1060 | "activation_23 (Activation) (None, None, None, 9 0 batch_normalization_23[0][0] \n", 1061 | "__________________________________________________________________________________________________\n", 1062 | "average_pooling2d_2 (AveragePoo (None, None, None, 2 0 mixed1[0][0] \n", 1063 | "__________________________________________________________________________________________________\n", 1064 | "conv2d_19 (Conv2D) (None, None, None, 6 18432 mixed1[0][0] \n", 1065 | "__________________________________________________________________________________________________\n", 1066 | "conv2d_21 (Conv2D) (None, None, None, 6 76800 activation_20[0][0] \n", 1067 | "__________________________________________________________________________________________________\n", 1068 | "conv2d_24 (Conv2D) (None, None, None, 9 82944 activation_23[0][0] \n", 1069 | "__________________________________________________________________________________________________\n", 1070 | "conv2d_25 (Conv2D) (None, None, None, 6 18432 average_pooling2d_2[0][0] \n", 1071 | "__________________________________________________________________________________________________\n", 1072 | "batch_normalization_19 (BatchNo (None, None, None, 6 192 conv2d_19[0][0] \n", 1073 | "__________________________________________________________________________________________________\n", 1074 | "batch_normalization_21 (BatchNo (None, None, None, 6 192 conv2d_21[0][0] \n", 1075 | "__________________________________________________________________________________________________\n", 1076 | "batch_normalization_24 (BatchNo (None, None, None, 9 288 conv2d_24[0][0] \n", 1077 | "__________________________________________________________________________________________________\n", 1078 | "batch_normalization_25 (BatchNo (None, None, None, 6 192 conv2d_25[0][0] \n", 1079 | "__________________________________________________________________________________________________\n", 1080 | "activation_19 (Activation) (None, None, None, 6 0 batch_normalization_19[0][0] \n", 1081 | "__________________________________________________________________________________________________\n", 1082 | "activation_21 (Activation) (None, None, None, 6 0 batch_normalization_21[0][0] \n", 1083 | "__________________________________________________________________________________________________\n", 1084 | "activation_24 (Activation) (None, None, None, 9 0 batch_normalization_24[0][0] \n", 1085 | "__________________________________________________________________________________________________\n", 1086 | "activation_25 (Activation) (None, None, None, 6 0 batch_normalization_25[0][0] \n", 1087 | "__________________________________________________________________________________________________\n", 1088 | "mixed2 (Concatenate) (None, None, None, 2 0 activation_19[0][0] \n", 1089 | " activation_21[0][0] \n", 1090 | " activation_24[0][0] \n", 1091 | " activation_25[0][0] \n", 1092 | "__________________________________________________________________________________________________\n", 1093 | "conv2d_27 (Conv2D) (None, None, None, 6 18432 mixed2[0][0] \n", 1094 | "__________________________________________________________________________________________________\n", 1095 | "batch_normalization_27 (BatchNo (None, None, None, 6 192 conv2d_27[0][0] \n", 1096 | "__________________________________________________________________________________________________\n", 1097 | "activation_27 (Activation) (None, None, None, 6 0 batch_normalization_27[0][0] \n", 1098 | "__________________________________________________________________________________________________\n", 1099 | "conv2d_28 (Conv2D) (None, None, None, 9 55296 activation_27[0][0] \n", 1100 | "__________________________________________________________________________________________________\n", 1101 | "batch_normalization_28 (BatchNo (None, None, None, 9 288 conv2d_28[0][0] \n", 1102 | "__________________________________________________________________________________________________\n", 1103 | "activation_28 (Activation) (None, None, None, 9 0 batch_normalization_28[0][0] \n", 1104 | "__________________________________________________________________________________________________\n", 1105 | "conv2d_26 (Conv2D) (None, None, None, 3 995328 mixed2[0][0] \n", 1106 | "__________________________________________________________________________________________________\n", 1107 | "conv2d_29 (Conv2D) (None, None, None, 9 82944 activation_28[0][0] \n", 1108 | "__________________________________________________________________________________________________\n", 1109 | "batch_normalization_26 (BatchNo (None, None, None, 3 1152 conv2d_26[0][0] \n", 1110 | "__________________________________________________________________________________________________\n", 1111 | "batch_normalization_29 (BatchNo (None, None, None, 9 288 conv2d_29[0][0] \n", 1112 | "__________________________________________________________________________________________________\n", 1113 | "activation_26 (Activation) (None, None, None, 3 0 batch_normalization_26[0][0] \n", 1114 | "__________________________________________________________________________________________________\n", 1115 | "activation_29 (Activation) (None, None, None, 9 0 batch_normalization_29[0][0] \n", 1116 | "__________________________________________________________________________________________________\n", 1117 | "max_pooling2d_2 (MaxPooling2D) (None, None, None, 2 0 mixed2[0][0] \n", 1118 | "__________________________________________________________________________________________________\n", 1119 | "mixed3 (Concatenate) (None, None, None, 7 0 activation_26[0][0] \n", 1120 | " activation_29[0][0] \n", 1121 | " max_pooling2d_2[0][0] \n", 1122 | "__________________________________________________________________________________________________\n", 1123 | "conv2d_34 (Conv2D) (None, None, None, 1 98304 mixed3[0][0] \n", 1124 | "__________________________________________________________________________________________________\n", 1125 | "batch_normalization_34 (BatchNo (None, None, None, 1 384 conv2d_34[0][0] \n", 1126 | "__________________________________________________________________________________________________\n", 1127 | "activation_34 (Activation) (None, None, None, 1 0 batch_normalization_34[0][0] \n", 1128 | "__________________________________________________________________________________________________\n", 1129 | "conv2d_35 (Conv2D) (None, None, None, 1 114688 activation_34[0][0] \n", 1130 | "__________________________________________________________________________________________________\n", 1131 | "batch_normalization_35 (BatchNo (None, None, None, 1 384 conv2d_35[0][0] \n", 1132 | "__________________________________________________________________________________________________\n", 1133 | "activation_35 (Activation) (None, None, None, 1 0 batch_normalization_35[0][0] \n", 1134 | "__________________________________________________________________________________________________\n", 1135 | "conv2d_31 (Conv2D) (None, None, None, 1 98304 mixed3[0][0] \n", 1136 | "__________________________________________________________________________________________________\n", 1137 | "conv2d_36 (Conv2D) (None, None, None, 1 114688 activation_35[0][0] \n", 1138 | "__________________________________________________________________________________________________\n", 1139 | "batch_normalization_31 (BatchNo (None, None, None, 1 384 conv2d_31[0][0] \n", 1140 | "__________________________________________________________________________________________________\n", 1141 | "batch_normalization_36 (BatchNo (None, None, None, 1 384 conv2d_36[0][0] \n", 1142 | "__________________________________________________________________________________________________\n", 1143 | "activation_31 (Activation) (None, None, None, 1 0 batch_normalization_31[0][0] \n", 1144 | "__________________________________________________________________________________________________\n", 1145 | "activation_36 (Activation) (None, None, None, 1 0 batch_normalization_36[0][0] \n", 1146 | "__________________________________________________________________________________________________\n", 1147 | "conv2d_32 (Conv2D) (None, None, None, 1 114688 activation_31[0][0] \n", 1148 | "__________________________________________________________________________________________________\n", 1149 | "conv2d_37 (Conv2D) (None, None, None, 1 114688 activation_36[0][0] \n", 1150 | "__________________________________________________________________________________________________\n", 1151 | "batch_normalization_32 (BatchNo (None, None, None, 1 384 conv2d_32[0][0] \n", 1152 | "__________________________________________________________________________________________________\n", 1153 | "batch_normalization_37 (BatchNo (None, None, None, 1 384 conv2d_37[0][0] \n", 1154 | "__________________________________________________________________________________________________\n", 1155 | "activation_32 (Activation) (None, None, None, 1 0 batch_normalization_32[0][0] \n", 1156 | "__________________________________________________________________________________________________\n", 1157 | "activation_37 (Activation) (None, None, None, 1 0 batch_normalization_37[0][0] \n", 1158 | "__________________________________________________________________________________________________\n", 1159 | "average_pooling2d_3 (AveragePoo (None, None, None, 7 0 mixed3[0][0] \n", 1160 | "__________________________________________________________________________________________________\n", 1161 | "conv2d_30 (Conv2D) (None, None, None, 1 147456 mixed3[0][0] \n", 1162 | "__________________________________________________________________________________________________\n", 1163 | "conv2d_33 (Conv2D) (None, None, None, 1 172032 activation_32[0][0] \n", 1164 | "__________________________________________________________________________________________________\n", 1165 | "conv2d_38 (Conv2D) (None, None, None, 1 172032 activation_37[0][0] \n", 1166 | "__________________________________________________________________________________________________\n", 1167 | "conv2d_39 (Conv2D) (None, None, None, 1 147456 average_pooling2d_3[0][0] \n", 1168 | "__________________________________________________________________________________________________\n", 1169 | "batch_normalization_30 (BatchNo (None, None, None, 1 576 conv2d_30[0][0] \n", 1170 | "__________________________________________________________________________________________________\n", 1171 | "batch_normalization_33 (BatchNo (None, None, None, 1 576 conv2d_33[0][0] \n", 1172 | "__________________________________________________________________________________________________\n", 1173 | "batch_normalization_38 (BatchNo (None, None, None, 1 576 conv2d_38[0][0] \n", 1174 | "__________________________________________________________________________________________________\n", 1175 | "batch_normalization_39 (BatchNo (None, None, None, 1 576 conv2d_39[0][0] \n", 1176 | "__________________________________________________________________________________________________\n", 1177 | "activation_30 (Activation) (None, None, None, 1 0 batch_normalization_30[0][0] \n", 1178 | "__________________________________________________________________________________________________\n", 1179 | "activation_33 (Activation) (None, None, None, 1 0 batch_normalization_33[0][0] \n", 1180 | "__________________________________________________________________________________________________\n", 1181 | "activation_38 (Activation) (None, None, None, 1 0 batch_normalization_38[0][0] \n", 1182 | "__________________________________________________________________________________________________\n", 1183 | "activation_39 (Activation) (None, None, None, 1 0 batch_normalization_39[0][0] \n", 1184 | "__________________________________________________________________________________________________\n", 1185 | "mixed4 (Concatenate) (None, None, None, 7 0 activation_30[0][0] \n", 1186 | " activation_33[0][0] \n", 1187 | " activation_38[0][0] \n", 1188 | " activation_39[0][0] \n", 1189 | "__________________________________________________________________________________________________\n", 1190 | "conv2d_44 (Conv2D) (None, None, None, 1 122880 mixed4[0][0] \n", 1191 | "__________________________________________________________________________________________________\n", 1192 | "batch_normalization_44 (BatchNo (None, None, None, 1 480 conv2d_44[0][0] \n", 1193 | "__________________________________________________________________________________________________\n", 1194 | "activation_44 (Activation) (None, None, None, 1 0 batch_normalization_44[0][0] \n", 1195 | "__________________________________________________________________________________________________\n", 1196 | "conv2d_45 (Conv2D) (None, None, None, 1 179200 activation_44[0][0] \n", 1197 | "__________________________________________________________________________________________________\n", 1198 | "batch_normalization_45 (BatchNo (None, None, None, 1 480 conv2d_45[0][0] \n", 1199 | "__________________________________________________________________________________________________\n", 1200 | "activation_45 (Activation) (None, None, None, 1 0 batch_normalization_45[0][0] \n", 1201 | "__________________________________________________________________________________________________\n", 1202 | "conv2d_41 (Conv2D) (None, None, None, 1 122880 mixed4[0][0] \n", 1203 | "__________________________________________________________________________________________________\n", 1204 | "conv2d_46 (Conv2D) (None, None, None, 1 179200 activation_45[0][0] \n", 1205 | "__________________________________________________________________________________________________\n", 1206 | "batch_normalization_41 (BatchNo (None, None, None, 1 480 conv2d_41[0][0] \n", 1207 | "__________________________________________________________________________________________________\n", 1208 | "batch_normalization_46 (BatchNo (None, None, None, 1 480 conv2d_46[0][0] \n", 1209 | "__________________________________________________________________________________________________\n", 1210 | "activation_41 (Activation) (None, None, None, 1 0 batch_normalization_41[0][0] \n", 1211 | "__________________________________________________________________________________________________\n", 1212 | "activation_46 (Activation) (None, None, None, 1 0 batch_normalization_46[0][0] \n", 1213 | "__________________________________________________________________________________________________\n", 1214 | "conv2d_42 (Conv2D) (None, None, None, 1 179200 activation_41[0][0] \n", 1215 | "__________________________________________________________________________________________________\n", 1216 | "conv2d_47 (Conv2D) (None, None, None, 1 179200 activation_46[0][0] \n", 1217 | "__________________________________________________________________________________________________\n", 1218 | "batch_normalization_42 (BatchNo (None, None, None, 1 480 conv2d_42[0][0] \n", 1219 | "__________________________________________________________________________________________________\n", 1220 | "batch_normalization_47 (BatchNo (None, None, None, 1 480 conv2d_47[0][0] \n", 1221 | "__________________________________________________________________________________________________\n", 1222 | "activation_42 (Activation) (None, None, None, 1 0 batch_normalization_42[0][0] \n", 1223 | "__________________________________________________________________________________________________\n", 1224 | "activation_47 (Activation) (None, None, None, 1 0 batch_normalization_47[0][0] \n", 1225 | "__________________________________________________________________________________________________\n", 1226 | "average_pooling2d_4 (AveragePoo (None, None, None, 7 0 mixed4[0][0] \n", 1227 | "__________________________________________________________________________________________________\n", 1228 | "conv2d_40 (Conv2D) (None, None, None, 1 147456 mixed4[0][0] \n", 1229 | "__________________________________________________________________________________________________\n", 1230 | "conv2d_43 (Conv2D) (None, None, None, 1 215040 activation_42[0][0] \n", 1231 | "__________________________________________________________________________________________________\n", 1232 | "conv2d_48 (Conv2D) (None, None, None, 1 215040 activation_47[0][0] \n", 1233 | "__________________________________________________________________________________________________\n", 1234 | "conv2d_49 (Conv2D) (None, None, None, 1 147456 average_pooling2d_4[0][0] \n", 1235 | "__________________________________________________________________________________________________\n", 1236 | "batch_normalization_40 (BatchNo (None, None, None, 1 576 conv2d_40[0][0] \n", 1237 | "__________________________________________________________________________________________________\n", 1238 | "batch_normalization_43 (BatchNo (None, None, None, 1 576 conv2d_43[0][0] \n", 1239 | "__________________________________________________________________________________________________\n", 1240 | "batch_normalization_48 (BatchNo (None, None, None, 1 576 conv2d_48[0][0] \n", 1241 | "__________________________________________________________________________________________________\n", 1242 | "batch_normalization_49 (BatchNo (None, None, None, 1 576 conv2d_49[0][0] \n", 1243 | "__________________________________________________________________________________________________\n", 1244 | "activation_40 (Activation) (None, None, None, 1 0 batch_normalization_40[0][0] \n", 1245 | "__________________________________________________________________________________________________\n", 1246 | "activation_43 (Activation) (None, None, None, 1 0 batch_normalization_43[0][0] \n", 1247 | "__________________________________________________________________________________________________\n", 1248 | "activation_48 (Activation) (None, None, None, 1 0 batch_normalization_48[0][0] \n", 1249 | "__________________________________________________________________________________________________\n", 1250 | "activation_49 (Activation) (None, None, None, 1 0 batch_normalization_49[0][0] \n", 1251 | "__________________________________________________________________________________________________\n", 1252 | "mixed5 (Concatenate) (None, None, None, 7 0 activation_40[0][0] \n", 1253 | " activation_43[0][0] \n", 1254 | " activation_48[0][0] \n", 1255 | " activation_49[0][0] \n", 1256 | "__________________________________________________________________________________________________\n", 1257 | "conv2d_54 (Conv2D) (None, None, None, 1 122880 mixed5[0][0] \n", 1258 | "__________________________________________________________________________________________________\n", 1259 | "batch_normalization_54 (BatchNo (None, None, None, 1 480 conv2d_54[0][0] \n", 1260 | "__________________________________________________________________________________________________\n", 1261 | "activation_54 (Activation) (None, None, None, 1 0 batch_normalization_54[0][0] \n", 1262 | "__________________________________________________________________________________________________\n", 1263 | "conv2d_55 (Conv2D) (None, None, None, 1 179200 activation_54[0][0] \n", 1264 | "__________________________________________________________________________________________________\n", 1265 | "batch_normalization_55 (BatchNo (None, None, None, 1 480 conv2d_55[0][0] \n", 1266 | "__________________________________________________________________________________________________\n", 1267 | "activation_55 (Activation) (None, None, None, 1 0 batch_normalization_55[0][0] \n", 1268 | "__________________________________________________________________________________________________\n", 1269 | "conv2d_51 (Conv2D) (None, None, None, 1 122880 mixed5[0][0] \n", 1270 | "__________________________________________________________________________________________________\n", 1271 | "conv2d_56 (Conv2D) (None, None, None, 1 179200 activation_55[0][0] \n", 1272 | "__________________________________________________________________________________________________\n", 1273 | "batch_normalization_51 (BatchNo (None, None, None, 1 480 conv2d_51[0][0] \n", 1274 | "__________________________________________________________________________________________________\n", 1275 | "batch_normalization_56 (BatchNo (None, None, None, 1 480 conv2d_56[0][0] \n", 1276 | "__________________________________________________________________________________________________\n", 1277 | "activation_51 (Activation) (None, None, None, 1 0 batch_normalization_51[0][0] \n", 1278 | "__________________________________________________________________________________________________\n", 1279 | "activation_56 (Activation) (None, None, None, 1 0 batch_normalization_56[0][0] \n", 1280 | "__________________________________________________________________________________________________\n", 1281 | "conv2d_52 (Conv2D) (None, None, None, 1 179200 activation_51[0][0] \n", 1282 | "__________________________________________________________________________________________________\n", 1283 | "conv2d_57 (Conv2D) (None, None, None, 1 179200 activation_56[0][0] \n", 1284 | "__________________________________________________________________________________________________\n", 1285 | "batch_normalization_52 (BatchNo (None, None, None, 1 480 conv2d_52[0][0] \n", 1286 | "__________________________________________________________________________________________________\n", 1287 | "batch_normalization_57 (BatchNo (None, None, None, 1 480 conv2d_57[0][0] \n", 1288 | "__________________________________________________________________________________________________\n", 1289 | "activation_52 (Activation) (None, None, None, 1 0 batch_normalization_52[0][0] \n", 1290 | "__________________________________________________________________________________________________\n", 1291 | "activation_57 (Activation) (None, None, None, 1 0 batch_normalization_57[0][0] \n", 1292 | "__________________________________________________________________________________________________\n", 1293 | "average_pooling2d_5 (AveragePoo (None, None, None, 7 0 mixed5[0][0] \n", 1294 | "__________________________________________________________________________________________________\n", 1295 | "conv2d_50 (Conv2D) (None, None, None, 1 147456 mixed5[0][0] \n", 1296 | "__________________________________________________________________________________________________\n", 1297 | "conv2d_53 (Conv2D) (None, None, None, 1 215040 activation_52[0][0] \n", 1298 | "__________________________________________________________________________________________________\n", 1299 | "conv2d_58 (Conv2D) (None, None, None, 1 215040 activation_57[0][0] \n", 1300 | "__________________________________________________________________________________________________\n", 1301 | "conv2d_59 (Conv2D) (None, None, None, 1 147456 average_pooling2d_5[0][0] \n", 1302 | "__________________________________________________________________________________________________\n", 1303 | "batch_normalization_50 (BatchNo (None, None, None, 1 576 conv2d_50[0][0] \n", 1304 | "__________________________________________________________________________________________________\n", 1305 | "batch_normalization_53 (BatchNo (None, None, None, 1 576 conv2d_53[0][0] \n", 1306 | "__________________________________________________________________________________________________\n", 1307 | "batch_normalization_58 (BatchNo (None, None, None, 1 576 conv2d_58[0][0] \n", 1308 | "__________________________________________________________________________________________________\n", 1309 | "batch_normalization_59 (BatchNo (None, None, None, 1 576 conv2d_59[0][0] \n", 1310 | "__________________________________________________________________________________________________\n", 1311 | "activation_50 (Activation) (None, None, None, 1 0 batch_normalization_50[0][0] \n", 1312 | "__________________________________________________________________________________________________\n", 1313 | "activation_53 (Activation) (None, None, None, 1 0 batch_normalization_53[0][0] \n", 1314 | "__________________________________________________________________________________________________\n", 1315 | "activation_58 (Activation) (None, None, None, 1 0 batch_normalization_58[0][0] \n", 1316 | "__________________________________________________________________________________________________\n", 1317 | "activation_59 (Activation) (None, None, None, 1 0 batch_normalization_59[0][0] \n", 1318 | "__________________________________________________________________________________________________\n", 1319 | "mixed6 (Concatenate) (None, None, None, 7 0 activation_50[0][0] \n", 1320 | " activation_53[0][0] \n", 1321 | " activation_58[0][0] \n", 1322 | " activation_59[0][0] \n", 1323 | "__________________________________________________________________________________________________\n", 1324 | "conv2d_64 (Conv2D) (None, None, None, 1 147456 mixed6[0][0] \n", 1325 | "__________________________________________________________________________________________________\n", 1326 | "batch_normalization_64 (BatchNo (None, None, None, 1 576 conv2d_64[0][0] \n", 1327 | "__________________________________________________________________________________________________\n", 1328 | "activation_64 (Activation) (None, None, None, 1 0 batch_normalization_64[0][0] \n", 1329 | "__________________________________________________________________________________________________\n", 1330 | "conv2d_65 (Conv2D) (None, None, None, 1 258048 activation_64[0][0] \n", 1331 | "__________________________________________________________________________________________________\n", 1332 | "batch_normalization_65 (BatchNo (None, None, None, 1 576 conv2d_65[0][0] \n", 1333 | "__________________________________________________________________________________________________\n", 1334 | "activation_65 (Activation) (None, None, None, 1 0 batch_normalization_65[0][0] \n", 1335 | "__________________________________________________________________________________________________\n", 1336 | "conv2d_61 (Conv2D) (None, None, None, 1 147456 mixed6[0][0] \n", 1337 | "__________________________________________________________________________________________________\n", 1338 | "conv2d_66 (Conv2D) (None, None, None, 1 258048 activation_65[0][0] \n", 1339 | "__________________________________________________________________________________________________\n", 1340 | "batch_normalization_61 (BatchNo (None, None, None, 1 576 conv2d_61[0][0] \n", 1341 | "__________________________________________________________________________________________________\n", 1342 | "batch_normalization_66 (BatchNo (None, None, None, 1 576 conv2d_66[0][0] \n", 1343 | "__________________________________________________________________________________________________\n", 1344 | "activation_61 (Activation) (None, None, None, 1 0 batch_normalization_61[0][0] \n", 1345 | "__________________________________________________________________________________________________\n", 1346 | "activation_66 (Activation) (None, None, None, 1 0 batch_normalization_66[0][0] \n", 1347 | "__________________________________________________________________________________________________\n", 1348 | "conv2d_62 (Conv2D) (None, None, None, 1 258048 activation_61[0][0] \n", 1349 | "__________________________________________________________________________________________________\n", 1350 | "conv2d_67 (Conv2D) (None, None, None, 1 258048 activation_66[0][0] \n", 1351 | "__________________________________________________________________________________________________\n", 1352 | "batch_normalization_62 (BatchNo (None, None, None, 1 576 conv2d_62[0][0] \n", 1353 | "__________________________________________________________________________________________________\n", 1354 | "batch_normalization_67 (BatchNo (None, None, None, 1 576 conv2d_67[0][0] \n", 1355 | "__________________________________________________________________________________________________\n", 1356 | "activation_62 (Activation) (None, None, None, 1 0 batch_normalization_62[0][0] \n", 1357 | "__________________________________________________________________________________________________\n", 1358 | "activation_67 (Activation) (None, None, None, 1 0 batch_normalization_67[0][0] \n", 1359 | "__________________________________________________________________________________________________\n", 1360 | "average_pooling2d_6 (AveragePoo (None, None, None, 7 0 mixed6[0][0] \n", 1361 | "__________________________________________________________________________________________________\n", 1362 | "conv2d_60 (Conv2D) (None, None, None, 1 147456 mixed6[0][0] \n", 1363 | "__________________________________________________________________________________________________\n", 1364 | "conv2d_63 (Conv2D) (None, None, None, 1 258048 activation_62[0][0] \n", 1365 | "__________________________________________________________________________________________________\n", 1366 | "conv2d_68 (Conv2D) (None, None, None, 1 258048 activation_67[0][0] \n", 1367 | "__________________________________________________________________________________________________\n", 1368 | "conv2d_69 (Conv2D) (None, None, None, 1 147456 average_pooling2d_6[0][0] \n", 1369 | "__________________________________________________________________________________________________\n", 1370 | "batch_normalization_60 (BatchNo (None, None, None, 1 576 conv2d_60[0][0] \n", 1371 | "__________________________________________________________________________________________________\n", 1372 | "batch_normalization_63 (BatchNo (None, None, None, 1 576 conv2d_63[0][0] \n", 1373 | "__________________________________________________________________________________________________\n", 1374 | "batch_normalization_68 (BatchNo (None, None, None, 1 576 conv2d_68[0][0] \n", 1375 | "__________________________________________________________________________________________________\n", 1376 | "batch_normalization_69 (BatchNo (None, None, None, 1 576 conv2d_69[0][0] \n", 1377 | "__________________________________________________________________________________________________\n", 1378 | "activation_60 (Activation) (None, None, None, 1 0 batch_normalization_60[0][0] \n", 1379 | "__________________________________________________________________________________________________\n", 1380 | "activation_63 (Activation) (None, None, None, 1 0 batch_normalization_63[0][0] \n", 1381 | "__________________________________________________________________________________________________\n", 1382 | "activation_68 (Activation) (None, None, None, 1 0 batch_normalization_68[0][0] \n", 1383 | "__________________________________________________________________________________________________\n", 1384 | "activation_69 (Activation) (None, None, None, 1 0 batch_normalization_69[0][0] \n", 1385 | "__________________________________________________________________________________________________\n", 1386 | "mixed7 (Concatenate) (None, None, None, 7 0 activation_60[0][0] \n", 1387 | " activation_63[0][0] \n", 1388 | " activation_68[0][0] \n", 1389 | " activation_69[0][0] \n", 1390 | "__________________________________________________________________________________________________\n", 1391 | "conv2d_72 (Conv2D) (None, None, None, 1 147456 mixed7[0][0] \n", 1392 | "__________________________________________________________________________________________________\n", 1393 | "batch_normalization_72 (BatchNo (None, None, None, 1 576 conv2d_72[0][0] \n", 1394 | "__________________________________________________________________________________________________\n", 1395 | "activation_72 (Activation) (None, None, None, 1 0 batch_normalization_72[0][0] \n", 1396 | "__________________________________________________________________________________________________\n", 1397 | "conv2d_73 (Conv2D) (None, None, None, 1 258048 activation_72[0][0] \n", 1398 | "__________________________________________________________________________________________________\n", 1399 | "batch_normalization_73 (BatchNo (None, None, None, 1 576 conv2d_73[0][0] \n", 1400 | "__________________________________________________________________________________________________\n", 1401 | "activation_73 (Activation) (None, None, None, 1 0 batch_normalization_73[0][0] \n", 1402 | "__________________________________________________________________________________________________\n", 1403 | "conv2d_70 (Conv2D) (None, None, None, 1 147456 mixed7[0][0] \n", 1404 | "__________________________________________________________________________________________________\n", 1405 | "conv2d_74 (Conv2D) (None, None, None, 1 258048 activation_73[0][0] \n", 1406 | "__________________________________________________________________________________________________\n", 1407 | "batch_normalization_70 (BatchNo (None, None, None, 1 576 conv2d_70[0][0] \n", 1408 | "__________________________________________________________________________________________________\n", 1409 | "batch_normalization_74 (BatchNo (None, None, None, 1 576 conv2d_74[0][0] \n", 1410 | "__________________________________________________________________________________________________\n", 1411 | "activation_70 (Activation) (None, None, None, 1 0 batch_normalization_70[0][0] \n", 1412 | "__________________________________________________________________________________________________\n", 1413 | "activation_74 (Activation) (None, None, None, 1 0 batch_normalization_74[0][0] \n", 1414 | "__________________________________________________________________________________________________\n", 1415 | "conv2d_71 (Conv2D) (None, None, None, 3 552960 activation_70[0][0] \n", 1416 | "__________________________________________________________________________________________________\n", 1417 | "conv2d_75 (Conv2D) (None, None, None, 1 331776 activation_74[0][0] \n", 1418 | "__________________________________________________________________________________________________\n", 1419 | "batch_normalization_71 (BatchNo (None, None, None, 3 960 conv2d_71[0][0] \n", 1420 | "__________________________________________________________________________________________________\n", 1421 | "batch_normalization_75 (BatchNo (None, None, None, 1 576 conv2d_75[0][0] \n", 1422 | "__________________________________________________________________________________________________\n", 1423 | "activation_71 (Activation) (None, None, None, 3 0 batch_normalization_71[0][0] \n", 1424 | "__________________________________________________________________________________________________\n", 1425 | "activation_75 (Activation) (None, None, None, 1 0 batch_normalization_75[0][0] \n", 1426 | "__________________________________________________________________________________________________\n", 1427 | "max_pooling2d_3 (MaxPooling2D) (None, None, None, 7 0 mixed7[0][0] \n", 1428 | "__________________________________________________________________________________________________\n", 1429 | "mixed8 (Concatenate) (None, None, None, 1 0 activation_71[0][0] \n", 1430 | " activation_75[0][0] \n", 1431 | " max_pooling2d_3[0][0] \n", 1432 | "__________________________________________________________________________________________________\n", 1433 | "conv2d_80 (Conv2D) (None, None, None, 4 573440 mixed8[0][0] \n", 1434 | "__________________________________________________________________________________________________\n", 1435 | "batch_normalization_80 (BatchNo (None, None, None, 4 1344 conv2d_80[0][0] \n", 1436 | "__________________________________________________________________________________________________\n", 1437 | "activation_80 (Activation) (None, None, None, 4 0 batch_normalization_80[0][0] \n", 1438 | "__________________________________________________________________________________________________\n", 1439 | "conv2d_77 (Conv2D) (None, None, None, 3 491520 mixed8[0][0] \n", 1440 | "__________________________________________________________________________________________________\n", 1441 | "conv2d_81 (Conv2D) (None, None, None, 3 1548288 activation_80[0][0] \n", 1442 | "__________________________________________________________________________________________________\n", 1443 | "batch_normalization_77 (BatchNo (None, None, None, 3 1152 conv2d_77[0][0] \n", 1444 | "__________________________________________________________________________________________________\n", 1445 | "batch_normalization_81 (BatchNo (None, None, None, 3 1152 conv2d_81[0][0] \n", 1446 | "__________________________________________________________________________________________________\n", 1447 | "activation_77 (Activation) (None, None, None, 3 0 batch_normalization_77[0][0] \n", 1448 | "__________________________________________________________________________________________________\n", 1449 | "activation_81 (Activation) (None, None, None, 3 0 batch_normalization_81[0][0] \n", 1450 | "__________________________________________________________________________________________________\n", 1451 | "conv2d_78 (Conv2D) (None, None, None, 3 442368 activation_77[0][0] \n", 1452 | "__________________________________________________________________________________________________\n", 1453 | "conv2d_79 (Conv2D) (None, None, None, 3 442368 activation_77[0][0] \n", 1454 | "__________________________________________________________________________________________________\n", 1455 | "conv2d_82 (Conv2D) (None, None, None, 3 442368 activation_81[0][0] \n", 1456 | "__________________________________________________________________________________________________\n", 1457 | "conv2d_83 (Conv2D) (None, None, None, 3 442368 activation_81[0][0] \n", 1458 | "__________________________________________________________________________________________________\n", 1459 | "average_pooling2d_7 (AveragePoo (None, None, None, 1 0 mixed8[0][0] \n", 1460 | "__________________________________________________________________________________________________\n", 1461 | "conv2d_76 (Conv2D) (None, None, None, 3 409600 mixed8[0][0] \n", 1462 | "__________________________________________________________________________________________________\n", 1463 | "batch_normalization_78 (BatchNo (None, None, None, 3 1152 conv2d_78[0][0] \n", 1464 | "__________________________________________________________________________________________________\n", 1465 | "batch_normalization_79 (BatchNo (None, None, None, 3 1152 conv2d_79[0][0] \n", 1466 | "__________________________________________________________________________________________________\n", 1467 | "batch_normalization_82 (BatchNo (None, None, None, 3 1152 conv2d_82[0][0] \n", 1468 | "__________________________________________________________________________________________________\n", 1469 | "batch_normalization_83 (BatchNo (None, None, None, 3 1152 conv2d_83[0][0] \n", 1470 | "__________________________________________________________________________________________________\n", 1471 | "conv2d_84 (Conv2D) (None, None, None, 1 245760 average_pooling2d_7[0][0] \n", 1472 | "__________________________________________________________________________________________________\n", 1473 | "batch_normalization_76 (BatchNo (None, None, None, 3 960 conv2d_76[0][0] \n", 1474 | "__________________________________________________________________________________________________\n", 1475 | "activation_78 (Activation) (None, None, None, 3 0 batch_normalization_78[0][0] \n", 1476 | "__________________________________________________________________________________________________\n", 1477 | "activation_79 (Activation) (None, None, None, 3 0 batch_normalization_79[0][0] \n", 1478 | "__________________________________________________________________________________________________\n", 1479 | "activation_82 (Activation) (None, None, None, 3 0 batch_normalization_82[0][0] \n", 1480 | "__________________________________________________________________________________________________\n", 1481 | "activation_83 (Activation) (None, None, None, 3 0 batch_normalization_83[0][0] \n", 1482 | "__________________________________________________________________________________________________\n", 1483 | "batch_normalization_84 (BatchNo (None, None, None, 1 576 conv2d_84[0][0] \n", 1484 | "__________________________________________________________________________________________________\n", 1485 | "activation_76 (Activation) (None, None, None, 3 0 batch_normalization_76[0][0] \n", 1486 | "__________________________________________________________________________________________________\n", 1487 | "mixed9_0 (Concatenate) (None, None, None, 7 0 activation_78[0][0] \n", 1488 | " activation_79[0][0] \n", 1489 | "__________________________________________________________________________________________________\n", 1490 | "concatenate (Concatenate) (None, None, None, 7 0 activation_82[0][0] \n", 1491 | " activation_83[0][0] \n", 1492 | "__________________________________________________________________________________________________\n", 1493 | "activation_84 (Activation) (None, None, None, 1 0 batch_normalization_84[0][0] \n", 1494 | "__________________________________________________________________________________________________\n", 1495 | "mixed9 (Concatenate) (None, None, None, 2 0 activation_76[0][0] \n", 1496 | " mixed9_0[0][0] \n", 1497 | " concatenate[0][0] \n", 1498 | " activation_84[0][0] \n", 1499 | "__________________________________________________________________________________________________\n", 1500 | "conv2d_89 (Conv2D) (None, None, None, 4 917504 mixed9[0][0] \n", 1501 | "__________________________________________________________________________________________________\n", 1502 | "batch_normalization_89 (BatchNo (None, None, None, 4 1344 conv2d_89[0][0] \n", 1503 | "__________________________________________________________________________________________________\n", 1504 | "activation_89 (Activation) (None, None, None, 4 0 batch_normalization_89[0][0] \n", 1505 | "__________________________________________________________________________________________________\n", 1506 | "conv2d_86 (Conv2D) (None, None, None, 3 786432 mixed9[0][0] \n", 1507 | "__________________________________________________________________________________________________\n", 1508 | "conv2d_90 (Conv2D) (None, None, None, 3 1548288 activation_89[0][0] \n", 1509 | "__________________________________________________________________________________________________\n", 1510 | "batch_normalization_86 (BatchNo (None, None, None, 3 1152 conv2d_86[0][0] \n", 1511 | "__________________________________________________________________________________________________\n", 1512 | "batch_normalization_90 (BatchNo (None, None, None, 3 1152 conv2d_90[0][0] \n", 1513 | "__________________________________________________________________________________________________\n", 1514 | "activation_86 (Activation) (None, None, None, 3 0 batch_normalization_86[0][0] \n", 1515 | "__________________________________________________________________________________________________\n", 1516 | "activation_90 (Activation) (None, None, None, 3 0 batch_normalization_90[0][0] \n", 1517 | "__________________________________________________________________________________________________\n", 1518 | "conv2d_87 (Conv2D) (None, None, None, 3 442368 activation_86[0][0] \n", 1519 | "__________________________________________________________________________________________________\n", 1520 | "conv2d_88 (Conv2D) (None, None, None, 3 442368 activation_86[0][0] \n", 1521 | "__________________________________________________________________________________________________\n", 1522 | "conv2d_91 (Conv2D) (None, None, None, 3 442368 activation_90[0][0] \n", 1523 | "__________________________________________________________________________________________________\n", 1524 | "conv2d_92 (Conv2D) (None, None, None, 3 442368 activation_90[0][0] \n", 1525 | "__________________________________________________________________________________________________\n", 1526 | "average_pooling2d_8 (AveragePoo (None, None, None, 2 0 mixed9[0][0] \n", 1527 | "__________________________________________________________________________________________________\n", 1528 | "conv2d_85 (Conv2D) (None, None, None, 3 655360 mixed9[0][0] \n", 1529 | "__________________________________________________________________________________________________\n", 1530 | "batch_normalization_87 (BatchNo (None, None, None, 3 1152 conv2d_87[0][0] \n", 1531 | "__________________________________________________________________________________________________\n", 1532 | "batch_normalization_88 (BatchNo (None, None, None, 3 1152 conv2d_88[0][0] \n", 1533 | "__________________________________________________________________________________________________\n", 1534 | "batch_normalization_91 (BatchNo (None, None, None, 3 1152 conv2d_91[0][0] \n", 1535 | "__________________________________________________________________________________________________\n", 1536 | "batch_normalization_92 (BatchNo (None, None, None, 3 1152 conv2d_92[0][0] \n", 1537 | "__________________________________________________________________________________________________\n", 1538 | "conv2d_93 (Conv2D) (None, None, None, 1 393216 average_pooling2d_8[0][0] \n", 1539 | "__________________________________________________________________________________________________\n", 1540 | "batch_normalization_85 (BatchNo (None, None, None, 3 960 conv2d_85[0][0] \n", 1541 | "__________________________________________________________________________________________________\n", 1542 | "activation_87 (Activation) (None, None, None, 3 0 batch_normalization_87[0][0] \n", 1543 | "__________________________________________________________________________________________________\n", 1544 | "activation_88 (Activation) (None, None, None, 3 0 batch_normalization_88[0][0] \n", 1545 | "__________________________________________________________________________________________________\n", 1546 | "activation_91 (Activation) (None, None, None, 3 0 batch_normalization_91[0][0] \n", 1547 | "__________________________________________________________________________________________________\n", 1548 | "activation_92 (Activation) (None, None, None, 3 0 batch_normalization_92[0][0] \n", 1549 | "__________________________________________________________________________________________________\n", 1550 | "batch_normalization_93 (BatchNo (None, None, None, 1 576 conv2d_93[0][0] \n", 1551 | "__________________________________________________________________________________________________\n", 1552 | "activation_85 (Activation) (None, None, None, 3 0 batch_normalization_85[0][0] \n", 1553 | "__________________________________________________________________________________________________\n", 1554 | "mixed9_1 (Concatenate) (None, None, None, 7 0 activation_87[0][0] \n", 1555 | " activation_88[0][0] \n", 1556 | "__________________________________________________________________________________________________\n", 1557 | "concatenate_1 (Concatenate) (None, None, None, 7 0 activation_91[0][0] \n", 1558 | " activation_92[0][0] \n", 1559 | "__________________________________________________________________________________________________\n", 1560 | "activation_93 (Activation) (None, None, None, 1 0 batch_normalization_93[0][0] \n", 1561 | "__________________________________________________________________________________________________\n", 1562 | "mixed10 (Concatenate) (None, None, None, 2 0 activation_85[0][0] \n", 1563 | " mixed9_1[0][0] \n", 1564 | " concatenate_1[0][0] \n", 1565 | " activation_93[0][0] \n", 1566 | "==================================================================================================\n", 1567 | "Total params: 21,802,784\n", 1568 | "Trainable params: 21,768,352\n", 1569 | "Non-trainable params: 34,432\n", 1570 | "__________________________________________________________________________________________________\n" 1571 | ] 1572 | } 1573 | ], 1574 | "source": [ 1575 | "encoder_model = tf.keras.applications.InceptionV3(include_top=False, weights='imagenet')\n", 1576 | "\n", 1577 | "new_input = encoder_model.input \n", 1578 | "hidden_layer = encoder_model.layers[-1].output\n", 1579 | "encoder_features_model = tf.keras.Model(new_input, hidden_layer)\n", 1580 | "\n", 1581 | "encoder_features_model.summary()" 1582 | ] 1583 | }, 1584 | { 1585 | "cell_type": "code", 1586 | "execution_count": null, 1587 | "metadata": { 1588 | "id": "_Q_xORSfgVpw" 1589 | }, 1590 | "outputs": [], 1591 | "source": [ 1592 | "# Extracting features from the encoder model and caching it \n", 1593 | "# Creating a dataset of tensors from the train images list\n", 1594 | "images_data = tf.data.Dataset.from_tensor_slices(train_images)\n", 1595 | "\n", 1596 | "# Mapping the preprocess method on the dataset and paralellizing it (num of batches: 64)\n", 1597 | "images_data = images_data.map(load_image_preprocess, num_parallel_calls = tf.data.AUTOTUNE).batch(64)\n", 1598 | "features_dict = {}\n", 1599 | "\n", 1600 | "start = time.time()\n", 1601 | "for img, filepath in tqdm(images_data):\n", 1602 | " features = encoder_features_model(img)\n", 1603 | " features = tf.reshape(features, (features.shape[0], -1, features.shape[3]))\n", 1604 | "\n", 1605 | " for f, path in zip(features, filepath):\n", 1606 | " features_path = path.numpy().decode('utf-8')\n", 1607 | " np.save(features_path, f.numpy())\n", 1608 | " features_dict[features_path] = f.numpy()\n", 1609 | " \n", 1610 | "end = time.time()" 1611 | ] 1612 | }, 1613 | { 1614 | "cell_type": "code", 1615 | "execution_count": null, 1616 | "metadata": { 1617 | "colab": { 1618 | "base_uri": "https://localhost:8080/" 1619 | }, 1620 | "id": "DrwM9us-gdX7", 1621 | "outputId": "352e1096-20ea-4c31-847c-9c2287341a64" 1622 | }, 1623 | "outputs": [ 1624 | { 1625 | "name": "stdout", 1626 | "output_type": "stream", 1627 | "text": [ 1628 | "Time taken to generate features vector (train data): 28.365445109208427\n" 1629 | ] 1630 | } 1631 | ], 1632 | "source": [ 1633 | "print('Time taken to generate features vector (train data): ', (end - start)/60)" 1634 | ] 1635 | }, 1636 | { 1637 | "cell_type": "markdown", 1638 | "metadata": { 1639 | "id": "fZd16R4agVXJ" 1640 | }, 1641 | "source": [ 1642 | "Checkpoint: The code snippet below is to save the features_dict generated by the IncpetionV3 model once. These image features of length 2048, would be used for in the decoder LSTM-model\n" 1643 | ] 1644 | }, 1645 | { 1646 | "cell_type": "code", 1647 | "execution_count": null, 1648 | "metadata": { 1649 | "id": "yUfNLFsIy1I_" 1650 | }, 1651 | "outputs": [], 1652 | "source": [ 1653 | "# Saving the train and test features dictionary\n", 1654 | "from pickle import dump, load\n", 1655 | "with open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/train_features.pkl', 'wb') as features_file:\n", 1656 | " pickle.dump(features_dict, features_file)\n", 1657 | "\n", 1658 | "from pickle import dump, load\n", 1659 | "with open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/test_features.pkl', 'wb') as features_file:\n", 1660 | " pickle.dump(features_dict, features_file)" 1661 | ] 1662 | }, 1663 | { 1664 | "cell_type": "markdown", 1665 | "metadata": { 1666 | "id": "XjSYESq8O3zc" 1667 | }, 1668 | "source": [ 1669 | "### **4. LSTM Decoder**" 1670 | ] 1671 | }, 1672 | { 1673 | "cell_type": "markdown", 1674 | "metadata": { 1675 | "id": "TjW6yDwzfaOu" 1676 | }, 1677 | "source": [ 1678 | "The following function is used to format the data needed to input to the Deep Learning decoder model. \n", 1679 | "\n", 1680 | "> Caption: Consider the caption '(start) a child in a pink dress is climbing up a set of stairs in an entry way (end)' and a features_vector generated by the InceptionV3 model.\n", 1681 | "\n", 1682 | "> The function converts it into the input format:\n", 1683 | "\n", 1684 | "* features_vector + '(start)'\n", 1685 | "* features_vector + '(start) a'\n", 1686 | "* features_vector + '(start) a child'\n", 1687 | "* features_vector + '(start) a child in'\n", 1688 | "\n", 1689 | "... and so on.\n", 1690 | "\n", 1691 | "\n", 1692 | "\n" 1693 | ] 1694 | }, 1695 | { 1696 | "cell_type": "code", 1697 | "execution_count": 17, 1698 | "metadata": { 1699 | "id": "eJ2qLXYefUkW" 1700 | }, 1701 | "outputs": [], 1702 | "source": [ 1703 | "root_dir = '/content/gdrive/MyDrive/Deep_Learning/Flickr8k_Dataset/Flicker8k_Dataset/' \n", 1704 | "\n", 1705 | "def decoder_data_generator(dictionary, features_dict, token_to_idx, max_caption, images_batch_size):\n", 1706 | " X1, X2, y = list(), list(), list()\n", 1707 | " n=0\n", 1708 | " while 1:\n", 1709 | " for key, desc_list in dictionary.items():\n", 1710 | " n+=1\n", 1711 | "\n", 1712 | " image = features_dict[root_dir + key + '.jpg']\n", 1713 | " for desc in desc_list:\n", 1714 | " # encoding the input caption\n", 1715 | " seq = [token_to_idx[word] for word in desc.split(' ') if word in token_to_idx] \n", 1716 | " \n", 1717 | " for i in range(1, len(seq)): \n", 1718 | " in_seq, out_seq = seq[:i], seq[i] \n", 1719 | " in_seq = keras.preprocessing.sequence.pad_sequences([in_seq], maxlen=max_caption)[0] \n", 1720 | "\n", 1721 | " # Encoding the output caption \n", 1722 | " out_seq = keras.utils.to_categorical([out_seq], num_classes=vocab_size)[0] \n", 1723 | " X1.append(image)\n", 1724 | " X2.append(in_seq)\n", 1725 | " y.append(out_seq)\n", 1726 | " \n", 1727 | " if n == images_batch_size: # yield the batch data\n", 1728 | " yield [np.array(X1), np.array(X2)], np.array(y)\n", 1729 | " X1, X2, y = list(), list(), list()\n", 1730 | " n=0" 1731 | ] 1732 | }, 1733 | { 1734 | "cell_type": "code", 1735 | "execution_count": 18, 1736 | "metadata": { 1737 | "id": "9qo7AyQPC3gW" 1738 | }, 1739 | "outputs": [], 1740 | "source": [ 1741 | "def decoder_model():\n", 1742 | "\n", 1743 | " input_1 = keras.Input(shape=(2048,)) \n", 1744 | " dropout_1 = keras.layers.Dropout(0.5)(input_1)\n", 1745 | " dense_1 = keras.layers.Dense(256, activation = 'relu')(dropout_1)\n", 1746 | "\n", 1747 | " input_2 = keras.Input(shape=(max_caption,))\n", 1748 | " embeddings_layer = keras.layers.Embedding(vocab_size, embeddings_size, mask_zero = True)(input_2)\n", 1749 | " dropout_2 = keras.layers.Dropout(0.5)(embeddings_layer)\n", 1750 | " lstm_layer = keras.layers.LSTM(256)(dropout_2)\n", 1751 | "\n", 1752 | " add_1 = keras.layers.merge.add([dense_1, lstm_layer])\n", 1753 | " dense_2 = keras.layers.Dense(256, activation = 'relu')(add_1)\n", 1754 | " output_layer = keras.layers.Dense(vocab_size, activation = 'softmax')(dense_2)\n", 1755 | " model = keras.models.Model(inputs = [input_1, input_2], outputs = output_layer)\n", 1756 | " \n", 1757 | " return model" 1758 | ] 1759 | }, 1760 | { 1761 | "cell_type": "code", 1762 | "execution_count": 21, 1763 | "metadata": { 1764 | "colab": { 1765 | "base_uri": "https://localhost:8080/" 1766 | }, 1767 | "id": "42Wrm0BYHbGI", 1768 | "outputId": "94574ff4-ab38-4867-8e6d-cba0998977f3" 1769 | }, 1770 | "outputs": [ 1771 | { 1772 | "name": "stdout", 1773 | "output_type": "stream", 1774 | "text": [ 1775 | "Model: \"model\"\n", 1776 | "__________________________________________________________________________________________________\n", 1777 | "Layer (type) Output Shape Param # Connected to \n", 1778 | "==================================================================================================\n", 1779 | "input_4 (InputLayer) [(None, 37)] 0 \n", 1780 | "__________________________________________________________________________________________________\n", 1781 | "input_3 (InputLayer) [(None, 2048)] 0 \n", 1782 | "__________________________________________________________________________________________________\n", 1783 | "embedding (Embedding) (None, 37, 200) 331000 input_4[0][0] \n", 1784 | "__________________________________________________________________________________________________\n", 1785 | "dropout_1 (Dropout) (None, 2048) 0 input_3[0][0] \n", 1786 | "__________________________________________________________________________________________________\n", 1787 | "dropout_2 (Dropout) (None, 37, 200) 0 embedding[0][0] \n", 1788 | "__________________________________________________________________________________________________\n", 1789 | "dense_1 (Dense) (None, 256) 524544 dropout_1[0][0] \n", 1790 | "__________________________________________________________________________________________________\n", 1791 | "lstm (LSTM) (None, 256) 467968 dropout_2[0][0] \n", 1792 | "__________________________________________________________________________________________________\n", 1793 | "add (Add) (None, 256) 0 dense_1[0][0] \n", 1794 | " lstm[0][0] \n", 1795 | "__________________________________________________________________________________________________\n", 1796 | "dense_2 (Dense) (None, 256) 65792 add[0][0] \n", 1797 | "__________________________________________________________________________________________________\n", 1798 | "dense_3 (Dense) (None, 1655) 425335 dense_2[0][0] \n", 1799 | "==================================================================================================\n", 1800 | "Total params: 1,814,639\n", 1801 | "Trainable params: 1,814,639\n", 1802 | "Non-trainable params: 0\n", 1803 | "__________________________________________________________________________________________________\n" 1804 | ] 1805 | } 1806 | ], 1807 | "source": [ 1808 | "LSTM_decoder = decoder_model()\n", 1809 | "LSTM_decoder.summary()" 1810 | ] 1811 | }, 1812 | { 1813 | "cell_type": "markdown", 1814 | "metadata": { 1815 | "id": "NK2-ReinM076" 1816 | }, 1817 | "source": [ 1818 | "#### Defining LSTM decoder loss and optimizer and setting embeddings weights" 1819 | ] 1820 | }, 1821 | { 1822 | "cell_type": "code", 1823 | "execution_count": 24, 1824 | "metadata": { 1825 | "id": "UwoHK8ICXQgT" 1826 | }, 1827 | "outputs": [], 1828 | "source": [ 1829 | "embeddings = load(open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/embeddings.pkl', 'rb'))\n", 1830 | "features_dict = load(open('/content/gdrive/MyDrive/Deep_Learning/Saved_files/train_features.pkl', 'rb'))\n", 1831 | "\n", 1832 | "LSTM_decoder.layers[2].set_weights([embeddings])\n", 1833 | "LSTM_decoder.layers[2].trainable = False\n", 1834 | "\n", 1835 | "LSTM_decoder.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.001))\n", 1836 | "\n", 1837 | "def model_parameters(model, embeddings):\n", 1838 | " embeddings_layer = model.layers[2]\n", 1839 | " embeddings_layer.set_weights([embeddings])\n", 1840 | " embeddings_layer.trainable = False\n", 1841 | " model.layers[2] = embeddings_layer\n", 1842 | "\n", 1843 | " model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(lr=0.001))\n", 1844 | " return model\n", 1845 | "\n", 1846 | "LSTM_decoder = model_parameters(LSTM_decoder, embeddings)" 1847 | ] 1848 | }, 1849 | { 1850 | "cell_type": "code", 1851 | "execution_count": 26, 1852 | "metadata": { 1853 | "colab": { 1854 | "base_uri": "https://localhost:8080/" 1855 | }, 1856 | "id": "w_LJz-4zXWRC", 1857 | "outputId": "7c1a258a-c476-4bab-f89d-897ded4076a5" 1858 | }, 1859 | "outputs": [ 1860 | { 1861 | "name": "stdout", 1862 | "output_type": "stream", 1863 | "text": [ 1864 | "\r 1/1000 [..............................] - ETA: 1:41 - loss: 3.2640" 1865 | ] 1866 | }, 1867 | { 1868 | "name": "stderr", 1869 | "output_type": "stream", 1870 | "text": [ 1871 | "/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/engine/training.py:1844: UserWarning: `Model.fit_generator` is deprecated and will be removed in a future version. Please use `Model.fit`, which supports generators.\n", 1872 | " warnings.warn('`Model.fit_generator` is deprecated and '\n" 1873 | ] 1874 | }, 1875 | { 1876 | "name": "stdout", 1877 | "output_type": "stream", 1878 | "text": [ 1879 | "1000/1000 [==============================] - 102s 102ms/step - loss: 3.0930\n", 1880 | "1000/1000 [==============================] - 105s 105ms/step - loss: 2.8734\n", 1881 | "1000/1000 [==============================] - 105s 105ms/step - loss: 2.7477\n", 1882 | "1000/1000 [==============================] - 104s 104ms/step - loss: 2.6564\n", 1883 | "1000/1000 [==============================] - 104s 104ms/step - loss: 2.5849\n", 1884 | "1000/1000 [==============================] - 103s 103ms/step - loss: 2.5272\n", 1885 | "1000/1000 [==============================] - 102s 102ms/step - loss: 2.4774\n", 1886 | "1000/1000 [==============================] - 101s 101ms/step - loss: 2.4355\n", 1887 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.3999\n", 1888 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.3669\n", 1889 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.3382\n", 1890 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.3127\n", 1891 | "1000/1000 [==============================] - 99s 98ms/step - loss: 2.2913\n", 1892 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.2705\n", 1893 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.2504\n", 1894 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.2334\n", 1895 | "1000/1000 [==============================] - 99s 98ms/step - loss: 2.2185\n", 1896 | "1000/1000 [==============================] - 99s 99ms/step - loss: 2.2012\n", 1897 | "1000/1000 [==============================] - 104s 104ms/step - loss: 2.1881\n", 1898 | "1000/1000 [==============================] - 103s 103ms/step - loss: 2.1762\n", 1899 | "1000/1000 [==============================] - 102s 102ms/step - loss: 2.1608\n", 1900 | "1000/1000 [==============================] - 101s 101ms/step - loss: 2.1506\n", 1901 | "1000/1000 [==============================] - 102s 102ms/step - loss: 2.1413\n", 1902 | "1000/1000 [==============================] - 100s 100ms/step - loss: 2.1334\n", 1903 | "1000/1000 [==============================] - 100s 100ms/step - loss: 2.1226\n", 1904 | "1000/1000 [==============================] - 101s 101ms/step - loss: 2.1129\n", 1905 | "1000/1000 [==============================] - 101s 101ms/step - loss: 2.1076\n", 1906 | "1000/1000 [==============================] - 102s 102ms/step - loss: 2.0991\n", 1907 | "1000/1000 [==============================] - 102s 102ms/step - loss: 2.0897\n", 1908 | "1000/1000 [==============================] - 101s 101ms/step - loss: 2.0817\n" 1909 | ] 1910 | } 1911 | ], 1912 | "source": [ 1913 | "epochs = 30\n", 1914 | "images_per_batch = 6\n", 1915 | "steps = len(train_dictionary)//images_per_batch\n", 1916 | "\n", 1917 | "for i in range(epochs):\n", 1918 | " generator = decoder_data_generator(train_dictionary, features_dict, token_to_idx, max_caption, images_per_batch)\n", 1919 | " LSTM_decoder.fit_generator(generator, epochs=1, steps_per_epoch = steps, verbose=1)\n", 1920 | " LSTM_decoder.save('/content/gdrive/MyDrive/Deep_Learning/Saved_files/models/model_' + str(i) + '.h5')\n" 1921 | ] 1922 | }, 1923 | { 1924 | "cell_type": "code", 1925 | "execution_count": 33, 1926 | "metadata": { 1927 | "id": "ND0bdI9e9t73" 1928 | }, 1929 | "outputs": [], 1930 | "source": [ 1931 | "LSTM_decoder.save('/content/gdrive/MyDrive/Deep_Learning/Saved_files/models/trained_model' + '.h5')" 1932 | ] 1933 | } 1934 | ], 1935 | "metadata": { 1936 | "accelerator": "GPU", 1937 | "colab": { 1938 | "collapsed_sections": [], 1939 | "name": "encoder_decoder.ipynb", 1940 | "provenance": [] 1941 | }, 1942 | "kernelspec": { 1943 | "display_name": "Python 3", 1944 | "name": "python3" 1945 | }, 1946 | "language_info": { 1947 | "name": "python" 1948 | } 1949 | }, 1950 | "nbformat": 4, 1951 | "nbformat_minor": 0 1952 | } 1953 | --------------------------------------------------------------------------------