From afaff4742f8bd27bb6532631f2b7927c754a2736 Mon Sep 17 00:00:00 2001
From: Shaik Arshid Banu <arshidbanushaik@gmail.com>
Date: Fri, 31 May 2024 23:16:20 +0530
Subject: [PATCH] Transfer Learning with VGG16 and ResNet

---
 .../Readme.md                                 |  80 ++++
 ...nsfer_Learning_with_VGG16_and_ResNet.ipynb | 451 ++++++++++++++++++
 2 files changed, 531 insertions(+)
 create mode 100644 Transfer Learning with VGG16 and ResNet/Readme.md
 create mode 100644 Transfer Learning with VGG16 and ResNet/Transfer_Learning_with_VGG16_and_ResNet.ipynb

diff --git a/Transfer Learning with VGG16 and ResNet/Readme.md b/Transfer Learning with VGG16 and ResNet/Readme.md
new file mode 100644
index 000000000..3d3e7f32b
--- /dev/null
+++ b/Transfer Learning with VGG16 and ResNet/Readme.md	
@@ -0,0 +1,80 @@
+# Transfer Learning with VGG16 for Image Classification and Feature Extraction
+
+## Overview
+
+This project demonstrates the use of transfer learning to improve model performance on image classification tasks with limited training data. We leverage the pre-trained VGG16 model and show how to fine-tune this model and use it for feature extraction. The project includes a detailed Jupyter notebook that walks through each step of the process, including data preparation, model fine-tuning, feature extraction, training, and performance evaluation.
+
+## Table of Contents
+
+- [Introduction](#introduction)
+- [Model Used](#model-used)
+  - [VGG16](#vgg16)
+- [Activation Functions](#activation-functions)
+  - [tanh](#tanh)
+  - [softmax](#softmax)
+- [Loss Function](#loss-function)
+  - [Categorical Crossentropy](#categorical-crossentropy)
+- [Why Use Transfer Learning?](#why-use-transfer-learning)
+- [Visualization and Performance Comparison](#visualization-and-performance-comparison)
+- [Conclusion](#conclusion)
+
+
+## Introduction
+
+Transfer learning is a machine learning technique where a model developed for a specific task is reused as the starting point for a model on a second task. It is particularly useful when dealing with limited data, as it leverages the knowledge gained from large datasets used to train the pre-trained models. In this project, we will use transfer learning to fine-tune the VGG16 model for image classification tasks and demonstrate feature extraction using this model.
+
+
+## Model Used
+
+### VGG16
+
+VGG16 is a convolutional neural network model proposed by K. Simonyan and A. Zisserman from the University of Oxford in the paper "Very Deep Convolutional Networks for Large-Scale Image Recognition". VGG16 is characterized by its simplicity, using only 3x3 convolutional layers stacked on top of each other in increasing depth. The architecture consists of 16 layers, including convolutional layers, max-pooling layers, and fully connected layers.
+
+## Why VGG16?
+
+Proven Performance: VGG16 has demonstrated excellent performance on various image classification tasks.
+Simplicity: Its architecture is simple and straightforward, making it easy to understand and implement.
+Pre-trained Weights: Available pre-trained weights on ImageNet can be used to leverage prior knowledge.
+
+## Activation Functions
+
+### tanh
+The tanh (hyperbolic tangent) activation function outputs values between -1 and 1. It is a scaled version of the sigmoid activation function and is used to introduce non-linearity into the model.
+
+### Why tanh?
+
+Centered Output: The output is zero-centered, which can help in convergence during training.
+Saturated Gradients: It suffers from the vanishing gradient problem but to a lesser extent than the sigmoid function.
+softmax
+The softmax activation function is used in the output layer of a neural network model for multi-class classification problems. It outputs a probability distribution over classes.
+
+### Why softmax?
+
+Probability Distribution: Outputs probabilities that sum up to 1, making it useful for multi-class classification.
+
+## Loss Function
+
+### Categorical Crossentropy
+
+Categorical Crossentropy is a loss function used for multi-class classification problems where the target class is one-hot encoded.
+
+### Why Categorical Crossentropy?
+
+Direct Probability Handling: It directly handles the output probabilities of the softmax function.
+Standard for Classification: It is the standard loss function for multi-class classification problems.
+
+## Why Use Transfer Learning?
+
+### Transfer learning offers several advantages:
+
+Improved Performance: Models pre-trained on large datasets like ImageNet have already learned useful features that can be transferred to new tasks.
+Reduced Training Time: Fine-tuning a pre-trained model requires less time than training a model from scratch.
+Less Data Required: Transfer learning is particularly effective when you have limited data for the new task.
+
+## Visualization and Performance Comparison
+
+The notebook includes code to visualize the training process and compare the performance of the models. Performance metrics such as accuracy and loss are plotted to provide insights into how well the models are learning and generalizing.
+
+## Conclusion
+
+This project demonstrates the power of transfer learning using pre-trained models like VGG16 for image classification and feature extraction. By leveraging the knowledge from large datasets, we can achieve better performance with less data and reduced training time. The detailed Jupyter notebook provides an interactive learning experience, helping users understand and implement these advanced techniques in their projects.
\ No newline at end of file
diff --git a/Transfer Learning with VGG16 and ResNet/Transfer_Learning_with_VGG16_and_ResNet.ipynb b/Transfer Learning with VGG16 and ResNet/Transfer_Learning_with_VGG16_and_ResNet.ipynb
new file mode 100644
index 000000000..1f34cb13b
--- /dev/null
+++ b/Transfer Learning with VGG16 and ResNet/Transfer_Learning_with_VGG16_and_ResNet.ipynb	
@@ -0,0 +1,451 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": []
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## **Transfer Learning with VGG16 and ResNet for Image Classification and Feature Extraction**"
+      ],
+      "metadata": {
+        "id": "_ULyo-_Ee7zH"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "###**Introduction**                                                                              \n",
+        "In this notebook, we will demonstrate how to use transfer learning to improve model performance for image classification tasks with limited training data. We will leverage pre-trained models such as VGG16 and ResNet, and show how to fine-tune these models and use them for feature extraction."
+      ],
+      "metadata": {
+        "id": "zvYqPU45fE04"
+      }
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Prerequisites**\n",
+        "\n",
+        "Before we begin, make sure you have the necessary libraries installed:"
+      ],
+      "metadata": {
+        "id": "pmetmSMSgRYF"
+      }
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "collapsed": true,
+        "id": "QSSKQUoDe5Nr",
+        "outputId": "a3f6e8ee-092a-4f9e-d1d5-fd449ec7610f"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: tensorflow in /usr/local/lib/python3.10/dist-packages (2.15.0)\n",
+            "Requirement already satisfied: keras in /usr/local/lib/python3.10/dist-packages (2.15.0)\n",
+            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n",
+            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.7.1)\n",
+            "Requirement already satisfied: absl-py>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.4.0)\n",
+            "Requirement already satisfied: astunparse>=1.6.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.6.3)\n",
+            "Requirement already satisfied: flatbuffers>=23.5.26 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (24.3.25)\n",
+            "Requirement already satisfied: gast!=0.5.0,!=0.5.1,!=0.5.2,>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.5.4)\n",
+            "Requirement already satisfied: google-pasta>=0.1.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.2.0)\n",
+            "Requirement already satisfied: h5py>=2.9.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.9.0)\n",
+            "Requirement already satisfied: libclang>=13.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (18.1.1)\n",
+            "Requirement already satisfied: ml-dtypes~=0.2.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.2.0)\n",
+            "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.3.0)\n",
+            "Requirement already satisfied: packaging in /usr/local/lib/python3.10/dist-packages (from tensorflow) (24.0)\n",
+            "Requirement already satisfied: protobuf!=4.21.0,!=4.21.1,!=4.21.2,!=4.21.3,!=4.21.4,!=4.21.5,<5.0.0dev,>=3.20.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (3.20.3)\n",
+            "Requirement already satisfied: setuptools in /usr/local/lib/python3.10/dist-packages (from tensorflow) (67.7.2)\n",
+            "Requirement already satisfied: six>=1.12.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.16.0)\n",
+            "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.4.0)\n",
+            "Requirement already satisfied: typing-extensions>=3.6.6 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (4.11.0)\n",
+            "Requirement already satisfied: wrapt<1.15,>=1.11.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.14.1)\n",
+            "Requirement already satisfied: tensorflow-io-gcs-filesystem>=0.23.1 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (0.37.0)\n",
+            "Requirement already satisfied: grpcio<2.0,>=1.24.3 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (1.64.0)\n",
+            "Requirement already satisfied: tensorboard<2.16,>=2.15 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.15.2)\n",
+            "Requirement already satisfied: tensorflow-estimator<2.16,>=2.15.0 in /usr/local/lib/python3.10/dist-packages (from tensorflow) (2.15.0)\n",
+            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.2.1)\n",
+            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n",
+            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.51.0)\n",
+            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.5)\n",
+            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (9.4.0)\n",
+            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.1.2)\n",
+            "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (2.8.2)\n",
+            "Requirement already satisfied: wheel<1.0,>=0.23.0 in /usr/local/lib/python3.10/dist-packages (from astunparse>=1.6.0->tensorflow) (0.43.0)\n",
+            "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow) (2.27.0)\n",
+            "Requirement already satisfied: google-auth-oauthlib<2,>=0.5 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow) (1.2.0)\n",
+            "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow) (3.6)\n",
+            "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow) (2.31.0)\n",
+            "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow) (0.7.2)\n",
+            "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard<2.16,>=2.15->tensorflow) (3.0.3)\n",
+            "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (5.3.3)\n",
+            "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (0.4.0)\n",
+            "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (4.9)\n",
+            "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from google-auth-oauthlib<2,>=0.5->tensorboard<2.16,>=2.15->tensorflow) (1.3.1)\n",
+            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (3.3.2)\n",
+            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (3.7)\n",
+            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (2.0.7)\n",
+            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard<2.16,>=2.15->tensorflow) (2024.2.2)\n",
+            "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard<2.16,>=2.15->tensorflow) (2.1.5)\n",
+            "Requirement already satisfied: pyasn1<0.7.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard<2.16,>=2.15->tensorflow) (0.6.0)\n",
+            "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<2,>=0.5->tensorboard<2.16,>=2.15->tensorflow) (3.2.2)\n"
+          ]
+        }
+      ],
+      "source": [
+        "!pip install tensorflow keras numpy matplotlib\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Loading the Required Libraries**\n",
+        "\n",
+        "First, let's import the necessary libraries."
+      ],
+      "metadata": {
+        "id": "fwrh6KqbgpIx"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import tensorflow as tf\n",
+        "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
+        "from tensorflow.keras.applications import VGG16, ResNet50\n",
+        "from tensorflow.keras.models import Model\n",
+        "from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Flatten, Dropout\n",
+        "from tensorflow.keras.optimizers import RMSprop\n",
+        "from tensorflow.keras.optimizers import Adam\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt\n"
+      ],
+      "metadata": {
+        "id": "OCP_AvCcgtDP"
+      },
+      "execution_count": 10,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Data Preparation**\n",
+        "\n",
+        "We will use a sample dataset. For demonstration purposes, you can use any dataset such as CIFAR-10, or a custom dataset stored locally."
+      ],
+      "metadata": {
+        "id": "odMdg7XVhC7B"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Load CIFAR-10 dataset\n",
+        "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()\n",
+        "\n",
+        "# Normalize the data\n",
+        "x_train, x_test = x_train / 255.0, x_test / 255.0\n",
+        "\n",
+        "# Convert labels to one-hot encoding\n",
+        "y_train_one_hot = tf.keras.utils.to_categorical(y_train, 10)\n",
+        "y_test_one_hot = tf.keras.utils.to_categorical(y_test, 10)\n",
+        "\n",
+        "# Define data generators for data augmentation\n",
+        "train_datagen = ImageDataGenerator(rotation_range=20, width_shift_range=0.2, height_shift_range=0.2, horizontal_flip=True)\n",
+        "test_datagen = ImageDataGenerator()\n",
+        "\n",
+        "train_generator = train_datagen.flow(x_train, y_train_one_hot, batch_size=32)\n",
+        "test_generator = test_datagen.flow(x_test, y_test_one_hot, batch_size=32)\n"
+      ],
+      "metadata": {
+        "id": "Rl6pLAI5hHJ4",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "936a086a-75db-45fe-bf74-45593fae622d"
+      },
+      "execution_count": 4,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n",
+            "170498071/170498071 [==============================] - 4s 0us/step\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Fine-Tuning a Pre-Trained Model (VGG16)**\n",
+        "\n",
+        "We will fine-tune the VGG16 model for our dataset."
+      ],
+      "metadata": {
+        "id": "crwKZNCOhYMB"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Load the VGG16 model with pre-trained weights, excluding the top classification layer\n",
+        "base_model_vgg = VGG16(weights='imagenet', include_top=False, input_shape=(32, 32, 3))\n",
+        "\n",
+        "# Freeze the layers of the base model\n",
+        "for layer in base_model_vgg.layers:\n",
+        "    layer.trainable = False\n",
+        "\n",
+        "# Add new classification layers\n",
+        "x = base_model_vgg.output\n",
+        "x = GlobalAveragePooling2D()(x)\n",
+        "x = Dense(1024, activation='tanh')(x)\n",
+        "predictions = Dense(10, activation='softmax')(x)\n",
+        "\n",
+        "# Create the final model\n",
+        "model_vgg = Model(inputs=base_model_vgg.input, outputs=predictions)\n",
+        "\n",
+        "# Compile the model\n",
+        "model_vgg.compile(optimizer=RMSprop(), loss='categorical_crossentropy', metrics=['accuracy'])\n",
+        "\n",
+        "# Train the model\n",
+        "history_vgg = model_vgg.fit(train_generator, epochs=10, validation_data=test_generator)\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lV9B8PAGhbfv",
+        "outputId": "7409aec9-b520-437f-9530-5478e7c75804"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
+            "58889256/58889256 [==============================] - 0s 0us/step\n",
+            "Epoch 1/10\n",
+            "1563/1563 [==============================] - 778s 497ms/step - loss: 1.5836 - accuracy: 0.4408 - val_loss: 1.3754 - val_accuracy: 0.5131\n",
+            "Epoch 2/10\n",
+            "1563/1563 [==============================] - 771s 494ms/step - loss: 1.4596 - accuracy: 0.4847 - val_loss: 1.3454 - val_accuracy: 0.5281\n",
+            "Epoch 3/10\n",
+            "1563/1563 [==============================] - 768s 491ms/step - loss: 1.4252 - accuracy: 0.4985 - val_loss: 1.3058 - val_accuracy: 0.5413\n",
+            "Epoch 4/10\n",
+            "1563/1563 [==============================] - 766s 490ms/step - loss: 1.4070 - accuracy: 0.5047 - val_loss: 1.3920 - val_accuracy: 0.5114\n",
+            "Epoch 5/10\n",
+            "1563/1563 [==============================] - 766s 490ms/step - loss: 1.3782 - accuracy: 0.5102 - val_loss: 1.2762 - val_accuracy: 0.5506\n",
+            "Epoch 6/10\n",
+            "1563/1563 [==============================] - 788s 505ms/step - loss: 1.3709 - accuracy: 0.5146 - val_loss: 1.3276 - val_accuracy: 0.5336\n",
+            "Epoch 7/10\n",
+            "1563/1563 [==============================] - 767s 491ms/step - loss: 1.3490 - accuracy: 0.5240 - val_loss: 1.2873 - val_accuracy: 0.5505\n",
+            "Epoch 8/10\n",
+            "1563/1563 [==============================] - 764s 489ms/step - loss: 1.3445 - accuracy: 0.5219 - val_loss: 1.2730 - val_accuracy: 0.5494\n",
+            "Epoch 9/10\n",
+            "1563/1563 [==============================] - 762s 487ms/step - loss: 1.3327 - accuracy: 0.5277 - val_loss: 1.2562 - val_accuracy: 0.5496\n",
+            "Epoch 10/10\n",
+            "1563/1563 [==============================] - 793s 508ms/step - loss: 1.3241 - accuracy: 0.5304 - val_loss: 1.2274 - val_accuracy: 0.5659\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Feature Extraction Using a Pre-Trained Model (ResNet50)**\n",
+        "\n",
+        "Next, we will use ResNet50 for feature extraction."
+      ],
+      "metadata": {
+        "id": "M90jv4Bzh6P6"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Load the ResNet50 model with pre-trained weights, excluding the top classification layer\n",
+        "base_model_resnet = ResNet50(weights='imagenet', include_top=False, input_shape=(32, 32, 3))\n",
+        "\n",
+        "# Freeze the layers of the base model\n",
+        "for layer in base_model_resnet.layers:\n",
+        "    layer.trainable = False\n",
+        "\n",
+        "# Add new classification layers\n",
+        "x = base_model_resnet.output\n",
+        "x = GlobalAveragePooling2D()(x)\n",
+        "x = Dense(1024, activation='relu')(x)\n",
+        "x = Dropout(0.5)(x)\n",
+        "predictions = Dense(10, activation='softmax')(x)\n",
+        "\n",
+        "# Create the final model\n",
+        "model_resnet = Model(inputs=base_model_resnet.input, outputs=predictions)\n",
+        "\n",
+        "# Compile the model\n",
+        "model_resnet.compile(optimizer=RMSprop(), loss='categorical_crossentropy', metrics=['accuracy'])\n",
+        "\n",
+        "# Train the model\n",
+        "history_resnet = model_resnet.fit(train_generator, epochs=10, validation_data=test_generator)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HaCC6bD4h9n2",
+        "outputId": "e4b2cd7c-b9b1-4313-eb51-12680da1329e"
+      },
+      "execution_count": 11,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/10\n",
+            "1563/1563 [==============================] - 399s 216ms/step - loss: 2.3124 - accuracy: 0.1268 - val_loss: 2.1978 - val_accuracy: 0.1890\n",
+            "Epoch 2/10\n",
+            "1563/1563 [==============================] - 336s 215ms/step - loss: 2.2210 - accuracy: 0.1522 - val_loss: 2.1504 - val_accuracy: 0.2190\n",
+            "Epoch 3/10\n",
+            "1563/1563 [==============================] - 351s 225ms/step - loss: 2.2009 - accuracy: 0.1600 - val_loss: 2.1116 - val_accuracy: 0.2440\n",
+            "Epoch 4/10\n",
+            "1563/1563 [==============================] - 337s 216ms/step - loss: 2.1878 - accuracy: 0.1708 - val_loss: 2.0606 - val_accuracy: 0.2613\n",
+            "Epoch 5/10\n",
+            "1563/1563 [==============================] - 333s 213ms/step - loss: 2.1761 - accuracy: 0.1758 - val_loss: 2.0093 - val_accuracy: 0.2715\n",
+            "Epoch 6/10\n",
+            "1563/1563 [==============================] - 333s 213ms/step - loss: 2.1657 - accuracy: 0.1839 - val_loss: 2.0631 - val_accuracy: 0.2587\n",
+            "Epoch 7/10\n",
+            "1563/1563 [==============================] - 330s 211ms/step - loss: 2.1562 - accuracy: 0.1862 - val_loss: 2.0158 - val_accuracy: 0.2859\n",
+            "Epoch 8/10\n",
+            "1563/1563 [==============================] - 333s 213ms/step - loss: 2.1567 - accuracy: 0.1906 - val_loss: 1.9893 - val_accuracy: 0.2809\n",
+            "Epoch 9/10\n",
+            "1563/1563 [==============================] - 332s 212ms/step - loss: 2.1509 - accuracy: 0.1889 - val_loss: 1.9794 - val_accuracy: 0.2868\n",
+            "Epoch 10/10\n",
+            "1563/1563 [==============================] - 329s 211ms/step - loss: 2.1472 - accuracy: 0.1932 - val_loss: 2.0226 - val_accuracy: 0.2536\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Visualization and Performance Comparison**\n",
+        "\n",
+        "Let's visualize the training process and compare the performance of the models."
+      ],
+      "metadata": {
+        "id": "FXidOWIPiBge"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Plot training & validation accuracy values for VGG16 fine-tuning\n",
+        "plt.figure(figsize=(12, 4))\n",
+        "\n",
+        "plt.subplot(1, 2, 1)\n",
+        "plt.plot(history_vgg.history['accuracy'])\n",
+        "plt.plot(history_vgg.history['val_accuracy'])\n",
+        "plt.title('Model accuracy (VGG16 Fine-Tuning)')\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "# Plot training & validation loss values for VGG16 fine-tuning\n",
+        "plt.subplot(1, 2, 2)\n",
+        "plt.plot(history_vgg.history['loss'])\n",
+        "plt.plot(history_vgg.history['val_loss'])\n",
+        "plt.title('Model loss (VGG16 Fine-Tuning)')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "plt.show()\n",
+        "\n",
+        "# Plot training & validation accuracy values for Feature Extraction Using a Pre-Trained Model (ResNet50)\n",
+        "plt.figure(figsize=(12, 4))\n",
+        "\n",
+        "plt.subplot(1, 2, 1)\n",
+        "plt.plot(history_resnet.history['accuracy'])\n",
+        "plt.plot(history_resnet.history['val_accuracy'])\n",
+        "plt.title('Model accuracy (Using Feature Extraction ResNet50)')\n",
+        "plt.ylabel('Accuracy')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "# Plot training & validation loss values for Feature Extraction Using a Pre-Trained Model (ResNet50)\n",
+        "plt.subplot(1, 2, 2)\n",
+        "plt.plot(history_resnet.history['loss'])\n",
+        "plt.plot(history_resnet.history['val_loss'])\n",
+        "plt.title('Model loss (Using Feature Extraction ResNet50)')\n",
+        "plt.ylabel('Loss')\n",
+        "plt.xlabel('Epoch')\n",
+        "plt.legend(['Train', 'Test'], loc='upper left')\n",
+        "\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "id": "fMslCKUbiHkF",
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 803
+        },
+        "outputId": "10c7f5c7-16f1-4811-b414-38080f3b5446"
+      },
+      "execution_count": 17,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x400 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x400 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "**Conclusion**\n",
+        "\n",
+        "In this notebook, we demonstrated how to fine-tune a pre-trained VGG16 model and how to use ResNet50 for feature extraction to improve performance on a new dataset with limited data. Transfer learning significantly enhances model performance compared to training from scratch by leveraging the knowledge gained from large datasets used to train the pre-trained models.\n",
+        "\n"
+      ],
+      "metadata": {
+        "id": "KhQ5OQdTinXs"
+      }
+    }
+  ]
+}
\ No newline at end of file