├── .gitignore ├── CIFAR10_Image_Classifier ├── Cifar10_ImageClassifier.ipynb ├── Readme.md └── cifar10_img.png ├── ConvolutionalNeuralNetworkVisualizer ├── ConvolutionalNeuralNetwork_Visualizer.ipynb ├── Readme.md └── cool_cat.jpg ├── FaceDetectionOpenCV ├── Readme.md ├── deploy.prototxt.txt ├── face_detection_ssd_parallel.py └── res10_300x300_ssd_iter_140000.caffemodel ├── MultiThreadedVideoProcessing ├── Readme.md ├── video_processing_parallel.py └── video_processing_simple.py ├── NeuralStyleTransfer ├── Neural_Style_Transfer_Tensorflow.ipynb ├── README.md ├── content.jpg ├── neural_style_transfer.png └── style_mosaic.jpg ├── README.md ├── StreetViewHouseNumbers_Classifier ├── Colab_ImageClassifier_SVHN.ipynb ├── Readme.md └── SVHN_Overview_Image.png ├── TransferLearningResnet ├── Readme.md ├── Transfer_Learning_ResNet_ImageClassifier.ipynb └── cifar10_img.png └── VideoActivityRecognition3DResnet ├── Readme.md ├── img_activity_recognition.jpg └── video_activity_recognition_3DResnets.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | CIFAR10_Image_Classifier.zip 2 | ConvolutionalNeuralNetworkVisualizer.zip 3 | NeuralStyleTransfer.zip 4 | StreetViewHouseNumbers_Classifier.zip 5 | TransferLearningResnet.zip -------------------------------------------------------------------------------- /CIFAR10_Image_Classifier/Cifar10_ImageClassifier.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Cifar10_ImageClassifier_v2.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "toc_visible": true, 10 | "machine_shape": "hm", 11 | "authorship_tag": "ABX9TyPCgLrK1cIJtC5kaIsuHVGK", 12 | "include_colab_link": true 13 | }, 14 | "kernelspec": { 15 | "display_name": "Python 3", 16 | "name": "python3" 17 | }, 18 | "accelerator": "GPU" 19 | }, 20 | "cells": [ 21 | { 22 | "cell_type": "markdown", 23 | "metadata": { 24 | "id": "view-in-github", 25 | "colab_type": "text" 26 | }, 27 | "source": [ 28 | "\"Open" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "metadata": { 34 | "id": "MjzPfXdR50ff" 35 | }, 36 | "source": [ 37 | "# importing required libraries\n", 38 | "import numpy as np\n", 39 | "import matplotlib.pyplot as plt \n", 40 | "from tensorflow.keras.datasets import cifar10\n", 41 | "from tensorflow.keras.models import Sequential\n", 42 | "from tensorflow.keras.layers import Conv2D, Dense, Flatten, MaxPooling2D, BatchNormalization, Dropout" 43 | ], 44 | "execution_count": 1, 45 | "outputs": [] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "metadata": { 50 | "colab": { 51 | "base_uri": "https://localhost:8080/" 52 | }, 53 | "id": "xwJrg32a7itw", 54 | "outputId": "b9c76392-242f-435b-d63e-c2c906f8698a" 55 | }, 56 | "source": [ 57 | "# Loading the cifar-10 dataset \n", 58 | "# cifar10 is a dataset of 50,000 32x32 color training images and 10,000 test images, labeled over 10 categories. \n", 59 | "(x_train, y_train), (x_test, y_test) = cifar10.load_data()\n", 60 | "print(x_train.shape, y_train.shape)\n", 61 | "print(x_test.shape, y_test.shape)\n", 62 | "print(np.min(x_train), np.max(x_train)) # to check if scaling to the range 0-1 is needed\n", 63 | "print(np.min(y_train), np.max(y_train))" 64 | ], 65 | "execution_count": 2, 66 | "outputs": [ 67 | { 68 | "output_type": "stream", 69 | "text": [ 70 | "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n", 71 | "170500096/170498071 [==============================] - 4s 0us/step\n", 72 | "(50000, 32, 32, 3) (50000, 1)\n", 73 | "(10000, 32, 32, 3) (10000, 1)\n", 74 | "0 255\n", 75 | "0 9\n" 76 | ], 77 | "name": "stdout" 78 | } 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "metadata": { 84 | "id": "CL2-Mc0TE_he" 85 | }, 86 | "source": [ 87 | "# scaling x_train and x_test values to the range 0-1\n", 88 | "x_train_scaled = x_train/255.\n", 89 | "x_test_scaled = x_test/255.\n", 90 | "# y_train, y_test values are already labelled as integers from 0 to 9 , so no preprocessing required" 91 | ], 92 | "execution_count": 3, 93 | "outputs": [] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "metadata": { 98 | "colab": { 99 | "base_uri": "https://localhost:8080/" 100 | }, 101 | "id": "b2A2O8cjFhbE", 102 | "outputId": "56207d39-de18-44be-be46-75676649f9ec" 103 | }, 104 | "source": [ 105 | "# Defining the CNN architecture using keras Sequential API (a minified version of VGGNet)\n", 106 | "model = Sequential()\n", 107 | "model.add(Conv2D(32, kernel_size=(3,3), padding=\"same\", activation=\"relu\", input_shape=(32,32,3)))\n", 108 | "model.add(BatchNormalization())\n", 109 | "model.add(Conv2D(32, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n", 110 | "model.add(BatchNormalization())\n", 111 | "model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2)))\n", 112 | "model.add(Dropout(0.25))\n", 113 | "model.add(Conv2D(64, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n", 114 | "model.add(BatchNormalization())\n", 115 | "model.add(Conv2D(64, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n", 116 | "model.add(BatchNormalization())\n", 117 | "model.add(MaxPooling2D(pool_size=(2,2), strides=(2,2)))\n", 118 | "model.add(Dropout(0.25))\n", 119 | "model.add(Flatten())\n", 120 | "model.add(Dense(512, activation=\"relu\"))\n", 121 | "model.add(BatchNormalization())\n", 122 | "model.add(Dropout(0.5))\n", 123 | "model.add(Dense(10, activation=\"softmax\"))\n", 124 | "\n", 125 | "# printing model summary\n", 126 | "model.summary()\n", 127 | "\n", 128 | "# Compiling the model \n", 129 | "model.compile(loss=\"sparse_categorical_crossentropy\", optimizer=\"adam\", metrics=[\"accuracy\"])" 130 | ], 131 | "execution_count": 4, 132 | "outputs": [ 133 | { 134 | "output_type": "stream", 135 | "text": [ 136 | "Model: \"sequential\"\n", 137 | "_________________________________________________________________\n", 138 | "Layer (type) Output Shape Param # \n", 139 | "=================================================================\n", 140 | "conv2d (Conv2D) (None, 32, 32, 32) 896 \n", 141 | "_________________________________________________________________\n", 142 | "batch_normalization (BatchNo (None, 32, 32, 32) 128 \n", 143 | "_________________________________________________________________\n", 144 | "conv2d_1 (Conv2D) (None, 32, 32, 32) 9248 \n", 145 | "_________________________________________________________________\n", 146 | "batch_normalization_1 (Batch (None, 32, 32, 32) 128 \n", 147 | "_________________________________________________________________\n", 148 | "max_pooling2d (MaxPooling2D) (None, 16, 16, 32) 0 \n", 149 | "_________________________________________________________________\n", 150 | "dropout (Dropout) (None, 16, 16, 32) 0 \n", 151 | "_________________________________________________________________\n", 152 | "conv2d_2 (Conv2D) (None, 16, 16, 64) 18496 \n", 153 | "_________________________________________________________________\n", 154 | "batch_normalization_2 (Batch (None, 16, 16, 64) 256 \n", 155 | "_________________________________________________________________\n", 156 | "conv2d_3 (Conv2D) (None, 16, 16, 64) 36928 \n", 157 | "_________________________________________________________________\n", 158 | "batch_normalization_3 (Batch (None, 16, 16, 64) 256 \n", 159 | "_________________________________________________________________\n", 160 | "max_pooling2d_1 (MaxPooling2 (None, 8, 8, 64) 0 \n", 161 | "_________________________________________________________________\n", 162 | "dropout_1 (Dropout) (None, 8, 8, 64) 0 \n", 163 | "_________________________________________________________________\n", 164 | "flatten (Flatten) (None, 4096) 0 \n", 165 | "_________________________________________________________________\n", 166 | "dense (Dense) (None, 512) 2097664 \n", 167 | "_________________________________________________________________\n", 168 | "batch_normalization_4 (Batch (None, 512) 2048 \n", 169 | "_________________________________________________________________\n", 170 | "dropout_2 (Dropout) (None, 512) 0 \n", 171 | "_________________________________________________________________\n", 172 | "dense_1 (Dense) (None, 10) 5130 \n", 173 | "=================================================================\n", 174 | "Total params: 2,171,178\n", 175 | "Trainable params: 2,169,770\n", 176 | "Non-trainable params: 1,408\n", 177 | "_________________________________________________________________\n" 178 | ], 179 | "name": "stdout" 180 | } 181 | ] 182 | }, 183 | { 184 | "cell_type": "code", 185 | "metadata": { 186 | "colab": { 187 | "base_uri": "https://localhost:8080/" 188 | }, 189 | "id": "T1JX59wSF-Lv", 190 | "outputId": "a73c23f1-8bd2-43c6-9df9-726c890a66d7" 191 | }, 192 | "source": [ 193 | "# Training the model \n", 194 | "history = model.fit(x_train_scaled, y_train, batch_size=64, epochs=40, validation_data=(x_test_scaled, y_test), verbose=2)" 195 | ], 196 | "execution_count": 6, 197 | "outputs": [ 198 | { 199 | "output_type": "stream", 200 | "text": [ 201 | "Epoch 1/40\n", 202 | "782/782 - 20s - loss: 1.4748 - accuracy: 0.5088 - val_loss: 1.0989 - val_accuracy: 0.6155\n", 203 | "Epoch 2/40\n", 204 | "782/782 - 4s - loss: 0.9532 - accuracy: 0.6642 - val_loss: 3.6966 - val_accuracy: 0.2994\n", 205 | "Epoch 3/40\n", 206 | "782/782 - 4s - loss: 0.8142 - accuracy: 0.7133 - val_loss: 1.0699 - val_accuracy: 0.6588\n", 207 | "Epoch 4/40\n", 208 | "782/782 - 4s - loss: 0.7352 - accuracy: 0.7435 - val_loss: 0.6923 - val_accuracy: 0.7580\n", 209 | "Epoch 5/40\n", 210 | "782/782 - 4s - loss: 0.6651 - accuracy: 0.7642 - val_loss: 0.6709 - val_accuracy: 0.7713\n", 211 | "Epoch 6/40\n", 212 | "782/782 - 4s - loss: 0.6095 - accuracy: 0.7856 - val_loss: 0.7959 - val_accuracy: 0.7364\n", 213 | "Epoch 7/40\n", 214 | "782/782 - 4s - loss: 0.5581 - accuracy: 0.8040 - val_loss: 0.5927 - val_accuracy: 0.7970\n", 215 | "Epoch 8/40\n", 216 | "782/782 - 4s - loss: 0.5189 - accuracy: 0.8168 - val_loss: 0.6359 - val_accuracy: 0.7847\n", 217 | "Epoch 9/40\n", 218 | "782/782 - 4s - loss: 0.4788 - accuracy: 0.8311 - val_loss: 0.5534 - val_accuracy: 0.8137\n", 219 | "Epoch 10/40\n", 220 | "782/782 - 4s - loss: 0.4419 - accuracy: 0.8447 - val_loss: 0.6788 - val_accuracy: 0.7834\n", 221 | "Epoch 11/40\n", 222 | "782/782 - 4s - loss: 0.4076 - accuracy: 0.8566 - val_loss: 0.6475 - val_accuracy: 0.7919\n", 223 | "Epoch 12/40\n", 224 | "782/782 - 4s - loss: 0.3912 - accuracy: 0.8626 - val_loss: 0.6400 - val_accuracy: 0.7905\n", 225 | "Epoch 13/40\n", 226 | "782/782 - 4s - loss: 0.3676 - accuracy: 0.8695 - val_loss: 0.5595 - val_accuracy: 0.8173\n", 227 | "Epoch 14/40\n", 228 | "782/782 - 4s - loss: 0.3337 - accuracy: 0.8804 - val_loss: 0.6950 - val_accuracy: 0.7885\n", 229 | "Epoch 15/40\n", 230 | "782/782 - 4s - loss: 0.3138 - accuracy: 0.8882 - val_loss: 0.6289 - val_accuracy: 0.8036\n", 231 | "Epoch 16/40\n", 232 | "782/782 - 4s - loss: 0.3163 - accuracy: 0.8884 - val_loss: 0.5864 - val_accuracy: 0.8213\n", 233 | "Epoch 17/40\n", 234 | "782/782 - 4s - loss: 0.2875 - accuracy: 0.8976 - val_loss: 0.5803 - val_accuracy: 0.8184\n", 235 | "Epoch 18/40\n", 236 | "782/782 - 4s - loss: 0.2745 - accuracy: 0.9024 - val_loss: 0.6515 - val_accuracy: 0.8099\n", 237 | "Epoch 19/40\n", 238 | "782/782 - 4s - loss: 0.2605 - accuracy: 0.9081 - val_loss: 0.6302 - val_accuracy: 0.8155\n", 239 | "Epoch 20/40\n", 240 | "782/782 - 4s - loss: 0.2476 - accuracy: 0.9112 - val_loss: 0.5855 - val_accuracy: 0.8273\n", 241 | "Epoch 21/40\n", 242 | "782/782 - 4s - loss: 0.2432 - accuracy: 0.9142 - val_loss: 0.6192 - val_accuracy: 0.8196\n", 243 | "Epoch 22/40\n", 244 | "782/782 - 4s - loss: 0.2368 - accuracy: 0.9165 - val_loss: 0.6565 - val_accuracy: 0.8243\n", 245 | "Epoch 23/40\n", 246 | "782/782 - 4s - loss: 0.2182 - accuracy: 0.9230 - val_loss: 0.5994 - val_accuracy: 0.8281\n", 247 | "Epoch 24/40\n", 248 | "782/782 - 4s - loss: 0.2184 - accuracy: 0.9231 - val_loss: 0.6279 - val_accuracy: 0.8204\n", 249 | "Epoch 25/40\n", 250 | "782/782 - 4s - loss: 0.2067 - accuracy: 0.9278 - val_loss: 0.5764 - val_accuracy: 0.8358\n", 251 | "Epoch 26/40\n", 252 | "782/782 - 4s - loss: 0.1998 - accuracy: 0.9291 - val_loss: 0.5831 - val_accuracy: 0.8359\n", 253 | "Epoch 27/40\n", 254 | "782/782 - 4s - loss: 0.1929 - accuracy: 0.9316 - val_loss: 0.6074 - val_accuracy: 0.8339\n", 255 | "Epoch 28/40\n", 256 | "782/782 - 4s - loss: 0.1918 - accuracy: 0.9311 - val_loss: 0.6144 - val_accuracy: 0.8290\n", 257 | "Epoch 29/40\n", 258 | "782/782 - 4s - loss: 0.1897 - accuracy: 0.9332 - val_loss: 0.5774 - val_accuracy: 0.8377\n", 259 | "Epoch 30/40\n", 260 | "782/782 - 4s - loss: 0.1908 - accuracy: 0.9328 - val_loss: 0.6057 - val_accuracy: 0.8367\n", 261 | "Epoch 31/40\n", 262 | "782/782 - 4s - loss: 0.1724 - accuracy: 0.9394 - val_loss: 0.6022 - val_accuracy: 0.8353\n", 263 | "Epoch 32/40\n", 264 | "782/782 - 4s - loss: 0.1679 - accuracy: 0.9412 - val_loss: 0.6457 - val_accuracy: 0.8297\n", 265 | "Epoch 33/40\n", 266 | "782/782 - 4s - loss: 0.1659 - accuracy: 0.9401 - val_loss: 0.7429 - val_accuracy: 0.8173\n", 267 | "Epoch 34/40\n", 268 | "782/782 - 4s - loss: 0.1665 - accuracy: 0.9422 - val_loss: 0.6386 - val_accuracy: 0.8347\n", 269 | "Epoch 35/40\n", 270 | "782/782 - 4s - loss: 0.1641 - accuracy: 0.9411 - val_loss: 0.6328 - val_accuracy: 0.8298\n", 271 | "Epoch 36/40\n", 272 | "782/782 - 4s - loss: 0.1527 - accuracy: 0.9462 - val_loss: 0.6865 - val_accuracy: 0.8236\n", 273 | "Epoch 37/40\n", 274 | "782/782 - 4s - loss: 0.1524 - accuracy: 0.9456 - val_loss: 0.6909 - val_accuracy: 0.8270\n", 275 | "Epoch 38/40\n", 276 | "782/782 - 4s - loss: 0.1472 - accuracy: 0.9484 - val_loss: 0.7240 - val_accuracy: 0.8218\n", 277 | "Epoch 39/40\n", 278 | "782/782 - 4s - loss: 0.1456 - accuracy: 0.9484 - val_loss: 0.6283 - val_accuracy: 0.8368\n", 279 | "Epoch 40/40\n", 280 | "782/782 - 4s - loss: 0.1409 - accuracy: 0.9503 - val_loss: 0.6493 - val_accuracy: 0.8256\n" 281 | ], 282 | "name": "stdout" 283 | } 284 | ] 285 | }, 286 | { 287 | "cell_type": "code", 288 | "metadata": { 289 | "id": "tChTuxzcGUcA", 290 | "colab": { 291 | "base_uri": "https://localhost:8080/", 292 | "height": 299 293 | }, 294 | "outputId": "3f1a63ee-0d41-433c-a70d-1bce7aef8ded" 295 | }, 296 | "source": [ 297 | "# plotting loss and accuracy values \n", 298 | "num_epochs=40\n", 299 | "plt.style.use('ggplot')\n", 300 | "plt.figure()\n", 301 | "plt.plot(np.arange(num_epochs), history.history[\"loss\"], label=\"train_loss\")\n", 302 | "plt.plot(np.arange(num_epochs), history.history[\"val_loss\"], label=\"val_loss\")\n", 303 | "plt.plot(np.arange(num_epochs), history.history[\"accuracy\"], label=\"train_acc\")\n", 304 | "plt.plot(np.arange(num_epochs), history.history[\"val_accuracy\"], label=\"val_acc\")\n", 305 | "plt.title(\"Accuracy and Loss Curves\")\n", 306 | "plt.xlabel(\"Epoch #\")\n", 307 | "plt.ylabel(\"Accuracy/Loss\")\n", 308 | "plt.legend()\n", 309 | "plt.show()\n" 310 | ], 311 | "execution_count": 7, 312 | "outputs": [ 313 | { 314 | "output_type": "display_data", 315 | "data": { 316 | "image/png": "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\n", 317 | "text/plain": [ 318 | "
" 319 | ] 320 | }, 321 | "metadata": { 322 | "tags": [] 323 | } 324 | } 325 | ] 326 | } 327 | ] 328 | } -------------------------------------------------------------------------------- /CIFAR10_Image_Classifier/Readme.md: -------------------------------------------------------------------------------- 1 | # This project is an Image Classifier for the CIFAR-10 dataset containing 10 different image classes - airplanes, automobiles, birds, cats, deer, dogs, frogs, horses, ships, and trucks. 2 | 3 | ![Example images from cifar-10 dataset](cifar10_img.png) 4 | [*Image Source*](https://www.cs.toronto.edu/~kriz/cifar.html) 5 | 6 | ## Project folder includes 7 | 1. Readme.md (this file) 8 | 2. Google colab notebook for building, training and testing a Convolutional Neural Network on the CIFAR-10 dataset. 9 | 3. Misc 10 | - CIFAR-10 overview image 11 | 12 | ## Programming language and Libraries used 13 | 1. Python programming language 14 | 2. Deep learning libraries tensorflow 2.x and Keras API 15 | 3. Python libraries including numpy, etc 16 | 17 | ## Notes 18 | 1. Purpose of this project is to demonstrate how to build, train and evaluate a simple CNN model for classifying images in the cifar-10 dataset 19 | -------------------------------------------------------------------------------- /CIFAR10_Image_Classifier/cifar10_img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/CIFAR10_Image_Classifier/cifar10_img.png -------------------------------------------------------------------------------- /ConvolutionalNeuralNetworkVisualizer/Readme.md: -------------------------------------------------------------------------------- 1 | # This project is a Convolutional Neural Network Visualizer for visualizing outputs from inner convolutional layers within a CNN model. 2 | 3 | ![Example Cool Cat Image](cool_cat.jpg) 4 | [*Image Source*](https://i.pinimg.com/originals/73/fd/d4/73fdd4752a176af8f388b31a67e93d87.jpg) 5 | 6 | ## Project folder includes 7 | 1. Readme.md (this file) 8 | 2. Google colab notebook for visualizing the CNN layer outputs on the Cool Cat image 9 | 3. Misc 10 | - Cool Cat Image - 11 | In Zambia’s South Luangwa National Park, a photographer had been watching a pride of lions while they slept off a feast from a buffalo kill. When this female walked away, he anticipated that she might be going for a drink and so he positioned his vehicle on the opposite side of the waterhole. The cool cat picture is one of the highly commended 2018 Image from Wildlife Photographer of the Year. 12 | 13 | ## Programming language and Libraries used 14 | 1. Python programming language 15 | 2. Deep learning libraries tensorflow 2.x and Keras API 16 | 3. Python libraries including numpy, etc 17 | 18 | ## Notes 19 | 1. Purpose of this project is to demonstrate how to use the functional api in keras to visualize outputs from inner layers within a CNN. 20 | -------------------------------------------------------------------------------- /ConvolutionalNeuralNetworkVisualizer/cool_cat.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/ConvolutionalNeuralNetworkVisualizer/cool_cat.jpg -------------------------------------------------------------------------------- /FaceDetectionOpenCV/Readme.md: -------------------------------------------------------------------------------- 1 | # Real-Time Face Detection Using OpenCV 2 | 1. face_detection_ssd_parallel.py script is used for performing real-time face detection on input stream from webcam connected to a laptop or desktop 3 | 2. Pre-trained deep learning model for face detection from OpenCV is used Link 4 | 3. Imutils library is used for reading frames from webcam in a multi-threaded approach for achieving higher FPS Link 5 | 4. Model architecture is a Single Shot Detector (SSD) framework with a ResNet backbone 6 | 5. Model files are in caffe format 7 | * deploy.prototxt.txt - defines model architecture 8 | * res10_300x300_ssd_iter_140000.caffemodel - contains trained model weights 9 | 6. Model files can also be directly downloaded from OpenCV repository. Useful links: Link1 Link2 Link3 10 | 11 | ## Programming language and libraries used 12 | 1. Python programming language 13 | 2. OpenCV library 14 | 3. Imutils library (install using -> pip install imutils) 15 | 4. Other Python libraries including Numpy library 16 | 17 | -------------------------------------------------------------------------------- /FaceDetectionOpenCV/deploy.prototxt.txt: -------------------------------------------------------------------------------- 1 | input: "data" 2 | input_shape { 3 | dim: 1 4 | dim: 3 5 | dim: 300 6 | dim: 300 7 | } 8 | 9 | layer { 10 | name: "data_bn" 11 | type: "BatchNorm" 12 | bottom: "data" 13 | top: "data_bn" 14 | param { 15 | lr_mult: 0.0 16 | } 17 | param { 18 | lr_mult: 0.0 19 | } 20 | param { 21 | lr_mult: 0.0 22 | } 23 | } 24 | layer { 25 | name: "data_scale" 26 | type: "Scale" 27 | bottom: "data_bn" 28 | top: "data_bn" 29 | param { 30 | lr_mult: 1.0 31 | decay_mult: 1.0 32 | } 33 | param { 34 | lr_mult: 2.0 35 | decay_mult: 1.0 36 | } 37 | scale_param { 38 | bias_term: true 39 | } 40 | } 41 | layer { 42 | name: "conv1_h" 43 | type: "Convolution" 44 | bottom: "data_bn" 45 | top: "conv1_h" 46 | param { 47 | lr_mult: 1.0 48 | decay_mult: 1.0 49 | } 50 | param { 51 | lr_mult: 2.0 52 | decay_mult: 1.0 53 | } 54 | convolution_param { 55 | num_output: 32 56 | pad: 3 57 | kernel_size: 7 58 | stride: 2 59 | weight_filler { 60 | type: "msra" 61 | variance_norm: FAN_OUT 62 | } 63 | bias_filler { 64 | type: "constant" 65 | value: 0.0 66 | } 67 | } 68 | } 69 | layer { 70 | name: "conv1_bn_h" 71 | type: "BatchNorm" 72 | bottom: "conv1_h" 73 | top: "conv1_h" 74 | param { 75 | lr_mult: 0.0 76 | } 77 | param { 78 | lr_mult: 0.0 79 | } 80 | param { 81 | lr_mult: 0.0 82 | } 83 | } 84 | layer { 85 | name: "conv1_scale_h" 86 | type: "Scale" 87 | bottom: "conv1_h" 88 | top: "conv1_h" 89 | param { 90 | lr_mult: 1.0 91 | decay_mult: 1.0 92 | } 93 | param { 94 | lr_mult: 2.0 95 | decay_mult: 1.0 96 | } 97 | scale_param { 98 | bias_term: true 99 | } 100 | } 101 | layer { 102 | name: "conv1_relu" 103 | type: "ReLU" 104 | bottom: "conv1_h" 105 | top: "conv1_h" 106 | } 107 | layer { 108 | name: "conv1_pool" 109 | type: "Pooling" 110 | bottom: "conv1_h" 111 | top: "conv1_pool" 112 | pooling_param { 113 | kernel_size: 3 114 | stride: 2 115 | } 116 | } 117 | layer { 118 | name: "layer_64_1_conv1_h" 119 | type: "Convolution" 120 | bottom: "conv1_pool" 121 | top: "layer_64_1_conv1_h" 122 | param { 123 | lr_mult: 1.0 124 | decay_mult: 1.0 125 | } 126 | convolution_param { 127 | num_output: 32 128 | bias_term: false 129 | pad: 1 130 | kernel_size: 3 131 | stride: 1 132 | weight_filler { 133 | type: "msra" 134 | } 135 | bias_filler { 136 | type: "constant" 137 | value: 0.0 138 | } 139 | } 140 | } 141 | layer { 142 | name: "layer_64_1_bn2_h" 143 | type: "BatchNorm" 144 | bottom: "layer_64_1_conv1_h" 145 | top: "layer_64_1_conv1_h" 146 | param { 147 | lr_mult: 0.0 148 | } 149 | param { 150 | lr_mult: 0.0 151 | } 152 | param { 153 | lr_mult: 0.0 154 | } 155 | } 156 | layer { 157 | name: "layer_64_1_scale2_h" 158 | type: "Scale" 159 | bottom: "layer_64_1_conv1_h" 160 | top: "layer_64_1_conv1_h" 161 | param { 162 | lr_mult: 1.0 163 | decay_mult: 1.0 164 | } 165 | param { 166 | lr_mult: 2.0 167 | decay_mult: 1.0 168 | } 169 | scale_param { 170 | bias_term: true 171 | } 172 | } 173 | layer { 174 | name: "layer_64_1_relu2" 175 | type: "ReLU" 176 | bottom: "layer_64_1_conv1_h" 177 | top: "layer_64_1_conv1_h" 178 | } 179 | layer { 180 | name: "layer_64_1_conv2_h" 181 | type: "Convolution" 182 | bottom: "layer_64_1_conv1_h" 183 | top: "layer_64_1_conv2_h" 184 | param { 185 | lr_mult: 1.0 186 | decay_mult: 1.0 187 | } 188 | convolution_param { 189 | num_output: 32 190 | bias_term: false 191 | pad: 1 192 | kernel_size: 3 193 | stride: 1 194 | weight_filler { 195 | type: "msra" 196 | } 197 | bias_filler { 198 | type: "constant" 199 | value: 0.0 200 | } 201 | } 202 | } 203 | layer { 204 | name: "layer_64_1_sum" 205 | type: "Eltwise" 206 | bottom: "layer_64_1_conv2_h" 207 | bottom: "conv1_pool" 208 | top: "layer_64_1_sum" 209 | } 210 | layer { 211 | name: "layer_128_1_bn1_h" 212 | type: "BatchNorm" 213 | bottom: "layer_64_1_sum" 214 | top: "layer_128_1_bn1_h" 215 | param { 216 | lr_mult: 0.0 217 | } 218 | param { 219 | lr_mult: 0.0 220 | } 221 | param { 222 | lr_mult: 0.0 223 | } 224 | } 225 | layer { 226 | name: "layer_128_1_scale1_h" 227 | type: "Scale" 228 | bottom: "layer_128_1_bn1_h" 229 | top: "layer_128_1_bn1_h" 230 | param { 231 | lr_mult: 1.0 232 | decay_mult: 1.0 233 | } 234 | param { 235 | lr_mult: 2.0 236 | decay_mult: 1.0 237 | } 238 | scale_param { 239 | bias_term: true 240 | } 241 | } 242 | layer { 243 | name: "layer_128_1_relu1" 244 | type: "ReLU" 245 | bottom: "layer_128_1_bn1_h" 246 | top: "layer_128_1_bn1_h" 247 | } 248 | layer { 249 | name: "layer_128_1_conv1_h" 250 | type: "Convolution" 251 | bottom: "layer_128_1_bn1_h" 252 | top: "layer_128_1_conv1_h" 253 | param { 254 | lr_mult: 1.0 255 | decay_mult: 1.0 256 | } 257 | convolution_param { 258 | num_output: 128 259 | bias_term: false 260 | pad: 1 261 | kernel_size: 3 262 | stride: 2 263 | weight_filler { 264 | type: "msra" 265 | } 266 | bias_filler { 267 | type: "constant" 268 | value: 0.0 269 | } 270 | } 271 | } 272 | layer { 273 | name: "layer_128_1_bn2" 274 | type: "BatchNorm" 275 | bottom: "layer_128_1_conv1_h" 276 | top: "layer_128_1_conv1_h" 277 | param { 278 | lr_mult: 0.0 279 | } 280 | param { 281 | lr_mult: 0.0 282 | } 283 | param { 284 | lr_mult: 0.0 285 | } 286 | } 287 | layer { 288 | name: "layer_128_1_scale2" 289 | type: "Scale" 290 | bottom: "layer_128_1_conv1_h" 291 | top: "layer_128_1_conv1_h" 292 | param { 293 | lr_mult: 1.0 294 | decay_mult: 1.0 295 | } 296 | param { 297 | lr_mult: 2.0 298 | decay_mult: 1.0 299 | } 300 | scale_param { 301 | bias_term: true 302 | } 303 | } 304 | layer { 305 | name: "layer_128_1_relu2" 306 | type: "ReLU" 307 | bottom: "layer_128_1_conv1_h" 308 | top: "layer_128_1_conv1_h" 309 | } 310 | layer { 311 | name: "layer_128_1_conv2" 312 | type: "Convolution" 313 | bottom: "layer_128_1_conv1_h" 314 | top: "layer_128_1_conv2" 315 | param { 316 | lr_mult: 1.0 317 | decay_mult: 1.0 318 | } 319 | convolution_param { 320 | num_output: 128 321 | bias_term: false 322 | pad: 1 323 | kernel_size: 3 324 | stride: 1 325 | weight_filler { 326 | type: "msra" 327 | } 328 | bias_filler { 329 | type: "constant" 330 | value: 0.0 331 | } 332 | } 333 | } 334 | layer { 335 | name: "layer_128_1_conv_expand_h" 336 | type: "Convolution" 337 | bottom: "layer_128_1_bn1_h" 338 | top: "layer_128_1_conv_expand_h" 339 | param { 340 | lr_mult: 1.0 341 | decay_mult: 1.0 342 | } 343 | convolution_param { 344 | num_output: 128 345 | bias_term: false 346 | pad: 0 347 | kernel_size: 1 348 | stride: 2 349 | weight_filler { 350 | type: "msra" 351 | } 352 | bias_filler { 353 | type: "constant" 354 | value: 0.0 355 | } 356 | } 357 | } 358 | layer { 359 | name: "layer_128_1_sum" 360 | type: "Eltwise" 361 | bottom: "layer_128_1_conv2" 362 | bottom: "layer_128_1_conv_expand_h" 363 | top: "layer_128_1_sum" 364 | } 365 | layer { 366 | name: "layer_256_1_bn1" 367 | type: "BatchNorm" 368 | bottom: "layer_128_1_sum" 369 | top: "layer_256_1_bn1" 370 | param { 371 | lr_mult: 0.0 372 | } 373 | param { 374 | lr_mult: 0.0 375 | } 376 | param { 377 | lr_mult: 0.0 378 | } 379 | } 380 | layer { 381 | name: "layer_256_1_scale1" 382 | type: "Scale" 383 | bottom: "layer_256_1_bn1" 384 | top: "layer_256_1_bn1" 385 | param { 386 | lr_mult: 1.0 387 | decay_mult: 1.0 388 | } 389 | param { 390 | lr_mult: 2.0 391 | decay_mult: 1.0 392 | } 393 | scale_param { 394 | bias_term: true 395 | } 396 | } 397 | layer { 398 | name: "layer_256_1_relu1" 399 | type: "ReLU" 400 | bottom: "layer_256_1_bn1" 401 | top: "layer_256_1_bn1" 402 | } 403 | layer { 404 | name: "layer_256_1_conv1" 405 | type: "Convolution" 406 | bottom: "layer_256_1_bn1" 407 | top: "layer_256_1_conv1" 408 | param { 409 | lr_mult: 1.0 410 | decay_mult: 1.0 411 | } 412 | convolution_param { 413 | num_output: 256 414 | bias_term: false 415 | pad: 1 416 | kernel_size: 3 417 | stride: 2 418 | weight_filler { 419 | type: "msra" 420 | } 421 | bias_filler { 422 | type: "constant" 423 | value: 0.0 424 | } 425 | } 426 | } 427 | layer { 428 | name: "layer_256_1_bn2" 429 | type: "BatchNorm" 430 | bottom: "layer_256_1_conv1" 431 | top: "layer_256_1_conv1" 432 | param { 433 | lr_mult: 0.0 434 | } 435 | param { 436 | lr_mult: 0.0 437 | } 438 | param { 439 | lr_mult: 0.0 440 | } 441 | } 442 | layer { 443 | name: "layer_256_1_scale2" 444 | type: "Scale" 445 | bottom: "layer_256_1_conv1" 446 | top: "layer_256_1_conv1" 447 | param { 448 | lr_mult: 1.0 449 | decay_mult: 1.0 450 | } 451 | param { 452 | lr_mult: 2.0 453 | decay_mult: 1.0 454 | } 455 | scale_param { 456 | bias_term: true 457 | } 458 | } 459 | layer { 460 | name: "layer_256_1_relu2" 461 | type: "ReLU" 462 | bottom: "layer_256_1_conv1" 463 | top: "layer_256_1_conv1" 464 | } 465 | layer { 466 | name: "layer_256_1_conv2" 467 | type: "Convolution" 468 | bottom: "layer_256_1_conv1" 469 | top: "layer_256_1_conv2" 470 | param { 471 | lr_mult: 1.0 472 | decay_mult: 1.0 473 | } 474 | convolution_param { 475 | num_output: 256 476 | bias_term: false 477 | pad: 1 478 | kernel_size: 3 479 | stride: 1 480 | weight_filler { 481 | type: "msra" 482 | } 483 | bias_filler { 484 | type: "constant" 485 | value: 0.0 486 | } 487 | } 488 | } 489 | layer { 490 | name: "layer_256_1_conv_expand" 491 | type: "Convolution" 492 | bottom: "layer_256_1_bn1" 493 | top: "layer_256_1_conv_expand" 494 | param { 495 | lr_mult: 1.0 496 | decay_mult: 1.0 497 | } 498 | convolution_param { 499 | num_output: 256 500 | bias_term: false 501 | pad: 0 502 | kernel_size: 1 503 | stride: 2 504 | weight_filler { 505 | type: "msra" 506 | } 507 | bias_filler { 508 | type: "constant" 509 | value: 0.0 510 | } 511 | } 512 | } 513 | layer { 514 | name: "layer_256_1_sum" 515 | type: "Eltwise" 516 | bottom: "layer_256_1_conv2" 517 | bottom: "layer_256_1_conv_expand" 518 | top: "layer_256_1_sum" 519 | } 520 | layer { 521 | name: "layer_512_1_bn1" 522 | type: "BatchNorm" 523 | bottom: "layer_256_1_sum" 524 | top: "layer_512_1_bn1" 525 | param { 526 | lr_mult: 0.0 527 | } 528 | param { 529 | lr_mult: 0.0 530 | } 531 | param { 532 | lr_mult: 0.0 533 | } 534 | } 535 | layer { 536 | name: "layer_512_1_scale1" 537 | type: "Scale" 538 | bottom: "layer_512_1_bn1" 539 | top: "layer_512_1_bn1" 540 | param { 541 | lr_mult: 1.0 542 | decay_mult: 1.0 543 | } 544 | param { 545 | lr_mult: 2.0 546 | decay_mult: 1.0 547 | } 548 | scale_param { 549 | bias_term: true 550 | } 551 | } 552 | layer { 553 | name: "layer_512_1_relu1" 554 | type: "ReLU" 555 | bottom: "layer_512_1_bn1" 556 | top: "layer_512_1_bn1" 557 | } 558 | layer { 559 | name: "layer_512_1_conv1_h" 560 | type: "Convolution" 561 | bottom: "layer_512_1_bn1" 562 | top: "layer_512_1_conv1_h" 563 | param { 564 | lr_mult: 1.0 565 | decay_mult: 1.0 566 | } 567 | convolution_param { 568 | num_output: 128 569 | bias_term: false 570 | pad: 1 571 | kernel_size: 3 572 | stride: 1 # 2 573 | weight_filler { 574 | type: "msra" 575 | } 576 | bias_filler { 577 | type: "constant" 578 | value: 0.0 579 | } 580 | } 581 | } 582 | layer { 583 | name: "layer_512_1_bn2_h" 584 | type: "BatchNorm" 585 | bottom: "layer_512_1_conv1_h" 586 | top: "layer_512_1_conv1_h" 587 | param { 588 | lr_mult: 0.0 589 | } 590 | param { 591 | lr_mult: 0.0 592 | } 593 | param { 594 | lr_mult: 0.0 595 | } 596 | } 597 | layer { 598 | name: "layer_512_1_scale2_h" 599 | type: "Scale" 600 | bottom: "layer_512_1_conv1_h" 601 | top: "layer_512_1_conv1_h" 602 | param { 603 | lr_mult: 1.0 604 | decay_mult: 1.0 605 | } 606 | param { 607 | lr_mult: 2.0 608 | decay_mult: 1.0 609 | } 610 | scale_param { 611 | bias_term: true 612 | } 613 | } 614 | layer { 615 | name: "layer_512_1_relu2" 616 | type: "ReLU" 617 | bottom: "layer_512_1_conv1_h" 618 | top: "layer_512_1_conv1_h" 619 | } 620 | layer { 621 | name: "layer_512_1_conv2_h" 622 | type: "Convolution" 623 | bottom: "layer_512_1_conv1_h" 624 | top: "layer_512_1_conv2_h" 625 | param { 626 | lr_mult: 1.0 627 | decay_mult: 1.0 628 | } 629 | convolution_param { 630 | num_output: 256 631 | bias_term: false 632 | pad: 2 # 1 633 | kernel_size: 3 634 | stride: 1 635 | dilation: 2 636 | weight_filler { 637 | type: "msra" 638 | } 639 | bias_filler { 640 | type: "constant" 641 | value: 0.0 642 | } 643 | } 644 | } 645 | layer { 646 | name: "layer_512_1_conv_expand_h" 647 | type: "Convolution" 648 | bottom: "layer_512_1_bn1" 649 | top: "layer_512_1_conv_expand_h" 650 | param { 651 | lr_mult: 1.0 652 | decay_mult: 1.0 653 | } 654 | convolution_param { 655 | num_output: 256 656 | bias_term: false 657 | pad: 0 658 | kernel_size: 1 659 | stride: 1 # 2 660 | weight_filler { 661 | type: "msra" 662 | } 663 | bias_filler { 664 | type: "constant" 665 | value: 0.0 666 | } 667 | } 668 | } 669 | layer { 670 | name: "layer_512_1_sum" 671 | type: "Eltwise" 672 | bottom: "layer_512_1_conv2_h" 673 | bottom: "layer_512_1_conv_expand_h" 674 | top: "layer_512_1_sum" 675 | } 676 | layer { 677 | name: "last_bn_h" 678 | type: "BatchNorm" 679 | bottom: "layer_512_1_sum" 680 | top: "layer_512_1_sum" 681 | param { 682 | lr_mult: 0.0 683 | } 684 | param { 685 | lr_mult: 0.0 686 | } 687 | param { 688 | lr_mult: 0.0 689 | } 690 | } 691 | layer { 692 | name: "last_scale_h" 693 | type: "Scale" 694 | bottom: "layer_512_1_sum" 695 | top: "layer_512_1_sum" 696 | param { 697 | lr_mult: 1.0 698 | decay_mult: 1.0 699 | } 700 | param { 701 | lr_mult: 2.0 702 | decay_mult: 1.0 703 | } 704 | scale_param { 705 | bias_term: true 706 | } 707 | } 708 | layer { 709 | name: "last_relu" 710 | type: "ReLU" 711 | bottom: "layer_512_1_sum" 712 | top: "fc7" 713 | } 714 | 715 | layer { 716 | name: "conv6_1_h" 717 | type: "Convolution" 718 | bottom: "fc7" 719 | top: "conv6_1_h" 720 | param { 721 | lr_mult: 1 722 | decay_mult: 1 723 | } 724 | param { 725 | lr_mult: 2 726 | decay_mult: 0 727 | } 728 | convolution_param { 729 | num_output: 128 730 | pad: 0 731 | kernel_size: 1 732 | stride: 1 733 | weight_filler { 734 | type: "xavier" 735 | } 736 | bias_filler { 737 | type: "constant" 738 | value: 0 739 | } 740 | } 741 | } 742 | layer { 743 | name: "conv6_1_relu" 744 | type: "ReLU" 745 | bottom: "conv6_1_h" 746 | top: "conv6_1_h" 747 | } 748 | layer { 749 | name: "conv6_2_h" 750 | type: "Convolution" 751 | bottom: "conv6_1_h" 752 | top: "conv6_2_h" 753 | param { 754 | lr_mult: 1 755 | decay_mult: 1 756 | } 757 | param { 758 | lr_mult: 2 759 | decay_mult: 0 760 | } 761 | convolution_param { 762 | num_output: 256 763 | pad: 1 764 | kernel_size: 3 765 | stride: 2 766 | weight_filler { 767 | type: "xavier" 768 | } 769 | bias_filler { 770 | type: "constant" 771 | value: 0 772 | } 773 | } 774 | } 775 | layer { 776 | name: "conv6_2_relu" 777 | type: "ReLU" 778 | bottom: "conv6_2_h" 779 | top: "conv6_2_h" 780 | } 781 | layer { 782 | name: "conv7_1_h" 783 | type: "Convolution" 784 | bottom: "conv6_2_h" 785 | top: "conv7_1_h" 786 | param { 787 | lr_mult: 1 788 | decay_mult: 1 789 | } 790 | param { 791 | lr_mult: 2 792 | decay_mult: 0 793 | } 794 | convolution_param { 795 | num_output: 64 796 | pad: 0 797 | kernel_size: 1 798 | stride: 1 799 | weight_filler { 800 | type: "xavier" 801 | } 802 | bias_filler { 803 | type: "constant" 804 | value: 0 805 | } 806 | } 807 | } 808 | layer { 809 | name: "conv7_1_relu" 810 | type: "ReLU" 811 | bottom: "conv7_1_h" 812 | top: "conv7_1_h" 813 | } 814 | layer { 815 | name: "conv7_2_h" 816 | type: "Convolution" 817 | bottom: "conv7_1_h" 818 | top: "conv7_2_h" 819 | param { 820 | lr_mult: 1 821 | decay_mult: 1 822 | } 823 | param { 824 | lr_mult: 2 825 | decay_mult: 0 826 | } 827 | convolution_param { 828 | num_output: 128 829 | pad: 1 830 | kernel_size: 3 831 | stride: 2 832 | weight_filler { 833 | type: "xavier" 834 | } 835 | bias_filler { 836 | type: "constant" 837 | value: 0 838 | } 839 | } 840 | } 841 | layer { 842 | name: "conv7_2_relu" 843 | type: "ReLU" 844 | bottom: "conv7_2_h" 845 | top: "conv7_2_h" 846 | } 847 | layer { 848 | name: "conv8_1_h" 849 | type: "Convolution" 850 | bottom: "conv7_2_h" 851 | top: "conv8_1_h" 852 | param { 853 | lr_mult: 1 854 | decay_mult: 1 855 | } 856 | param { 857 | lr_mult: 2 858 | decay_mult: 0 859 | } 860 | convolution_param { 861 | num_output: 64 862 | pad: 0 863 | kernel_size: 1 864 | stride: 1 865 | weight_filler { 866 | type: "xavier" 867 | } 868 | bias_filler { 869 | type: "constant" 870 | value: 0 871 | } 872 | } 873 | } 874 | layer { 875 | name: "conv8_1_relu" 876 | type: "ReLU" 877 | bottom: "conv8_1_h" 878 | top: "conv8_1_h" 879 | } 880 | layer { 881 | name: "conv8_2_h" 882 | type: "Convolution" 883 | bottom: "conv8_1_h" 884 | top: "conv8_2_h" 885 | param { 886 | lr_mult: 1 887 | decay_mult: 1 888 | } 889 | param { 890 | lr_mult: 2 891 | decay_mult: 0 892 | } 893 | convolution_param { 894 | num_output: 128 895 | pad: 1 896 | kernel_size: 3 897 | stride: 1 898 | weight_filler { 899 | type: "xavier" 900 | } 901 | bias_filler { 902 | type: "constant" 903 | value: 0 904 | } 905 | } 906 | } 907 | layer { 908 | name: "conv8_2_relu" 909 | type: "ReLU" 910 | bottom: "conv8_2_h" 911 | top: "conv8_2_h" 912 | } 913 | layer { 914 | name: "conv9_1_h" 915 | type: "Convolution" 916 | bottom: "conv8_2_h" 917 | top: "conv9_1_h" 918 | param { 919 | lr_mult: 1 920 | decay_mult: 1 921 | } 922 | param { 923 | lr_mult: 2 924 | decay_mult: 0 925 | } 926 | convolution_param { 927 | num_output: 64 928 | pad: 0 929 | kernel_size: 1 930 | stride: 1 931 | weight_filler { 932 | type: "xavier" 933 | } 934 | bias_filler { 935 | type: "constant" 936 | value: 0 937 | } 938 | } 939 | } 940 | layer { 941 | name: "conv9_1_relu" 942 | type: "ReLU" 943 | bottom: "conv9_1_h" 944 | top: "conv9_1_h" 945 | } 946 | layer { 947 | name: "conv9_2_h" 948 | type: "Convolution" 949 | bottom: "conv9_1_h" 950 | top: "conv9_2_h" 951 | param { 952 | lr_mult: 1 953 | decay_mult: 1 954 | } 955 | param { 956 | lr_mult: 2 957 | decay_mult: 0 958 | } 959 | convolution_param { 960 | num_output: 128 961 | pad: 1 962 | kernel_size: 3 963 | stride: 1 964 | weight_filler { 965 | type: "xavier" 966 | } 967 | bias_filler { 968 | type: "constant" 969 | value: 0 970 | } 971 | } 972 | } 973 | layer { 974 | name: "conv9_2_relu" 975 | type: "ReLU" 976 | bottom: "conv9_2_h" 977 | top: "conv9_2_h" 978 | } 979 | layer { 980 | name: "conv4_3_norm" 981 | type: "Normalize" 982 | bottom: "layer_256_1_bn1" 983 | top: "conv4_3_norm" 984 | norm_param { 985 | across_spatial: false 986 | scale_filler { 987 | type: "constant" 988 | value: 20 989 | } 990 | channel_shared: false 991 | } 992 | } 993 | layer { 994 | name: "conv4_3_norm_mbox_loc" 995 | type: "Convolution" 996 | bottom: "conv4_3_norm" 997 | top: "conv4_3_norm_mbox_loc" 998 | param { 999 | lr_mult: 1 1000 | decay_mult: 1 1001 | } 1002 | param { 1003 | lr_mult: 2 1004 | decay_mult: 0 1005 | } 1006 | convolution_param { 1007 | num_output: 16 1008 | pad: 1 1009 | kernel_size: 3 1010 | stride: 1 1011 | weight_filler { 1012 | type: "xavier" 1013 | } 1014 | bias_filler { 1015 | type: "constant" 1016 | value: 0 1017 | } 1018 | } 1019 | } 1020 | layer { 1021 | name: "conv4_3_norm_mbox_loc_perm" 1022 | type: "Permute" 1023 | bottom: "conv4_3_norm_mbox_loc" 1024 | top: "conv4_3_norm_mbox_loc_perm" 1025 | permute_param { 1026 | order: 0 1027 | order: 2 1028 | order: 3 1029 | order: 1 1030 | } 1031 | } 1032 | layer { 1033 | name: "conv4_3_norm_mbox_loc_flat" 1034 | type: "Flatten" 1035 | bottom: "conv4_3_norm_mbox_loc_perm" 1036 | top: "conv4_3_norm_mbox_loc_flat" 1037 | flatten_param { 1038 | axis: 1 1039 | } 1040 | } 1041 | layer { 1042 | name: "conv4_3_norm_mbox_conf" 1043 | type: "Convolution" 1044 | bottom: "conv4_3_norm" 1045 | top: "conv4_3_norm_mbox_conf" 1046 | param { 1047 | lr_mult: 1 1048 | decay_mult: 1 1049 | } 1050 | param { 1051 | lr_mult: 2 1052 | decay_mult: 0 1053 | } 1054 | convolution_param { 1055 | num_output: 8 # 84 1056 | pad: 1 1057 | kernel_size: 3 1058 | stride: 1 1059 | weight_filler { 1060 | type: "xavier" 1061 | } 1062 | bias_filler { 1063 | type: "constant" 1064 | value: 0 1065 | } 1066 | } 1067 | } 1068 | layer { 1069 | name: "conv4_3_norm_mbox_conf_perm" 1070 | type: "Permute" 1071 | bottom: "conv4_3_norm_mbox_conf" 1072 | top: "conv4_3_norm_mbox_conf_perm" 1073 | permute_param { 1074 | order: 0 1075 | order: 2 1076 | order: 3 1077 | order: 1 1078 | } 1079 | } 1080 | layer { 1081 | name: "conv4_3_norm_mbox_conf_flat" 1082 | type: "Flatten" 1083 | bottom: "conv4_3_norm_mbox_conf_perm" 1084 | top: "conv4_3_norm_mbox_conf_flat" 1085 | flatten_param { 1086 | axis: 1 1087 | } 1088 | } 1089 | layer { 1090 | name: "conv4_3_norm_mbox_priorbox" 1091 | type: "PriorBox" 1092 | bottom: "conv4_3_norm" 1093 | bottom: "data" 1094 | top: "conv4_3_norm_mbox_priorbox" 1095 | prior_box_param { 1096 | min_size: 30.0 1097 | max_size: 60.0 1098 | aspect_ratio: 2 1099 | flip: true 1100 | clip: false 1101 | variance: 0.1 1102 | variance: 0.1 1103 | variance: 0.2 1104 | variance: 0.2 1105 | step: 8 1106 | offset: 0.5 1107 | } 1108 | } 1109 | layer { 1110 | name: "fc7_mbox_loc" 1111 | type: "Convolution" 1112 | bottom: "fc7" 1113 | top: "fc7_mbox_loc" 1114 | param { 1115 | lr_mult: 1 1116 | decay_mult: 1 1117 | } 1118 | param { 1119 | lr_mult: 2 1120 | decay_mult: 0 1121 | } 1122 | convolution_param { 1123 | num_output: 24 1124 | pad: 1 1125 | kernel_size: 3 1126 | stride: 1 1127 | weight_filler { 1128 | type: "xavier" 1129 | } 1130 | bias_filler { 1131 | type: "constant" 1132 | value: 0 1133 | } 1134 | } 1135 | } 1136 | layer { 1137 | name: "fc7_mbox_loc_perm" 1138 | type: "Permute" 1139 | bottom: "fc7_mbox_loc" 1140 | top: "fc7_mbox_loc_perm" 1141 | permute_param { 1142 | order: 0 1143 | order: 2 1144 | order: 3 1145 | order: 1 1146 | } 1147 | } 1148 | layer { 1149 | name: "fc7_mbox_loc_flat" 1150 | type: "Flatten" 1151 | bottom: "fc7_mbox_loc_perm" 1152 | top: "fc7_mbox_loc_flat" 1153 | flatten_param { 1154 | axis: 1 1155 | } 1156 | } 1157 | layer { 1158 | name: "fc7_mbox_conf" 1159 | type: "Convolution" 1160 | bottom: "fc7" 1161 | top: "fc7_mbox_conf" 1162 | param { 1163 | lr_mult: 1 1164 | decay_mult: 1 1165 | } 1166 | param { 1167 | lr_mult: 2 1168 | decay_mult: 0 1169 | } 1170 | convolution_param { 1171 | num_output: 12 # 126 1172 | pad: 1 1173 | kernel_size: 3 1174 | stride: 1 1175 | weight_filler { 1176 | type: "xavier" 1177 | } 1178 | bias_filler { 1179 | type: "constant" 1180 | value: 0 1181 | } 1182 | } 1183 | } 1184 | layer { 1185 | name: "fc7_mbox_conf_perm" 1186 | type: "Permute" 1187 | bottom: "fc7_mbox_conf" 1188 | top: "fc7_mbox_conf_perm" 1189 | permute_param { 1190 | order: 0 1191 | order: 2 1192 | order: 3 1193 | order: 1 1194 | } 1195 | } 1196 | layer { 1197 | name: "fc7_mbox_conf_flat" 1198 | type: "Flatten" 1199 | bottom: "fc7_mbox_conf_perm" 1200 | top: "fc7_mbox_conf_flat" 1201 | flatten_param { 1202 | axis: 1 1203 | } 1204 | } 1205 | layer { 1206 | name: "fc7_mbox_priorbox" 1207 | type: "PriorBox" 1208 | bottom: "fc7" 1209 | bottom: "data" 1210 | top: "fc7_mbox_priorbox" 1211 | prior_box_param { 1212 | min_size: 60.0 1213 | max_size: 111.0 1214 | aspect_ratio: 2 1215 | aspect_ratio: 3 1216 | flip: true 1217 | clip: false 1218 | variance: 0.1 1219 | variance: 0.1 1220 | variance: 0.2 1221 | variance: 0.2 1222 | step: 16 1223 | offset: 0.5 1224 | } 1225 | } 1226 | layer { 1227 | name: "conv6_2_mbox_loc" 1228 | type: "Convolution" 1229 | bottom: "conv6_2_h" 1230 | top: "conv6_2_mbox_loc" 1231 | param { 1232 | lr_mult: 1 1233 | decay_mult: 1 1234 | } 1235 | param { 1236 | lr_mult: 2 1237 | decay_mult: 0 1238 | } 1239 | convolution_param { 1240 | num_output: 24 1241 | pad: 1 1242 | kernel_size: 3 1243 | stride: 1 1244 | weight_filler { 1245 | type: "xavier" 1246 | } 1247 | bias_filler { 1248 | type: "constant" 1249 | value: 0 1250 | } 1251 | } 1252 | } 1253 | layer { 1254 | name: "conv6_2_mbox_loc_perm" 1255 | type: "Permute" 1256 | bottom: "conv6_2_mbox_loc" 1257 | top: "conv6_2_mbox_loc_perm" 1258 | permute_param { 1259 | order: 0 1260 | order: 2 1261 | order: 3 1262 | order: 1 1263 | } 1264 | } 1265 | layer { 1266 | name: "conv6_2_mbox_loc_flat" 1267 | type: "Flatten" 1268 | bottom: "conv6_2_mbox_loc_perm" 1269 | top: "conv6_2_mbox_loc_flat" 1270 | flatten_param { 1271 | axis: 1 1272 | } 1273 | } 1274 | layer { 1275 | name: "conv6_2_mbox_conf" 1276 | type: "Convolution" 1277 | bottom: "conv6_2_h" 1278 | top: "conv6_2_mbox_conf" 1279 | param { 1280 | lr_mult: 1 1281 | decay_mult: 1 1282 | } 1283 | param { 1284 | lr_mult: 2 1285 | decay_mult: 0 1286 | } 1287 | convolution_param { 1288 | num_output: 12 # 126 1289 | pad: 1 1290 | kernel_size: 3 1291 | stride: 1 1292 | weight_filler { 1293 | type: "xavier" 1294 | } 1295 | bias_filler { 1296 | type: "constant" 1297 | value: 0 1298 | } 1299 | } 1300 | } 1301 | layer { 1302 | name: "conv6_2_mbox_conf_perm" 1303 | type: "Permute" 1304 | bottom: "conv6_2_mbox_conf" 1305 | top: "conv6_2_mbox_conf_perm" 1306 | permute_param { 1307 | order: 0 1308 | order: 2 1309 | order: 3 1310 | order: 1 1311 | } 1312 | } 1313 | layer { 1314 | name: "conv6_2_mbox_conf_flat" 1315 | type: "Flatten" 1316 | bottom: "conv6_2_mbox_conf_perm" 1317 | top: "conv6_2_mbox_conf_flat" 1318 | flatten_param { 1319 | axis: 1 1320 | } 1321 | } 1322 | layer { 1323 | name: "conv6_2_mbox_priorbox" 1324 | type: "PriorBox" 1325 | bottom: "conv6_2_h" 1326 | bottom: "data" 1327 | top: "conv6_2_mbox_priorbox" 1328 | prior_box_param { 1329 | min_size: 111.0 1330 | max_size: 162.0 1331 | aspect_ratio: 2 1332 | aspect_ratio: 3 1333 | flip: true 1334 | clip: false 1335 | variance: 0.1 1336 | variance: 0.1 1337 | variance: 0.2 1338 | variance: 0.2 1339 | step: 32 1340 | offset: 0.5 1341 | } 1342 | } 1343 | layer { 1344 | name: "conv7_2_mbox_loc" 1345 | type: "Convolution" 1346 | bottom: "conv7_2_h" 1347 | top: "conv7_2_mbox_loc" 1348 | param { 1349 | lr_mult: 1 1350 | decay_mult: 1 1351 | } 1352 | param { 1353 | lr_mult: 2 1354 | decay_mult: 0 1355 | } 1356 | convolution_param { 1357 | num_output: 24 1358 | pad: 1 1359 | kernel_size: 3 1360 | stride: 1 1361 | weight_filler { 1362 | type: "xavier" 1363 | } 1364 | bias_filler { 1365 | type: "constant" 1366 | value: 0 1367 | } 1368 | } 1369 | } 1370 | layer { 1371 | name: "conv7_2_mbox_loc_perm" 1372 | type: "Permute" 1373 | bottom: "conv7_2_mbox_loc" 1374 | top: "conv7_2_mbox_loc_perm" 1375 | permute_param { 1376 | order: 0 1377 | order: 2 1378 | order: 3 1379 | order: 1 1380 | } 1381 | } 1382 | layer { 1383 | name: "conv7_2_mbox_loc_flat" 1384 | type: "Flatten" 1385 | bottom: "conv7_2_mbox_loc_perm" 1386 | top: "conv7_2_mbox_loc_flat" 1387 | flatten_param { 1388 | axis: 1 1389 | } 1390 | } 1391 | layer { 1392 | name: "conv7_2_mbox_conf" 1393 | type: "Convolution" 1394 | bottom: "conv7_2_h" 1395 | top: "conv7_2_mbox_conf" 1396 | param { 1397 | lr_mult: 1 1398 | decay_mult: 1 1399 | } 1400 | param { 1401 | lr_mult: 2 1402 | decay_mult: 0 1403 | } 1404 | convolution_param { 1405 | num_output: 12 # 126 1406 | pad: 1 1407 | kernel_size: 3 1408 | stride: 1 1409 | weight_filler { 1410 | type: "xavier" 1411 | } 1412 | bias_filler { 1413 | type: "constant" 1414 | value: 0 1415 | } 1416 | } 1417 | } 1418 | layer { 1419 | name: "conv7_2_mbox_conf_perm" 1420 | type: "Permute" 1421 | bottom: "conv7_2_mbox_conf" 1422 | top: "conv7_2_mbox_conf_perm" 1423 | permute_param { 1424 | order: 0 1425 | order: 2 1426 | order: 3 1427 | order: 1 1428 | } 1429 | } 1430 | layer { 1431 | name: "conv7_2_mbox_conf_flat" 1432 | type: "Flatten" 1433 | bottom: "conv7_2_mbox_conf_perm" 1434 | top: "conv7_2_mbox_conf_flat" 1435 | flatten_param { 1436 | axis: 1 1437 | } 1438 | } 1439 | layer { 1440 | name: "conv7_2_mbox_priorbox" 1441 | type: "PriorBox" 1442 | bottom: "conv7_2_h" 1443 | bottom: "data" 1444 | top: "conv7_2_mbox_priorbox" 1445 | prior_box_param { 1446 | min_size: 162.0 1447 | max_size: 213.0 1448 | aspect_ratio: 2 1449 | aspect_ratio: 3 1450 | flip: true 1451 | clip: false 1452 | variance: 0.1 1453 | variance: 0.1 1454 | variance: 0.2 1455 | variance: 0.2 1456 | step: 64 1457 | offset: 0.5 1458 | } 1459 | } 1460 | layer { 1461 | name: "conv8_2_mbox_loc" 1462 | type: "Convolution" 1463 | bottom: "conv8_2_h" 1464 | top: "conv8_2_mbox_loc" 1465 | param { 1466 | lr_mult: 1 1467 | decay_mult: 1 1468 | } 1469 | param { 1470 | lr_mult: 2 1471 | decay_mult: 0 1472 | } 1473 | convolution_param { 1474 | num_output: 16 1475 | pad: 1 1476 | kernel_size: 3 1477 | stride: 1 1478 | weight_filler { 1479 | type: "xavier" 1480 | } 1481 | bias_filler { 1482 | type: "constant" 1483 | value: 0 1484 | } 1485 | } 1486 | } 1487 | layer { 1488 | name: "conv8_2_mbox_loc_perm" 1489 | type: "Permute" 1490 | bottom: "conv8_2_mbox_loc" 1491 | top: "conv8_2_mbox_loc_perm" 1492 | permute_param { 1493 | order: 0 1494 | order: 2 1495 | order: 3 1496 | order: 1 1497 | } 1498 | } 1499 | layer { 1500 | name: "conv8_2_mbox_loc_flat" 1501 | type: "Flatten" 1502 | bottom: "conv8_2_mbox_loc_perm" 1503 | top: "conv8_2_mbox_loc_flat" 1504 | flatten_param { 1505 | axis: 1 1506 | } 1507 | } 1508 | layer { 1509 | name: "conv8_2_mbox_conf" 1510 | type: "Convolution" 1511 | bottom: "conv8_2_h" 1512 | top: "conv8_2_mbox_conf" 1513 | param { 1514 | lr_mult: 1 1515 | decay_mult: 1 1516 | } 1517 | param { 1518 | lr_mult: 2 1519 | decay_mult: 0 1520 | } 1521 | convolution_param { 1522 | num_output: 8 # 84 1523 | pad: 1 1524 | kernel_size: 3 1525 | stride: 1 1526 | weight_filler { 1527 | type: "xavier" 1528 | } 1529 | bias_filler { 1530 | type: "constant" 1531 | value: 0 1532 | } 1533 | } 1534 | } 1535 | layer { 1536 | name: "conv8_2_mbox_conf_perm" 1537 | type: "Permute" 1538 | bottom: "conv8_2_mbox_conf" 1539 | top: "conv8_2_mbox_conf_perm" 1540 | permute_param { 1541 | order: 0 1542 | order: 2 1543 | order: 3 1544 | order: 1 1545 | } 1546 | } 1547 | layer { 1548 | name: "conv8_2_mbox_conf_flat" 1549 | type: "Flatten" 1550 | bottom: "conv8_2_mbox_conf_perm" 1551 | top: "conv8_2_mbox_conf_flat" 1552 | flatten_param { 1553 | axis: 1 1554 | } 1555 | } 1556 | layer { 1557 | name: "conv8_2_mbox_priorbox" 1558 | type: "PriorBox" 1559 | bottom: "conv8_2_h" 1560 | bottom: "data" 1561 | top: "conv8_2_mbox_priorbox" 1562 | prior_box_param { 1563 | min_size: 213.0 1564 | max_size: 264.0 1565 | aspect_ratio: 2 1566 | flip: true 1567 | clip: false 1568 | variance: 0.1 1569 | variance: 0.1 1570 | variance: 0.2 1571 | variance: 0.2 1572 | step: 100 1573 | offset: 0.5 1574 | } 1575 | } 1576 | layer { 1577 | name: "conv9_2_mbox_loc" 1578 | type: "Convolution" 1579 | bottom: "conv9_2_h" 1580 | top: "conv9_2_mbox_loc" 1581 | param { 1582 | lr_mult: 1 1583 | decay_mult: 1 1584 | } 1585 | param { 1586 | lr_mult: 2 1587 | decay_mult: 0 1588 | } 1589 | convolution_param { 1590 | num_output: 16 1591 | pad: 1 1592 | kernel_size: 3 1593 | stride: 1 1594 | weight_filler { 1595 | type: "xavier" 1596 | } 1597 | bias_filler { 1598 | type: "constant" 1599 | value: 0 1600 | } 1601 | } 1602 | } 1603 | layer { 1604 | name: "conv9_2_mbox_loc_perm" 1605 | type: "Permute" 1606 | bottom: "conv9_2_mbox_loc" 1607 | top: "conv9_2_mbox_loc_perm" 1608 | permute_param { 1609 | order: 0 1610 | order: 2 1611 | order: 3 1612 | order: 1 1613 | } 1614 | } 1615 | layer { 1616 | name: "conv9_2_mbox_loc_flat" 1617 | type: "Flatten" 1618 | bottom: "conv9_2_mbox_loc_perm" 1619 | top: "conv9_2_mbox_loc_flat" 1620 | flatten_param { 1621 | axis: 1 1622 | } 1623 | } 1624 | layer { 1625 | name: "conv9_2_mbox_conf" 1626 | type: "Convolution" 1627 | bottom: "conv9_2_h" 1628 | top: "conv9_2_mbox_conf" 1629 | param { 1630 | lr_mult: 1 1631 | decay_mult: 1 1632 | } 1633 | param { 1634 | lr_mult: 2 1635 | decay_mult: 0 1636 | } 1637 | convolution_param { 1638 | num_output: 8 # 84 1639 | pad: 1 1640 | kernel_size: 3 1641 | stride: 1 1642 | weight_filler { 1643 | type: "xavier" 1644 | } 1645 | bias_filler { 1646 | type: "constant" 1647 | value: 0 1648 | } 1649 | } 1650 | } 1651 | layer { 1652 | name: "conv9_2_mbox_conf_perm" 1653 | type: "Permute" 1654 | bottom: "conv9_2_mbox_conf" 1655 | top: "conv9_2_mbox_conf_perm" 1656 | permute_param { 1657 | order: 0 1658 | order: 2 1659 | order: 3 1660 | order: 1 1661 | } 1662 | } 1663 | layer { 1664 | name: "conv9_2_mbox_conf_flat" 1665 | type: "Flatten" 1666 | bottom: "conv9_2_mbox_conf_perm" 1667 | top: "conv9_2_mbox_conf_flat" 1668 | flatten_param { 1669 | axis: 1 1670 | } 1671 | } 1672 | layer { 1673 | name: "conv9_2_mbox_priorbox" 1674 | type: "PriorBox" 1675 | bottom: "conv9_2_h" 1676 | bottom: "data" 1677 | top: "conv9_2_mbox_priorbox" 1678 | prior_box_param { 1679 | min_size: 264.0 1680 | max_size: 315.0 1681 | aspect_ratio: 2 1682 | flip: true 1683 | clip: false 1684 | variance: 0.1 1685 | variance: 0.1 1686 | variance: 0.2 1687 | variance: 0.2 1688 | step: 300 1689 | offset: 0.5 1690 | } 1691 | } 1692 | layer { 1693 | name: "mbox_loc" 1694 | type: "Concat" 1695 | bottom: "conv4_3_norm_mbox_loc_flat" 1696 | bottom: "fc7_mbox_loc_flat" 1697 | bottom: "conv6_2_mbox_loc_flat" 1698 | bottom: "conv7_2_mbox_loc_flat" 1699 | bottom: "conv8_2_mbox_loc_flat" 1700 | bottom: "conv9_2_mbox_loc_flat" 1701 | top: "mbox_loc" 1702 | concat_param { 1703 | axis: 1 1704 | } 1705 | } 1706 | layer { 1707 | name: "mbox_conf" 1708 | type: "Concat" 1709 | bottom: "conv4_3_norm_mbox_conf_flat" 1710 | bottom: "fc7_mbox_conf_flat" 1711 | bottom: "conv6_2_mbox_conf_flat" 1712 | bottom: "conv7_2_mbox_conf_flat" 1713 | bottom: "conv8_2_mbox_conf_flat" 1714 | bottom: "conv9_2_mbox_conf_flat" 1715 | top: "mbox_conf" 1716 | concat_param { 1717 | axis: 1 1718 | } 1719 | } 1720 | layer { 1721 | name: "mbox_priorbox" 1722 | type: "Concat" 1723 | bottom: "conv4_3_norm_mbox_priorbox" 1724 | bottom: "fc7_mbox_priorbox" 1725 | bottom: "conv6_2_mbox_priorbox" 1726 | bottom: "conv7_2_mbox_priorbox" 1727 | bottom: "conv8_2_mbox_priorbox" 1728 | bottom: "conv9_2_mbox_priorbox" 1729 | top: "mbox_priorbox" 1730 | concat_param { 1731 | axis: 2 1732 | } 1733 | } 1734 | 1735 | layer { 1736 | name: "mbox_conf_reshape" 1737 | type: "Reshape" 1738 | bottom: "mbox_conf" 1739 | top: "mbox_conf_reshape" 1740 | reshape_param { 1741 | shape { 1742 | dim: 0 1743 | dim: -1 1744 | dim: 2 1745 | } 1746 | } 1747 | } 1748 | layer { 1749 | name: "mbox_conf_softmax" 1750 | type: "Softmax" 1751 | bottom: "mbox_conf_reshape" 1752 | top: "mbox_conf_softmax" 1753 | softmax_param { 1754 | axis: 2 1755 | } 1756 | } 1757 | layer { 1758 | name: "mbox_conf_flatten" 1759 | type: "Flatten" 1760 | bottom: "mbox_conf_softmax" 1761 | top: "mbox_conf_flatten" 1762 | flatten_param { 1763 | axis: 1 1764 | } 1765 | } 1766 | 1767 | layer { 1768 | name: "detection_out" 1769 | type: "DetectionOutput" 1770 | bottom: "mbox_loc" 1771 | bottom: "mbox_conf_flatten" 1772 | bottom: "mbox_priorbox" 1773 | top: "detection_out" 1774 | include { 1775 | phase: TEST 1776 | } 1777 | detection_output_param { 1778 | num_classes: 2 1779 | share_location: true 1780 | background_label_id: 0 1781 | nms_param { 1782 | nms_threshold: 0.45 1783 | top_k: 400 1784 | } 1785 | code_type: CENTER_SIZE 1786 | keep_top_k: 200 1787 | confidence_threshold: 0.01 1788 | } 1789 | } 1790 | -------------------------------------------------------------------------------- /FaceDetectionOpenCV/face_detection_ssd_parallel.py: -------------------------------------------------------------------------------- 1 | # importing required libaries 2 | import cv2 3 | import numpy as np 4 | from imutils.video import WebcamVideoStream, FPS # pip install imutils (if imutils library not already installed) 5 | 6 | # defining parameters and helper functions for performing face detection 7 | model_config_filepath = 'deploy.prototxt.txt' 8 | model_weights_filepath = 'res10_300x300_ssd_iter_140000.caffemodel' 9 | confidence_thresh = 0.9 # threshold for filtering weak detections 10 | 11 | # loading inference model using cv2's dnn module 12 | model = cv2.dnn.readNet(model=model_weights_filepath, config=model_config_filepath) 13 | 14 | # defining function for detecting faces in a single input image/video frame 15 | def detect_faces(frame): 16 | # original frame resolution 17 | orig_h, orig_w = frame.shape[:2] 18 | 19 | # preprocessing input frame 20 | h , w = 300 , 300 # required height and width after resizing 21 | resized_frame = cv2.resize(frame, (w,h) ) # performing resizing 22 | # performing mean subtraction and reshaping to a blob/image of shape 1x3x300x300 23 | blob = cv2.dnn.blobFromImage(resized_frame, scalefactor=1, size=(w,h), mean=(104, 177, 123)) # mean values are in BGR ordering 24 | 25 | # performing inference 26 | model.setInput(blob) 27 | detections = model.forward() # returned detections are of shape (1,1,num_detections,7). 28 | 29 | # looping over all detections and annotating input frame with high confidence detections 30 | for i in range(detections.shape[2]) : 31 | confidence = detections[0,0,i,2] # index 2 stores the confidence/probability of the detection 32 | if confidence < confidence_thresh : 33 | continue 34 | 35 | # indices 3,4,5,6 store the bounding box coordinates in order [xmin, ymin, xmax, ymax] with values in the range 0-1 36 | bbox = detections[0,0,i,3:7] * np.array([orig_w, orig_h, orig_w, orig_h]) # scaling bounding box coordinates back to original frame dimensions 37 | bbox = bbox.astype(np.int) # type casting and rounding to int type 38 | cv2.rectangle(frame, (bbox[0], bbox[1]) , (bbox[2], bbox[3]) , (0,0,255) , 2) # drawing rectangular bounding boxes around detections 39 | 40 | return frame 41 | 42 | # setting up input video stream for reading from webcam 43 | webcam_stream = WebcamVideoStream(0) # opening video stream from primary camera 44 | webcam_stream.start() 45 | fps = FPS() # for computing frames processed per second 46 | 47 | # processing video frames 48 | fps.start() 49 | while True : 50 | # reading next frame from input stream 51 | frame = webcam_stream.read() 52 | fps.update() 53 | 54 | # detecting faces in the read frame 55 | frame_with_detections = detect_faces(frame) 56 | 57 | # displaying the frame 58 | cv2.imshow('Detected Faces', frame_with_detections) 59 | key_pressed = cv2.waitKey(1) # a 1 millisecond delay 60 | if key_pressed == ord('q'): 61 | break 62 | fps.stop() 63 | 64 | # closing open streams, etc 65 | webcam_stream.stop() 66 | cv2.destroyAllWindows() 67 | 68 | # printing stats - fps 69 | print("FPS:{}".format(fps.fps())) 70 | -------------------------------------------------------------------------------- /FaceDetectionOpenCV/res10_300x300_ssd_iter_140000.caffemodel: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/FaceDetectionOpenCV/res10_300x300_ssd_iter_140000.caffemodel -------------------------------------------------------------------------------- /MultiThreadedVideoProcessing/Readme.md: -------------------------------------------------------------------------------- 1 | # Faster Real-Time Video Processing using Multi-Threading in Python 2 | 1. Two python scripts are included for processing video frames from a webcam connected to a laptop or desktop. One script uses a non-threaded implementation and the second script uses a threaded implementation. 3 | 2. Multi-threaded implementation can help achieve a higher FPS 4 | 3. Delay variable in the code can be used for simulating time taken for performing some video processing task like running a deep learning model for face detection, etc. Different amounts of delay can be used to evaluate performance. 5 | 4. Link to medium blog post with more details 6 | 7 | ## Programming language and libraries used 8 | 1. Python programming language 9 | 2. OpenCV library 10 | 3. Other Python libraries including threading library 11 | 12 | -------------------------------------------------------------------------------- /MultiThreadedVideoProcessing/video_processing_parallel.py: -------------------------------------------------------------------------------- 1 | # importing required libraries 2 | import cv2 3 | import time 4 | from threading import Thread # library for implementing multi-threaded processing 5 | 6 | # defining a helper class for implementing multi-threaded processing 7 | class WebcamStream : 8 | def __init__(self, stream_id=0): 9 | self.stream_id = stream_id # default is 0 for primary camera 10 | 11 | # opening video capture stream 12 | self.vcap = cv2.VideoCapture(self.stream_id) 13 | if self.vcap.isOpened() is False : 14 | print("[Exiting]: Error accessing webcam stream.") 15 | exit(0) 16 | fps_input_stream = int(self.vcap.get(5)) 17 | print("FPS of webcam hardware/input stream: {}".format(fps_input_stream)) 18 | 19 | # reading a single frame from vcap stream for initializing 20 | self.grabbed , self.frame = self.vcap.read() 21 | if self.grabbed is False : 22 | print('[Exiting] No more frames to read') 23 | exit(0) 24 | 25 | # self.stopped is set to False when frames are being read from self.vcap stream 26 | self.stopped = True 27 | 28 | # reference to the thread for reading next available frame from input stream 29 | self.t = Thread(target=self.update, args=()) 30 | self.t.daemon = True # daemon threads keep running in the background while the program is executing 31 | 32 | # method for starting the thread for grabbing next available frame in input stream 33 | def start(self): 34 | self.stopped = False 35 | self.t.start() 36 | 37 | # method for reading next frame 38 | def update(self): 39 | while True : 40 | if self.stopped is True : 41 | break 42 | self.grabbed , self.frame = self.vcap.read() 43 | if self.grabbed is False : 44 | print('[Exiting] No more frames to read') 45 | self.stopped = True 46 | break 47 | self.vcap.release() 48 | 49 | # method for returning latest read frame 50 | def read(self): 51 | return self.frame 52 | 53 | # method called to stop reading frames 54 | def stop(self): 55 | self.stopped = True 56 | 57 | 58 | # initializing and starting multi-threaded webcam capture input stream 59 | webcam_stream = WebcamStream(stream_id=0) # stream_id = 0 is for primary camera 60 | webcam_stream.start() 61 | 62 | # processing frames in input stream 63 | num_frames_processed = 0 64 | start = time.time() 65 | while True : 66 | if webcam_stream.stopped is True : 67 | break 68 | else : 69 | frame = webcam_stream.read() 70 | 71 | # adding a delay for simulating time taken for processing a frame 72 | delay = 0.03 # delay value in seconds. so, delay=1 is equivalent to 1 second 73 | time.sleep(delay) 74 | num_frames_processed += 1 75 | 76 | cv2.imshow('frame' , frame) 77 | key = cv2.waitKey(1) 78 | if key == ord('q'): 79 | break 80 | end = time.time() 81 | webcam_stream.stop() # stop the webcam stream 82 | 83 | # printing time elapsed and fps 84 | elapsed = end-start 85 | fps = num_frames_processed/elapsed 86 | print("FPS: {} , Elapsed Time: {} , Frames Processed: {}".format(fps, elapsed, num_frames_processed)) 87 | 88 | # closing all windows 89 | cv2.destroyAllWindows() 90 | -------------------------------------------------------------------------------- /MultiThreadedVideoProcessing/video_processing_simple.py: -------------------------------------------------------------------------------- 1 | # importing required libraries 2 | import cv2 3 | import time 4 | 5 | # opening video capture stream 6 | vcap = cv2.VideoCapture(0) 7 | if vcap.isOpened() is False : 8 | print("[Exiting]: Error accessing webcam stream.") 9 | exit(0) 10 | fps_input_stream = int(vcap.get(5)) 11 | print("FPS of webcam hardware/input stream: {}".format(fps_input_stream)) 12 | grabbed, frame = vcap.read() # reading single frame for initialization/ hardware warm-up 13 | 14 | # processing frames in input stream 15 | num_frames_processed = 0 16 | start = time.time() 17 | while True : 18 | grabbed, frame = vcap.read() 19 | if grabbed is False : 20 | print('[Exiting] No more frames to read') 21 | break 22 | 23 | # adding a delay for simulating time taken for processing a frame 24 | delay = 0.03 # delay value in seconds. so, delay=1 is equivalent to 1 second 25 | time.sleep(delay) 26 | num_frames_processed += 1 27 | 28 | cv2.imshow('frame' , frame) 29 | key = cv2.waitKey(1) 30 | if key == ord('q'): 31 | break 32 | end = time.time() 33 | 34 | # printing time elapsed and fps 35 | elapsed = end-start 36 | fps = num_frames_processed/elapsed 37 | print("FPS: {} , Elapsed Time: {} , Frames Processed: {}".format(fps, elapsed, num_frames_processed)) 38 | 39 | # releasing input stream , closing all windows 40 | vcap.release() 41 | cv2.destroyAllWindows() 42 | -------------------------------------------------------------------------------- /NeuralStyleTransfer/README.md: -------------------------------------------------------------------------------- 1 | # Neural Style Transfer using TensorFlow 2 | Neural Style Transfer is a technique for generating new artistic images from existing content and style images. This project uses an unsupervised deep learning algorithm for performing neural style transfer. 3 | 4 | ![Generated Style Transferred Image](neural_style_transfer.png) 5 | 6 | ## Programming Language and Libraries used 7 | 1. Python 3.x 8 | 2. Tensorflow 2.x and Keras API 9 | 3. Other python libraries like Numpy, OpenCV 10 | 11 | ## Notes 12 | 1. Link to Medium Article presenting the main ideas and implementation details of Neural Style Transfer using TensorFlow 13 | 14 | -------------------------------------------------------------------------------- /NeuralStyleTransfer/content.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/NeuralStyleTransfer/content.jpg -------------------------------------------------------------------------------- /NeuralStyleTransfer/neural_style_transfer.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/NeuralStyleTransfer/neural_style_transfer.png -------------------------------------------------------------------------------- /NeuralStyleTransfer/style_mosaic.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/NeuralStyleTransfer/style_mosaic.jpg -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Computer Vision and Deep Learning Projects 2 | This repo contains code for some of my computer vision and deep learning projects. 3 | 4 | ## List of Projects 5 | | Project | 6 | | ------------- | 7 | | [Image Classifier for The Street View House Numbers (SVHN) Dataset](StreetViewHouseNumbers_Classifier/) | 8 | | [A Simple CNN Image Classifier for Cifar-10 dataset](CIFAR10_Image_Classifier/) | 9 | | [Convolutional Neural Network Visualizer](ConvolutionalNeuralNetworkVisualizer/) | 10 | | [Transfer Learning example using ResNet-50 architecture](TransferLearningResnet/) | 11 | | [Neural Style Transfer using TensorFlow](NeuralStyleTransfer/) [[ Blog ]](https://medium.com/@vasu.gupta9/neural-style-transfer-using-tensorflow-7e0f3e789e0c) | 12 | | [Video Activity Recognition using Pretrained 3D ResNet model](VideoActivityRecognition3DResnet/) [[ Blog ]](https://gvasu.medium.com/recognizing-400-different-activities-in-videos-using-python-and-opencv-ee59cc6d61f6) | 13 | | [Faster Real-Time Video Processing using Multi-Threading in Python](MultiThreadedVideoProcessing/) [[ Blog ]](https://gvasu.medium.com/faster-real-time-video-processing-using-multi-threading-in-python-8902589e1055) | 14 | | [Real-Time Face Detection Using OpenCV](FaceDetectionOpenCV/) -------------------------------------------------------------------------------- /StreetViewHouseNumbers_Classifier/Readme.md: -------------------------------------------------------------------------------- 1 | # This project is an Image Classifier for the Street View House Numbers (SVHN) Dataset obtained from house numbers in Google Street View images. 2 | 3 | ![SVHN overview image](SVHN_Overview_Image.png) 4 | [*Image Source*](http://ufldl.stanford.edu/housenumbers/) 5 | 6 | ## Project folder includes 7 | 1. Readme.md (*this file*) 8 | 2. Google colab notebook for building, training and testing a Convolutional Neural Network on the SVHN dataset. 9 | 3. Misc 10 | * SVHN Overview Image 11 | 12 | ## Libraries used 13 | 1. Python programming language is used 14 | 2. Deep learning libraries Tensorflow 2.x and Keras API 15 | 3. Other python libraries including numpy, etc 16 | 17 | ## Notes 18 | 1. The SVHN dataset has 2 formats. This project uses Format 2: Cropped Digits 19 | -------------------------------------------------------------------------------- /StreetViewHouseNumbers_Classifier/SVHN_Overview_Image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/StreetViewHouseNumbers_Classifier/SVHN_Overview_Image.png -------------------------------------------------------------------------------- /TransferLearningResnet/Readme.md: -------------------------------------------------------------------------------- 1 | # Purpose of this project is to demonstrate how to build and train a Deep Neural Network using Transfer Learning 2 | 1. Dataset used is Cifar-10 which contains images from 10 different classes (https://www.cs.toronto.edu/~kriz/cifar.html) 3 | 2. Architecture used is ResNet-50 (https://keras.io/api/applications/) 4 | 5 | ![Example images from cifar-10 dataset](cifar10_img.png) 6 | [*Image Source*](https://www.cs.toronto.edu/~kriz/cifar.html) 7 | 8 | ## Project folder includes 9 | 1. Readme.md (this file) 10 | 2. Google colab notebook for building, training and testing a ResNet50 architecture using transfer learning on the CIFAR-10 dataset. 11 | 3. Misc 12 | - CIFAR-10 overview image 13 | 14 | ## Programming language and Libraries used 15 | 1. Python programming language 16 | 2. Deep learning libraries tensorflow 2.x and Keras API 17 | 3. Python libraries including numpy, etc 18 | -------------------------------------------------------------------------------- /TransferLearningResnet/Transfer_Learning_ResNet_ImageClassifier.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "nbformat": 4, 3 | "nbformat_minor": 0, 4 | "metadata": { 5 | "colab": { 6 | "name": "Transfer_Learning_ResNet_ImageClassifier.ipynb", 7 | "provenance": [], 8 | "collapsed_sections": [], 9 | "toc_visible": true, 10 | "authorship_tag": "ABX9TyMgQ4Qi0SYj/dBzG221AxvF", 11 | "include_colab_link": true 12 | }, 13 | "kernelspec": { 14 | "name": "python3", 15 | "display_name": "Python 3" 16 | }, 17 | "language_info": { 18 | "name": "python" 19 | }, 20 | "accelerator": "GPU" 21 | }, 22 | "cells": [ 23 | { 24 | "cell_type": "markdown", 25 | "metadata": { 26 | "id": "view-in-github", 27 | "colab_type": "text" 28 | }, 29 | "source": [ 30 | "\"Open" 31 | ] 32 | }, 33 | { 34 | "cell_type": "markdown", 35 | "metadata": { 36 | "id": "ZdvsU9L3T_8P" 37 | }, 38 | "source": [ 39 | "# Purpose of this notebook is to show an example of training a Deep Neural Network using Transfer Learning\n", 40 | "1. Dataset used is Cifar-10 which contains images from 10 different classes (https://www.cs.toronto.edu/~kriz/cifar.html)\n", 41 | "2. Architecture used is ResNet-50 (https://keras.io/api/applications/)\n" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "metadata": { 47 | "id": "5puSqI9GSmk2" 48 | }, 49 | "source": [ 50 | "# importing required libraries\n", 51 | "import numpy as np \n", 52 | "import cv2\n", 53 | "import matplotlib.pyplot as plt \n", 54 | "import tensorflow as tf \n", 55 | "from tensorflow.keras.models import Model \n", 56 | "from tensorflow.keras.layers import Dense , Input\n", 57 | "from tensorflow.keras.datasets import cifar10\n", 58 | "from tensorflow.keras.applications import ResNet50\n", 59 | "from tensorflow.keras.applications.resnet import preprocess_input as resnet_preprocess_input\n" 60 | ], 61 | "execution_count": 5, 62 | "outputs": [] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "metadata": { 67 | "colab": { 68 | "base_uri": "https://localhost:8080/" 69 | }, 70 | "id": "oKNeyDZ9VrKj", 71 | "outputId": "dd9cfa2e-d9e1-437f-ea17-695d7c39356c" 72 | }, 73 | "source": [ 74 | "# loading cifar-10 dataset \n", 75 | "(x_train, y_train) , (x_test, y_test) = cifar10.load_data()\n", 76 | "\n", 77 | "# reshaping y_train, y_test to 1D arrays (since later using loss function as sparse categorical crossentropy)\n", 78 | "y_train = y_train.reshape(-1)\n", 79 | "y_test = y_test.reshape(-1)\n", 80 | "\n", 81 | "label_names = ['airplane','automobile','bird','cat', 'deer' , 'dog', 'frog', 'horse', 'ship', 'truck' ] # reference - https://www.cs.toronto.edu/~kriz/cifar.html" 82 | ], 83 | "execution_count": 6, 84 | "outputs": [ 85 | { 86 | "output_type": "stream", 87 | "text": [ 88 | "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n", 89 | "170500096/170498071 [==============================] - 11s 0us/step\n" 90 | ], 91 | "name": "stdout" 92 | } 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "metadata": { 98 | "colab": { 99 | "base_uri": "https://localhost:8080/", 100 | "height": 366 101 | }, 102 | "id": "pteamvelXP3s", 103 | "outputId": "6d520fec-39df-4f7d-cf62-b26ecbc9b90e" 104 | }, 105 | "source": [ 106 | "# printing useful dataset related information \n", 107 | "\n", 108 | "# printing dataset shapes\n", 109 | "print(\"x_train:{} , y_train:{} , x_test:{} , y_test:{} \".format(x_train.shape, y_train.shape, x_test.shape, y_test.shape ))\n", 110 | "\n", 111 | "# printing range of values in x_train, x_test and unique values in y_train, y_test\n", 112 | "print(\"x_train values are in range:{}-{}\".format(np.min(x_train), np.max(x_train)))\n", 113 | "print(\"x_test values are in range:{}-{}\".format(np.min(x_test), np.max(x_test)))\n", 114 | "print(\"unique values in y_train:{}\".format(np.unique(y_train)))\n", 115 | "print(\"unique values in y_test:{}\".format(np.unique(y_test)))\n", 116 | "\n", 117 | "# visualizing sample image \n", 118 | "idx = 0\n", 119 | "img = x_train[idx]\n", 120 | "label_id = y_train[idx]\n", 121 | "plt.title( \"image label {}:{}\".format( label_names[label_id] , label_id ) )\n", 122 | "plt.imshow(img)\n", 123 | "plt.show()" 124 | ], 125 | "execution_count": 7, 126 | "outputs": [ 127 | { 128 | "output_type": "stream", 129 | "text": [ 130 | "x_train:(50000, 32, 32, 3) , y_train:(50000,) , x_test:(10000, 32, 32, 3) , y_test:(10000,) \n", 131 | "x_train values are in range:0-255\n", 132 | "x_test values are in range:0-255\n", 133 | "unique values in y_train:[0 1 2 3 4 5 6 7 8 9]\n", 134 | "unique values in y_test:[0 1 2 3 4 5 6 7 8 9]\n" 135 | ], 136 | "name": "stdout" 137 | }, 138 | { 139 | "output_type": "display_data", 140 | "data": { 141 | "image/png": "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\n", 142 | "text/plain": [ 143 | "
" 144 | ] 145 | }, 146 | "metadata": { 147 | "tags": [], 148 | "needs_background": "light" 149 | } 150 | } 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "metadata": { 156 | "colab": { 157 | "base_uri": "https://localhost:8080/" 158 | }, 159 | "id": "b5C73dgyZ0zG", 160 | "outputId": "c8a82177-b95e-4c63-88ba-084e5118e9e1" 161 | }, 162 | "source": [ 163 | "# pre-processing the image for classification using resnet model (expects a specific kind of input preprocessing for resnet)\n", 164 | "x_train_pp = x_train.astype('float32')\n", 165 | "x_train_pp = resnet_preprocess_input(x_train_pp)\n", 166 | "x_test_pp = x_test.astype('float32')\n", 167 | "x_test_pp = resnet_preprocess_input(x_test_pp)\n", 168 | "\n", 169 | "# printing range of values in x_train_pp, x_test_pp\n", 170 | "print(\"x_train_pp values are in range:{} to {}\".format(np.min(x_train_pp), np.max(x_train_pp)))\n", 171 | "print(\"x_test_pp values are in range:{} to {}\".format(np.min(x_test_pp), np.max(x_test_pp)))" 172 | ], 173 | "execution_count": 8, 174 | "outputs": [ 175 | { 176 | "output_type": "stream", 177 | "text": [ 178 | "x_train_pp values are in range:-123.68000030517578 to 151.06100463867188\n", 179 | "x_test_pp values are in range:-123.68000030517578 to 151.06100463867188\n" 180 | ], 181 | "name": "stdout" 182 | } 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "metadata": { 188 | "colab": { 189 | "base_uri": "https://localhost:8080/" 190 | }, 191 | "id": "W0GZNNXocHaM", 192 | "outputId": "de3fc1e4-5b6f-4e8a-c3b5-afe6f9b14503" 193 | }, 194 | "source": [ 195 | "# loading the resnet model \n", 196 | "# 1. top layer (global avg pooling + output dense layer) in not loaded\n", 197 | "# 2. weights pre-trained on imagenet are used \n", 198 | "# 3. input image shape is (32,32,3)\n", 199 | "# 4. global average pooling is added at the top \n", 200 | "model_resnet = ResNet50(include_top=False, weights='imagenet', input_shape=(32,32,3) , pooling='avg')\n", 201 | "model_resnet.summary()" 202 | ], 203 | "execution_count": 9, 204 | "outputs": [ 205 | { 206 | "output_type": "stream", 207 | "text": [ 208 | "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5\n", 209 | "94773248/94765736 [==============================] - 1s 0us/step\n", 210 | "Model: \"resnet50\"\n", 211 | "__________________________________________________________________________________________________\n", 212 | "Layer (type) Output Shape Param # Connected to \n", 213 | "==================================================================================================\n", 214 | "input_1 (InputLayer) [(None, 32, 32, 3)] 0 \n", 215 | "__________________________________________________________________________________________________\n", 216 | "conv1_pad (ZeroPadding2D) (None, 38, 38, 3) 0 input_1[0][0] \n", 217 | "__________________________________________________________________________________________________\n", 218 | "conv1_conv (Conv2D) (None, 16, 16, 64) 9472 conv1_pad[0][0] \n", 219 | "__________________________________________________________________________________________________\n", 220 | "conv1_bn (BatchNormalization) (None, 16, 16, 64) 256 conv1_conv[0][0] \n", 221 | "__________________________________________________________________________________________________\n", 222 | "conv1_relu (Activation) (None, 16, 16, 64) 0 conv1_bn[0][0] \n", 223 | "__________________________________________________________________________________________________\n", 224 | "pool1_pad (ZeroPadding2D) (None, 18, 18, 64) 0 conv1_relu[0][0] \n", 225 | "__________________________________________________________________________________________________\n", 226 | "pool1_pool (MaxPooling2D) (None, 8, 8, 64) 0 pool1_pad[0][0] \n", 227 | "__________________________________________________________________________________________________\n", 228 | "conv2_block1_1_conv (Conv2D) (None, 8, 8, 64) 4160 pool1_pool[0][0] \n", 229 | "__________________________________________________________________________________________________\n", 230 | "conv2_block1_1_bn (BatchNormali (None, 8, 8, 64) 256 conv2_block1_1_conv[0][0] \n", 231 | "__________________________________________________________________________________________________\n", 232 | "conv2_block1_1_relu (Activation (None, 8, 8, 64) 0 conv2_block1_1_bn[0][0] \n", 233 | "__________________________________________________________________________________________________\n", 234 | "conv2_block1_2_conv (Conv2D) (None, 8, 8, 64) 36928 conv2_block1_1_relu[0][0] \n", 235 | "__________________________________________________________________________________________________\n", 236 | "conv2_block1_2_bn (BatchNormali (None, 8, 8, 64) 256 conv2_block1_2_conv[0][0] \n", 237 | "__________________________________________________________________________________________________\n", 238 | "conv2_block1_2_relu (Activation (None, 8, 8, 64) 0 conv2_block1_2_bn[0][0] \n", 239 | "__________________________________________________________________________________________________\n", 240 | "conv2_block1_0_conv (Conv2D) (None, 8, 8, 256) 16640 pool1_pool[0][0] \n", 241 | "__________________________________________________________________________________________________\n", 242 | "conv2_block1_3_conv (Conv2D) (None, 8, 8, 256) 16640 conv2_block1_2_relu[0][0] \n", 243 | "__________________________________________________________________________________________________\n", 244 | "conv2_block1_0_bn (BatchNormali (None, 8, 8, 256) 1024 conv2_block1_0_conv[0][0] \n", 245 | "__________________________________________________________________________________________________\n", 246 | "conv2_block1_3_bn (BatchNormali (None, 8, 8, 256) 1024 conv2_block1_3_conv[0][0] \n", 247 | "__________________________________________________________________________________________________\n", 248 | "conv2_block1_add (Add) (None, 8, 8, 256) 0 conv2_block1_0_bn[0][0] \n", 249 | " conv2_block1_3_bn[0][0] \n", 250 | "__________________________________________________________________________________________________\n", 251 | "conv2_block1_out (Activation) (None, 8, 8, 256) 0 conv2_block1_add[0][0] \n", 252 | "__________________________________________________________________________________________________\n", 253 | "conv2_block2_1_conv (Conv2D) (None, 8, 8, 64) 16448 conv2_block1_out[0][0] \n", 254 | "__________________________________________________________________________________________________\n", 255 | "conv2_block2_1_bn (BatchNormali (None, 8, 8, 64) 256 conv2_block2_1_conv[0][0] \n", 256 | "__________________________________________________________________________________________________\n", 257 | "conv2_block2_1_relu (Activation (None, 8, 8, 64) 0 conv2_block2_1_bn[0][0] \n", 258 | "__________________________________________________________________________________________________\n", 259 | "conv2_block2_2_conv (Conv2D) (None, 8, 8, 64) 36928 conv2_block2_1_relu[0][0] \n", 260 | "__________________________________________________________________________________________________\n", 261 | "conv2_block2_2_bn (BatchNormali (None, 8, 8, 64) 256 conv2_block2_2_conv[0][0] \n", 262 | "__________________________________________________________________________________________________\n", 263 | "conv2_block2_2_relu (Activation (None, 8, 8, 64) 0 conv2_block2_2_bn[0][0] \n", 264 | "__________________________________________________________________________________________________\n", 265 | "conv2_block2_3_conv (Conv2D) (None, 8, 8, 256) 16640 conv2_block2_2_relu[0][0] \n", 266 | "__________________________________________________________________________________________________\n", 267 | "conv2_block2_3_bn (BatchNormali (None, 8, 8, 256) 1024 conv2_block2_3_conv[0][0] \n", 268 | "__________________________________________________________________________________________________\n", 269 | "conv2_block2_add (Add) (None, 8, 8, 256) 0 conv2_block1_out[0][0] \n", 270 | " conv2_block2_3_bn[0][0] \n", 271 | "__________________________________________________________________________________________________\n", 272 | "conv2_block2_out (Activation) (None, 8, 8, 256) 0 conv2_block2_add[0][0] \n", 273 | "__________________________________________________________________________________________________\n", 274 | "conv2_block3_1_conv (Conv2D) (None, 8, 8, 64) 16448 conv2_block2_out[0][0] \n", 275 | "__________________________________________________________________________________________________\n", 276 | "conv2_block3_1_bn (BatchNormali (None, 8, 8, 64) 256 conv2_block3_1_conv[0][0] \n", 277 | "__________________________________________________________________________________________________\n", 278 | "conv2_block3_1_relu (Activation (None, 8, 8, 64) 0 conv2_block3_1_bn[0][0] \n", 279 | "__________________________________________________________________________________________________\n", 280 | "conv2_block3_2_conv (Conv2D) (None, 8, 8, 64) 36928 conv2_block3_1_relu[0][0] \n", 281 | "__________________________________________________________________________________________________\n", 282 | "conv2_block3_2_bn (BatchNormali (None, 8, 8, 64) 256 conv2_block3_2_conv[0][0] \n", 283 | "__________________________________________________________________________________________________\n", 284 | "conv2_block3_2_relu (Activation (None, 8, 8, 64) 0 conv2_block3_2_bn[0][0] \n", 285 | "__________________________________________________________________________________________________\n", 286 | "conv2_block3_3_conv (Conv2D) (None, 8, 8, 256) 16640 conv2_block3_2_relu[0][0] \n", 287 | "__________________________________________________________________________________________________\n", 288 | "conv2_block3_3_bn (BatchNormali (None, 8, 8, 256) 1024 conv2_block3_3_conv[0][0] \n", 289 | "__________________________________________________________________________________________________\n", 290 | "conv2_block3_add (Add) (None, 8, 8, 256) 0 conv2_block2_out[0][0] \n", 291 | " conv2_block3_3_bn[0][0] \n", 292 | "__________________________________________________________________________________________________\n", 293 | "conv2_block3_out (Activation) (None, 8, 8, 256) 0 conv2_block3_add[0][0] \n", 294 | "__________________________________________________________________________________________________\n", 295 | "conv3_block1_1_conv (Conv2D) (None, 4, 4, 128) 32896 conv2_block3_out[0][0] \n", 296 | "__________________________________________________________________________________________________\n", 297 | "conv3_block1_1_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block1_1_conv[0][0] \n", 298 | "__________________________________________________________________________________________________\n", 299 | "conv3_block1_1_relu (Activation (None, 4, 4, 128) 0 conv3_block1_1_bn[0][0] \n", 300 | "__________________________________________________________________________________________________\n", 301 | "conv3_block1_2_conv (Conv2D) (None, 4, 4, 128) 147584 conv3_block1_1_relu[0][0] \n", 302 | "__________________________________________________________________________________________________\n", 303 | "conv3_block1_2_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block1_2_conv[0][0] \n", 304 | "__________________________________________________________________________________________________\n", 305 | "conv3_block1_2_relu (Activation (None, 4, 4, 128) 0 conv3_block1_2_bn[0][0] \n", 306 | "__________________________________________________________________________________________________\n", 307 | "conv3_block1_0_conv (Conv2D) (None, 4, 4, 512) 131584 conv2_block3_out[0][0] \n", 308 | "__________________________________________________________________________________________________\n", 309 | "conv3_block1_3_conv (Conv2D) (None, 4, 4, 512) 66048 conv3_block1_2_relu[0][0] \n", 310 | "__________________________________________________________________________________________________\n", 311 | "conv3_block1_0_bn (BatchNormali (None, 4, 4, 512) 2048 conv3_block1_0_conv[0][0] \n", 312 | "__________________________________________________________________________________________________\n", 313 | "conv3_block1_3_bn (BatchNormali (None, 4, 4, 512) 2048 conv3_block1_3_conv[0][0] \n", 314 | "__________________________________________________________________________________________________\n", 315 | "conv3_block1_add (Add) (None, 4, 4, 512) 0 conv3_block1_0_bn[0][0] \n", 316 | " conv3_block1_3_bn[0][0] \n", 317 | "__________________________________________________________________________________________________\n", 318 | "conv3_block1_out (Activation) (None, 4, 4, 512) 0 conv3_block1_add[0][0] \n", 319 | "__________________________________________________________________________________________________\n", 320 | "conv3_block2_1_conv (Conv2D) (None, 4, 4, 128) 65664 conv3_block1_out[0][0] \n", 321 | "__________________________________________________________________________________________________\n", 322 | "conv3_block2_1_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block2_1_conv[0][0] \n", 323 | "__________________________________________________________________________________________________\n", 324 | "conv3_block2_1_relu (Activation (None, 4, 4, 128) 0 conv3_block2_1_bn[0][0] \n", 325 | "__________________________________________________________________________________________________\n", 326 | "conv3_block2_2_conv (Conv2D) (None, 4, 4, 128) 147584 conv3_block2_1_relu[0][0] \n", 327 | "__________________________________________________________________________________________________\n", 328 | "conv3_block2_2_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block2_2_conv[0][0] \n", 329 | "__________________________________________________________________________________________________\n", 330 | "conv3_block2_2_relu (Activation (None, 4, 4, 128) 0 conv3_block2_2_bn[0][0] \n", 331 | "__________________________________________________________________________________________________\n", 332 | "conv3_block2_3_conv (Conv2D) (None, 4, 4, 512) 66048 conv3_block2_2_relu[0][0] \n", 333 | "__________________________________________________________________________________________________\n", 334 | "conv3_block2_3_bn (BatchNormali (None, 4, 4, 512) 2048 conv3_block2_3_conv[0][0] \n", 335 | "__________________________________________________________________________________________________\n", 336 | "conv3_block2_add (Add) (None, 4, 4, 512) 0 conv3_block1_out[0][0] \n", 337 | " conv3_block2_3_bn[0][0] \n", 338 | "__________________________________________________________________________________________________\n", 339 | "conv3_block2_out (Activation) (None, 4, 4, 512) 0 conv3_block2_add[0][0] \n", 340 | "__________________________________________________________________________________________________\n", 341 | "conv3_block3_1_conv (Conv2D) (None, 4, 4, 128) 65664 conv3_block2_out[0][0] \n", 342 | "__________________________________________________________________________________________________\n", 343 | "conv3_block3_1_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block3_1_conv[0][0] \n", 344 | "__________________________________________________________________________________________________\n", 345 | "conv3_block3_1_relu (Activation (None, 4, 4, 128) 0 conv3_block3_1_bn[0][0] \n", 346 | "__________________________________________________________________________________________________\n", 347 | "conv3_block3_2_conv (Conv2D) (None, 4, 4, 128) 147584 conv3_block3_1_relu[0][0] \n", 348 | "__________________________________________________________________________________________________\n", 349 | "conv3_block3_2_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block3_2_conv[0][0] \n", 350 | "__________________________________________________________________________________________________\n", 351 | "conv3_block3_2_relu (Activation (None, 4, 4, 128) 0 conv3_block3_2_bn[0][0] \n", 352 | "__________________________________________________________________________________________________\n", 353 | "conv3_block3_3_conv (Conv2D) (None, 4, 4, 512) 66048 conv3_block3_2_relu[0][0] \n", 354 | "__________________________________________________________________________________________________\n", 355 | "conv3_block3_3_bn (BatchNormali (None, 4, 4, 512) 2048 conv3_block3_3_conv[0][0] \n", 356 | "__________________________________________________________________________________________________\n", 357 | "conv3_block3_add (Add) (None, 4, 4, 512) 0 conv3_block2_out[0][0] \n", 358 | " conv3_block3_3_bn[0][0] \n", 359 | "__________________________________________________________________________________________________\n", 360 | "conv3_block3_out (Activation) (None, 4, 4, 512) 0 conv3_block3_add[0][0] \n", 361 | "__________________________________________________________________________________________________\n", 362 | "conv3_block4_1_conv (Conv2D) (None, 4, 4, 128) 65664 conv3_block3_out[0][0] \n", 363 | "__________________________________________________________________________________________________\n", 364 | "conv3_block4_1_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block4_1_conv[0][0] \n", 365 | "__________________________________________________________________________________________________\n", 366 | "conv3_block4_1_relu (Activation (None, 4, 4, 128) 0 conv3_block4_1_bn[0][0] \n", 367 | "__________________________________________________________________________________________________\n", 368 | "conv3_block4_2_conv (Conv2D) (None, 4, 4, 128) 147584 conv3_block4_1_relu[0][0] \n", 369 | "__________________________________________________________________________________________________\n", 370 | "conv3_block4_2_bn (BatchNormali (None, 4, 4, 128) 512 conv3_block4_2_conv[0][0] \n", 371 | "__________________________________________________________________________________________________\n", 372 | "conv3_block4_2_relu (Activation (None, 4, 4, 128) 0 conv3_block4_2_bn[0][0] \n", 373 | "__________________________________________________________________________________________________\n", 374 | "conv3_block4_3_conv (Conv2D) (None, 4, 4, 512) 66048 conv3_block4_2_relu[0][0] \n", 375 | "__________________________________________________________________________________________________\n", 376 | "conv3_block4_3_bn (BatchNormali (None, 4, 4, 512) 2048 conv3_block4_3_conv[0][0] \n", 377 | "__________________________________________________________________________________________________\n", 378 | "conv3_block4_add (Add) (None, 4, 4, 512) 0 conv3_block3_out[0][0] \n", 379 | " conv3_block4_3_bn[0][0] \n", 380 | "__________________________________________________________________________________________________\n", 381 | "conv3_block4_out (Activation) (None, 4, 4, 512) 0 conv3_block4_add[0][0] \n", 382 | "__________________________________________________________________________________________________\n", 383 | "conv4_block1_1_conv (Conv2D) (None, 2, 2, 256) 131328 conv3_block4_out[0][0] \n", 384 | "__________________________________________________________________________________________________\n", 385 | "conv4_block1_1_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block1_1_conv[0][0] \n", 386 | "__________________________________________________________________________________________________\n", 387 | "conv4_block1_1_relu (Activation (None, 2, 2, 256) 0 conv4_block1_1_bn[0][0] \n", 388 | "__________________________________________________________________________________________________\n", 389 | "conv4_block1_2_conv (Conv2D) (None, 2, 2, 256) 590080 conv4_block1_1_relu[0][0] \n", 390 | "__________________________________________________________________________________________________\n", 391 | "conv4_block1_2_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block1_2_conv[0][0] \n", 392 | "__________________________________________________________________________________________________\n", 393 | "conv4_block1_2_relu (Activation (None, 2, 2, 256) 0 conv4_block1_2_bn[0][0] \n", 394 | "__________________________________________________________________________________________________\n", 395 | "conv4_block1_0_conv (Conv2D) (None, 2, 2, 1024) 525312 conv3_block4_out[0][0] \n", 396 | "__________________________________________________________________________________________________\n", 397 | "conv4_block1_3_conv (Conv2D) (None, 2, 2, 1024) 263168 conv4_block1_2_relu[0][0] \n", 398 | "__________________________________________________________________________________________________\n", 399 | "conv4_block1_0_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block1_0_conv[0][0] \n", 400 | "__________________________________________________________________________________________________\n", 401 | "conv4_block1_3_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block1_3_conv[0][0] \n", 402 | "__________________________________________________________________________________________________\n", 403 | "conv4_block1_add (Add) (None, 2, 2, 1024) 0 conv4_block1_0_bn[0][0] \n", 404 | " conv4_block1_3_bn[0][0] \n", 405 | "__________________________________________________________________________________________________\n", 406 | "conv4_block1_out (Activation) (None, 2, 2, 1024) 0 conv4_block1_add[0][0] \n", 407 | "__________________________________________________________________________________________________\n", 408 | "conv4_block2_1_conv (Conv2D) (None, 2, 2, 256) 262400 conv4_block1_out[0][0] \n", 409 | "__________________________________________________________________________________________________\n", 410 | "conv4_block2_1_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block2_1_conv[0][0] \n", 411 | "__________________________________________________________________________________________________\n", 412 | "conv4_block2_1_relu (Activation (None, 2, 2, 256) 0 conv4_block2_1_bn[0][0] \n", 413 | "__________________________________________________________________________________________________\n", 414 | "conv4_block2_2_conv (Conv2D) (None, 2, 2, 256) 590080 conv4_block2_1_relu[0][0] \n", 415 | "__________________________________________________________________________________________________\n", 416 | "conv4_block2_2_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block2_2_conv[0][0] \n", 417 | "__________________________________________________________________________________________________\n", 418 | "conv4_block2_2_relu (Activation (None, 2, 2, 256) 0 conv4_block2_2_bn[0][0] \n", 419 | "__________________________________________________________________________________________________\n", 420 | "conv4_block2_3_conv (Conv2D) (None, 2, 2, 1024) 263168 conv4_block2_2_relu[0][0] \n", 421 | "__________________________________________________________________________________________________\n", 422 | "conv4_block2_3_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block2_3_conv[0][0] \n", 423 | "__________________________________________________________________________________________________\n", 424 | "conv4_block2_add (Add) (None, 2, 2, 1024) 0 conv4_block1_out[0][0] \n", 425 | " conv4_block2_3_bn[0][0] \n", 426 | "__________________________________________________________________________________________________\n", 427 | "conv4_block2_out (Activation) (None, 2, 2, 1024) 0 conv4_block2_add[0][0] \n", 428 | "__________________________________________________________________________________________________\n", 429 | "conv4_block3_1_conv (Conv2D) (None, 2, 2, 256) 262400 conv4_block2_out[0][0] \n", 430 | "__________________________________________________________________________________________________\n", 431 | "conv4_block3_1_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block3_1_conv[0][0] \n", 432 | "__________________________________________________________________________________________________\n", 433 | "conv4_block3_1_relu (Activation (None, 2, 2, 256) 0 conv4_block3_1_bn[0][0] \n", 434 | "__________________________________________________________________________________________________\n", 435 | "conv4_block3_2_conv (Conv2D) (None, 2, 2, 256) 590080 conv4_block3_1_relu[0][0] \n", 436 | "__________________________________________________________________________________________________\n", 437 | "conv4_block3_2_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block3_2_conv[0][0] \n", 438 | "__________________________________________________________________________________________________\n", 439 | "conv4_block3_2_relu (Activation (None, 2, 2, 256) 0 conv4_block3_2_bn[0][0] \n", 440 | "__________________________________________________________________________________________________\n", 441 | "conv4_block3_3_conv (Conv2D) (None, 2, 2, 1024) 263168 conv4_block3_2_relu[0][0] \n", 442 | "__________________________________________________________________________________________________\n", 443 | "conv4_block3_3_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block3_3_conv[0][0] \n", 444 | "__________________________________________________________________________________________________\n", 445 | "conv4_block3_add (Add) (None, 2, 2, 1024) 0 conv4_block2_out[0][0] \n", 446 | " conv4_block3_3_bn[0][0] \n", 447 | "__________________________________________________________________________________________________\n", 448 | "conv4_block3_out (Activation) (None, 2, 2, 1024) 0 conv4_block3_add[0][0] \n", 449 | "__________________________________________________________________________________________________\n", 450 | "conv4_block4_1_conv (Conv2D) (None, 2, 2, 256) 262400 conv4_block3_out[0][0] \n", 451 | "__________________________________________________________________________________________________\n", 452 | "conv4_block4_1_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block4_1_conv[0][0] \n", 453 | "__________________________________________________________________________________________________\n", 454 | "conv4_block4_1_relu (Activation (None, 2, 2, 256) 0 conv4_block4_1_bn[0][0] \n", 455 | "__________________________________________________________________________________________________\n", 456 | "conv4_block4_2_conv (Conv2D) (None, 2, 2, 256) 590080 conv4_block4_1_relu[0][0] \n", 457 | "__________________________________________________________________________________________________\n", 458 | "conv4_block4_2_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block4_2_conv[0][0] \n", 459 | "__________________________________________________________________________________________________\n", 460 | "conv4_block4_2_relu (Activation (None, 2, 2, 256) 0 conv4_block4_2_bn[0][0] \n", 461 | "__________________________________________________________________________________________________\n", 462 | "conv4_block4_3_conv (Conv2D) (None, 2, 2, 1024) 263168 conv4_block4_2_relu[0][0] \n", 463 | "__________________________________________________________________________________________________\n", 464 | "conv4_block4_3_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block4_3_conv[0][0] \n", 465 | "__________________________________________________________________________________________________\n", 466 | "conv4_block4_add (Add) (None, 2, 2, 1024) 0 conv4_block3_out[0][0] \n", 467 | " conv4_block4_3_bn[0][0] \n", 468 | "__________________________________________________________________________________________________\n", 469 | "conv4_block4_out (Activation) (None, 2, 2, 1024) 0 conv4_block4_add[0][0] \n", 470 | "__________________________________________________________________________________________________\n", 471 | "conv4_block5_1_conv (Conv2D) (None, 2, 2, 256) 262400 conv4_block4_out[0][0] \n", 472 | "__________________________________________________________________________________________________\n", 473 | "conv4_block5_1_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block5_1_conv[0][0] \n", 474 | "__________________________________________________________________________________________________\n", 475 | "conv4_block5_1_relu (Activation (None, 2, 2, 256) 0 conv4_block5_1_bn[0][0] \n", 476 | "__________________________________________________________________________________________________\n", 477 | "conv4_block5_2_conv (Conv2D) (None, 2, 2, 256) 590080 conv4_block5_1_relu[0][0] \n", 478 | "__________________________________________________________________________________________________\n", 479 | "conv4_block5_2_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block5_2_conv[0][0] \n", 480 | "__________________________________________________________________________________________________\n", 481 | "conv4_block5_2_relu (Activation (None, 2, 2, 256) 0 conv4_block5_2_bn[0][0] \n", 482 | "__________________________________________________________________________________________________\n", 483 | "conv4_block5_3_conv (Conv2D) (None, 2, 2, 1024) 263168 conv4_block5_2_relu[0][0] \n", 484 | "__________________________________________________________________________________________________\n", 485 | "conv4_block5_3_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block5_3_conv[0][0] \n", 486 | "__________________________________________________________________________________________________\n", 487 | "conv4_block5_add (Add) (None, 2, 2, 1024) 0 conv4_block4_out[0][0] \n", 488 | " conv4_block5_3_bn[0][0] \n", 489 | "__________________________________________________________________________________________________\n", 490 | "conv4_block5_out (Activation) (None, 2, 2, 1024) 0 conv4_block5_add[0][0] \n", 491 | "__________________________________________________________________________________________________\n", 492 | "conv4_block6_1_conv (Conv2D) (None, 2, 2, 256) 262400 conv4_block5_out[0][0] \n", 493 | "__________________________________________________________________________________________________\n", 494 | "conv4_block6_1_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block6_1_conv[0][0] \n", 495 | "__________________________________________________________________________________________________\n", 496 | "conv4_block6_1_relu (Activation (None, 2, 2, 256) 0 conv4_block6_1_bn[0][0] \n", 497 | "__________________________________________________________________________________________________\n", 498 | "conv4_block6_2_conv (Conv2D) (None, 2, 2, 256) 590080 conv4_block6_1_relu[0][0] \n", 499 | "__________________________________________________________________________________________________\n", 500 | "conv4_block6_2_bn (BatchNormali (None, 2, 2, 256) 1024 conv4_block6_2_conv[0][0] \n", 501 | "__________________________________________________________________________________________________\n", 502 | "conv4_block6_2_relu (Activation (None, 2, 2, 256) 0 conv4_block6_2_bn[0][0] \n", 503 | "__________________________________________________________________________________________________\n", 504 | "conv4_block6_3_conv (Conv2D) (None, 2, 2, 1024) 263168 conv4_block6_2_relu[0][0] \n", 505 | "__________________________________________________________________________________________________\n", 506 | "conv4_block6_3_bn (BatchNormali (None, 2, 2, 1024) 4096 conv4_block6_3_conv[0][0] \n", 507 | "__________________________________________________________________________________________________\n", 508 | "conv4_block6_add (Add) (None, 2, 2, 1024) 0 conv4_block5_out[0][0] \n", 509 | " conv4_block6_3_bn[0][0] \n", 510 | "__________________________________________________________________________________________________\n", 511 | "conv4_block6_out (Activation) (None, 2, 2, 1024) 0 conv4_block6_add[0][0] \n", 512 | "__________________________________________________________________________________________________\n", 513 | "conv5_block1_1_conv (Conv2D) (None, 1, 1, 512) 524800 conv4_block6_out[0][0] \n", 514 | "__________________________________________________________________________________________________\n", 515 | "conv5_block1_1_bn (BatchNormali (None, 1, 1, 512) 2048 conv5_block1_1_conv[0][0] \n", 516 | "__________________________________________________________________________________________________\n", 517 | "conv5_block1_1_relu (Activation (None, 1, 1, 512) 0 conv5_block1_1_bn[0][0] \n", 518 | "__________________________________________________________________________________________________\n", 519 | "conv5_block1_2_conv (Conv2D) (None, 1, 1, 512) 2359808 conv5_block1_1_relu[0][0] \n", 520 | "__________________________________________________________________________________________________\n", 521 | "conv5_block1_2_bn (BatchNormali (None, 1, 1, 512) 2048 conv5_block1_2_conv[0][0] \n", 522 | "__________________________________________________________________________________________________\n", 523 | "conv5_block1_2_relu (Activation (None, 1, 1, 512) 0 conv5_block1_2_bn[0][0] \n", 524 | "__________________________________________________________________________________________________\n", 525 | "conv5_block1_0_conv (Conv2D) (None, 1, 1, 2048) 2099200 conv4_block6_out[0][0] \n", 526 | "__________________________________________________________________________________________________\n", 527 | "conv5_block1_3_conv (Conv2D) (None, 1, 1, 2048) 1050624 conv5_block1_2_relu[0][0] \n", 528 | "__________________________________________________________________________________________________\n", 529 | "conv5_block1_0_bn (BatchNormali (None, 1, 1, 2048) 8192 conv5_block1_0_conv[0][0] \n", 530 | "__________________________________________________________________________________________________\n", 531 | "conv5_block1_3_bn (BatchNormali (None, 1, 1, 2048) 8192 conv5_block1_3_conv[0][0] \n", 532 | "__________________________________________________________________________________________________\n", 533 | "conv5_block1_add (Add) (None, 1, 1, 2048) 0 conv5_block1_0_bn[0][0] \n", 534 | " conv5_block1_3_bn[0][0] \n", 535 | "__________________________________________________________________________________________________\n", 536 | "conv5_block1_out (Activation) (None, 1, 1, 2048) 0 conv5_block1_add[0][0] \n", 537 | "__________________________________________________________________________________________________\n", 538 | "conv5_block2_1_conv (Conv2D) (None, 1, 1, 512) 1049088 conv5_block1_out[0][0] \n", 539 | "__________________________________________________________________________________________________\n", 540 | "conv5_block2_1_bn (BatchNormali (None, 1, 1, 512) 2048 conv5_block2_1_conv[0][0] \n", 541 | "__________________________________________________________________________________________________\n", 542 | "conv5_block2_1_relu (Activation (None, 1, 1, 512) 0 conv5_block2_1_bn[0][0] \n", 543 | "__________________________________________________________________________________________________\n", 544 | "conv5_block2_2_conv (Conv2D) (None, 1, 1, 512) 2359808 conv5_block2_1_relu[0][0] \n", 545 | "__________________________________________________________________________________________________\n", 546 | "conv5_block2_2_bn (BatchNormali (None, 1, 1, 512) 2048 conv5_block2_2_conv[0][0] \n", 547 | "__________________________________________________________________________________________________\n", 548 | "conv5_block2_2_relu (Activation (None, 1, 1, 512) 0 conv5_block2_2_bn[0][0] \n", 549 | "__________________________________________________________________________________________________\n", 550 | "conv5_block2_3_conv (Conv2D) (None, 1, 1, 2048) 1050624 conv5_block2_2_relu[0][0] \n", 551 | "__________________________________________________________________________________________________\n", 552 | "conv5_block2_3_bn (BatchNormali (None, 1, 1, 2048) 8192 conv5_block2_3_conv[0][0] \n", 553 | "__________________________________________________________________________________________________\n", 554 | "conv5_block2_add (Add) (None, 1, 1, 2048) 0 conv5_block1_out[0][0] \n", 555 | " conv5_block2_3_bn[0][0] \n", 556 | "__________________________________________________________________________________________________\n", 557 | "conv5_block2_out (Activation) (None, 1, 1, 2048) 0 conv5_block2_add[0][0] \n", 558 | "__________________________________________________________________________________________________\n", 559 | "conv5_block3_1_conv (Conv2D) (None, 1, 1, 512) 1049088 conv5_block2_out[0][0] \n", 560 | "__________________________________________________________________________________________________\n", 561 | "conv5_block3_1_bn (BatchNormali (None, 1, 1, 512) 2048 conv5_block3_1_conv[0][0] \n", 562 | "__________________________________________________________________________________________________\n", 563 | "conv5_block3_1_relu (Activation (None, 1, 1, 512) 0 conv5_block3_1_bn[0][0] \n", 564 | "__________________________________________________________________________________________________\n", 565 | "conv5_block3_2_conv (Conv2D) (None, 1, 1, 512) 2359808 conv5_block3_1_relu[0][0] \n", 566 | "__________________________________________________________________________________________________\n", 567 | "conv5_block3_2_bn (BatchNormali (None, 1, 1, 512) 2048 conv5_block3_2_conv[0][0] \n", 568 | "__________________________________________________________________________________________________\n", 569 | "conv5_block3_2_relu (Activation (None, 1, 1, 512) 0 conv5_block3_2_bn[0][0] \n", 570 | "__________________________________________________________________________________________________\n", 571 | "conv5_block3_3_conv (Conv2D) (None, 1, 1, 2048) 1050624 conv5_block3_2_relu[0][0] \n", 572 | "__________________________________________________________________________________________________\n", 573 | "conv5_block3_3_bn (BatchNormali (None, 1, 1, 2048) 8192 conv5_block3_3_conv[0][0] \n", 574 | "__________________________________________________________________________________________________\n", 575 | "conv5_block3_add (Add) (None, 1, 1, 2048) 0 conv5_block2_out[0][0] \n", 576 | " conv5_block3_3_bn[0][0] \n", 577 | "__________________________________________________________________________________________________\n", 578 | "conv5_block3_out (Activation) (None, 1, 1, 2048) 0 conv5_block3_add[0][0] \n", 579 | "__________________________________________________________________________________________________\n", 580 | "avg_pool (GlobalAveragePooling2 (None, 2048) 0 conv5_block3_out[0][0] \n", 581 | "==================================================================================================\n", 582 | "Total params: 23,587,712\n", 583 | "Trainable params: 23,534,592\n", 584 | "Non-trainable params: 53,120\n", 585 | "__________________________________________________________________________________________________\n" 586 | ], 587 | "name": "stdout" 588 | } 589 | ] 590 | }, 591 | { 592 | "cell_type": "code", 593 | "metadata": { 594 | "colab": { 595 | "base_uri": "https://localhost:8080/" 596 | }, 597 | "id": "JTVzf85zd6fF", 598 | "outputId": "bf1822ea-43ab-4694-ba10-3338babdf12e" 599 | }, 600 | "source": [ 601 | "# defining the model for transfer learning with 10 different output classes \n", 602 | "num_classes = 10\n", 603 | "model_resnet.trainable = False # freezing the weights in model_resnet (these weights will not be updated during training)\n", 604 | "inputs = Input(shape=(32,32,3))\n", 605 | "x = model_resnet(inputs, training=False)\n", 606 | "outputs = Dense(units=num_classes, activation='softmax')(x)\n", 607 | "model = Model(inputs=inputs, outputs=outputs)\n", 608 | "model.summary()" 609 | ], 610 | "execution_count": 10, 611 | "outputs": [ 612 | { 613 | "output_type": "stream", 614 | "text": [ 615 | "Model: \"model\"\n", 616 | "_________________________________________________________________\n", 617 | "Layer (type) Output Shape Param # \n", 618 | "=================================================================\n", 619 | "input_2 (InputLayer) [(None, 32, 32, 3)] 0 \n", 620 | "_________________________________________________________________\n", 621 | "resnet50 (Functional) (None, 2048) 23587712 \n", 622 | "_________________________________________________________________\n", 623 | "dense (Dense) (None, 10) 20490 \n", 624 | "=================================================================\n", 625 | "Total params: 23,608,202\n", 626 | "Trainable params: 20,490\n", 627 | "Non-trainable params: 23,587,712\n", 628 | "_________________________________________________________________\n" 629 | ], 630 | "name": "stdout" 631 | } 632 | ] 633 | }, 634 | { 635 | "cell_type": "code", 636 | "metadata": { 637 | "id": "k7gT0FjofIFf" 638 | }, 639 | "source": [ 640 | "# compiling the model \n", 641 | "model.compile(loss='sparse_categorical_crossentropy', optimizer='adam', metrics='accuracy')" 642 | ], 643 | "execution_count": 11, 644 | "outputs": [] 645 | }, 646 | { 647 | "cell_type": "code", 648 | "metadata": { 649 | "colab": { 650 | "base_uri": "https://localhost:8080/" 651 | }, 652 | "id": "DaU1wI1gfQ3O", 653 | "outputId": "879d7cae-38a3-46dd-af9e-582c19776065" 654 | }, 655 | "source": [ 656 | "# training the model \n", 657 | "H = model.fit(x_train_pp, y_train, validation_split=0.1, epochs=10, verbose=2)" 658 | ], 659 | "execution_count": 12, 660 | "outputs": [ 661 | { 662 | "output_type": "stream", 663 | "text": [ 664 | "Epoch 1/10\n", 665 | "1407/1407 - 69s - loss: 1.5887 - accuracy: 0.5685 - val_loss: 1.3398 - val_accuracy: 0.6276\n", 666 | "Epoch 2/10\n", 667 | "1407/1407 - 34s - loss: 1.2304 - accuracy: 0.6419 - val_loss: 1.3710 - val_accuracy: 0.6300\n", 668 | "Epoch 3/10\n", 669 | "1407/1407 - 34s - loss: 1.1648 - accuracy: 0.6585 - val_loss: 1.3614 - val_accuracy: 0.6254\n", 670 | "Epoch 4/10\n", 671 | "1407/1407 - 34s - loss: 1.1258 - accuracy: 0.6690 - val_loss: 1.4487 - val_accuracy: 0.6216\n", 672 | "Epoch 5/10\n", 673 | "1407/1407 - 34s - loss: 1.1015 - accuracy: 0.6775 - val_loss: 1.4542 - val_accuracy: 0.6178\n", 674 | "Epoch 6/10\n", 675 | "1407/1407 - 34s - loss: 1.1143 - accuracy: 0.6785 - val_loss: 1.4831 - val_accuracy: 0.6294\n", 676 | "Epoch 7/10\n", 677 | "1407/1407 - 34s - loss: 1.0876 - accuracy: 0.6824 - val_loss: 1.4893 - val_accuracy: 0.6412\n", 678 | "Epoch 8/10\n", 679 | "1407/1407 - 34s - loss: 1.0887 - accuracy: 0.6838 - val_loss: 1.6309 - val_accuracy: 0.6074\n", 680 | "Epoch 9/10\n", 681 | "1407/1407 - 34s - loss: 1.0838 - accuracy: 0.6880 - val_loss: 1.5115 - val_accuracy: 0.6274\n", 682 | "Epoch 10/10\n", 683 | "1407/1407 - 34s - loss: 1.0830 - accuracy: 0.6887 - val_loss: 1.5944 - val_accuracy: 0.6218\n" 684 | ], 685 | "name": "stdout" 686 | } 687 | ] 688 | }, 689 | { 690 | "cell_type": "code", 691 | "metadata": { 692 | "colab": { 693 | "base_uri": "https://localhost:8080/", 694 | "height": 581 695 | }, 696 | "id": "P5dxn52RfdEL", 697 | "outputId": "e295538f-5262-46e3-c05c-38865247f8b9" 698 | }, 699 | "source": [ 700 | "# plotting the training and validation set loss and accuracy results\n", 701 | "plt.style.use('ggplot')\n", 702 | "plt.figure()\n", 703 | "num_epochs=10\n", 704 | "epochs = np.arange(num_epochs)\n", 705 | "train_loss = H.history['loss']\n", 706 | "val_loss = H.history['val_loss']\n", 707 | "plt.plot(epochs, train_loss, label='train loss')\n", 708 | "plt.plot(epochs, val_loss, label='val_loss')\n", 709 | "plt.title('training and testing loss')\n", 710 | "plt.legend()\n", 711 | "plt.xlabel('#epochs')\n", 712 | "plt.ylabel('loss')\n", 713 | "\n", 714 | "plt.figure()\n", 715 | "train_acc = H.history['accuracy']\n", 716 | "val_acc = H.history['val_accuracy']\n", 717 | "plt.plot(epochs, train_acc, label='train accuracy')\n", 718 | "plt.plot(epochs, val_acc, label='val_accuracy')\n", 719 | "plt.title('training and testing accuracy')\n", 720 | "plt.legend()\n", 721 | "plt.xlabel('#epochs')\n", 722 | "plt.ylabel('accuracy')\n", 723 | "\n", 724 | "plt.show()\n" 725 | ], 726 | "execution_count": 16, 727 | "outputs": [ 728 | { 729 | "output_type": "display_data", 730 | "data": { 731 | "image/png": "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\n", 732 | "text/plain": [ 733 | "
" 734 | ] 735 | }, 736 | "metadata": { 737 | "tags": [] 738 | } 739 | }, 740 | { 741 | "output_type": "display_data", 742 | "data": { 743 | "image/png": "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\n", 744 | "text/plain": [ 745 | "
" 746 | ] 747 | }, 748 | "metadata": { 749 | "tags": [] 750 | } 751 | } 752 | ] 753 | }, 754 | { 755 | "cell_type": "code", 756 | "metadata": { 757 | "colab": { 758 | "base_uri": "https://localhost:8080/" 759 | }, 760 | "id": "nMBd-COFf_yI", 761 | "outputId": "8cef5860-2e2b-4b8e-b3bb-d780e7962fd7" 762 | }, 763 | "source": [ 764 | "# evaluating the model on the test set \n", 765 | "model.evaluate(x_test_pp, y_test)" 766 | ], 767 | "execution_count": 17, 768 | "outputs": [ 769 | { 770 | "output_type": "stream", 771 | "text": [ 772 | "313/313 [==============================] - 8s 26ms/step - loss: 1.6533 - accuracy: 0.6125\n" 773 | ], 774 | "name": "stdout" 775 | }, 776 | { 777 | "output_type": "execute_result", 778 | "data": { 779 | "text/plain": [ 780 | "[1.653288722038269, 0.612500011920929]" 781 | ] 782 | }, 783 | "metadata": { 784 | "tags": [] 785 | }, 786 | "execution_count": 17 787 | } 788 | ] 789 | } 790 | ] 791 | } -------------------------------------------------------------------------------- /TransferLearningResnet/cifar10_img.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/TransferLearningResnet/cifar10_img.png -------------------------------------------------------------------------------- /VideoActivityRecognition3DResnet/Readme.md: -------------------------------------------------------------------------------- 1 | # Performing activity recognition in videos using a pre-trained 3D ResNet model 2 | 1. Pre-trained model used for recognition is from https://github.com/kenshohara 3 | 2. Model can recognize 400 different activities 4 | 3. Running the code notebook requires 3 files - pretrained model file, class names text file, sample video file . These files are automatically downloaded from my google drive on running the associated ipynb code file 5 | 4. Link to medium blog post with more details 6 | 7 | ![Image snapshot for Video Activity Recognition](img_activity_recognition.jpg) 8 | 9 | ## Programming language and Libraries used 10 | 1. Python programming language 11 | 2. OpenCV library 12 | 3. Other Python libraries including numpy, etc 13 | 14 | -------------------------------------------------------------------------------- /VideoActivityRecognition3DResnet/img_activity_recognition.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/vasugupta9/DeepLearningProjects/f6396195d04cf91b59d1b78bddac27ba0a607119/VideoActivityRecognition3DResnet/img_activity_recognition.jpg --------------------------------------------------------------------------------