LogoDetection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b309c980",
   "metadata": {},
   "source": [
    "## Importing Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9c6ebabc",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\patel\\anaconda3\\lib\\site-packages\\scipy\\__init__.py:146: UserWarning: A NumPy version >=1.16.5 and <1.23.0 is required for this version of SciPy (detected version 1.26.1\n",
      "  warnings.warn(f\"A NumPy version >={np_minversion} and <{np_maxversion}\"\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pickle\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import keras\n",
    "import tensorflow as tf\n",
    "from PIL import Image\n",
    "\n",
    "from keras.preprocessing import image\n",
    "from keras.applications.vgg19 import VGG19, preprocess_input\n",
    "from keras.models import Model\n",
    "from keras.layers import Dense, GlobalAveragePooling2D\n",
    "from keras.optimizers import Adam\n",
    "from keras.utils import to_categorical\n",
    "from sklearn.model_selection import train_test_split\n",
    "from tensorflow.keras.utils import plot_model\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.applications import VGG19\n",
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from tensorflow.keras.layers import Input, Lambda, Flatten, Dropout, BatchNormalization, Activation\n",
    "from sklearn.metrics import confusion_matrix, classification_report, accuracy_score, recall_score, precision_score, f1_score\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3568f36",
   "metadata": {},
   "source": [
    "## Data Splitting in Folders"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "06a8db51",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "import random\n",
    "\n",
    "def split_data(input_directory, output_train_directory, output_test_directory, split_ratio=0.8):\n",
    "    \"\"\"\n",
    "    Split data from input_directory into training and test sets.\n",
    "\n",
    "    Args:\n",
    "        input_directory (str): Path to the directory containing subdirectories of class data.\n",
    "        output_train_directory (str): Path to the directory where training data will be stored.\n",
    "        output_test_directory (str): Path to the directory where test data will be stored.\n",
    "        split_ratio (float): Split ratio for training data (default is 0.8 for 80% training and 20% testing).\n",
    "    \"\"\"\n",
    "    # Get a list of all subdirectories in the input directory\n",
    "    subdirectories = [subdir for subdir in os.listdir(input_directory) if os.path.isdir(os.path.join(input_directory, subdir))]\n",
    "    \n",
    "    # Create train and test directories if they don't exist\n",
    "    os.makedirs(output_train_directory, exist_ok=True)\n",
    "    os.makedirs(output_test_directory, exist_ok=True)\n",
    "\n",
    "    for subdir in subdirectories:\n",
    "        subdir_path = os.path.join(input_directory, subdir)\n",
    "        image_files = [filename for filename in os.listdir(subdir_path) if filename.endswith('.jpg')]\n",
    "\n",
    "        # Shuffle the list of image files for randomness\n",
    "        random.shuffle(image_files)\n",
    "\n",
    "        # Calculate the split point\n",
    "        split_point = int(len(image_files) * split_ratio)\n",
    "\n",
    "        # Divide the image files into training and test sets\n",
    "        train_images = image_files[:split_point]\n",
    "        test_images = image_files[split_point:]\n",
    "\n",
    "        # Copy images to the train and test directories\n",
    "        for image in train_images:\n",
    "            source_path = os.path.join(subdir_path, image)\n",
    "            image = 'Fake' +image\n",
    "            destination_path = os.path.join(output_train_directory, subdir, image)\n",
    "            os.makedirs(os.path.dirname(destination_path), exist_ok=True)\n",
    "            shutil.copy(source_path, destination_path)\n",
    "\n",
    "        for image in test_images:\n",
    "            source_path = os.path.join(subdir_path, image)\n",
    "            image = 'Fake' +image\n",
    "            destination_path = os.path.join(output_test_directory, subdir, image)\n",
    "            os.makedirs(os.path.dirname(destination_path), exist_ok=True)\n",
    "            shutil.copy(source_path, destination_path)\n",
    "\n",
    "# Example usage:\n",
    "input_directory = \"D:/Downloads/AI_ML Course/Final Project/genLogoOutput\"  # Directory containing all the image subdirectories\n",
    "output_train_directory = 'C:/Users/satya/Downloads/AIML/Dataset/FakeLogoCategorize/train_data'  # Directory where training images will be stored\n",
    "output_test_directory = 'C:/Users/satya/Downloads/AIML/Dataset/FakeLogoCategorize/test_data'  # Directory where test images will be stored\n",
    "\n",
    "split_data(input_directory, output_train_directory, output_test_directory, split_ratio=0.8)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "66938673",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "000004.jpg\n",
      "000003.jpg\n",
      "000004.jpg\n",
      "000001.jpg\n",
      "000002.jpg\n",
      "000001.jpg\n",
      "000001.jpg\n",
      "000003.jpg\n",
      "000004.jpg\n",
      "000001.jpg\n",
      "000002.jpg\n",
      "000005.jpg\n",
      "000002.jpg\n",
      "000002.jpg\n",
      "000003.jpg\n",
      "000003.jpg\n",
      "000003.jpg\n",
      "000003.jpg\n",
      "000005.jpg\n",
      "000002.jpg\n",
      "000003.jpg\n",
      "000002.jpg\n",
      "000003.jpg\n",
      "000004.jpg\n",
      "000005.jpg\n",
      "000001.jpg\n",
      "000003.jpg\n",
      "000002.jpg\n",
      "000003.jpg\n",
      "000005.jpg\n",
      "000001.jpg\n",
      "000002.jpg\n",
      "000001.jpg\n",
      "000001.jpg\n",
      "000001.jpg\n",
      "000001.jpg\n",
      "000004.jpg\n",
      "000004.jpg\n",
      "000002.jpg\n",
      "000001.jpg\n",
      "000005.jpg\n",
      "000003.jpg\n",
      "000004.jpg\n",
      "000005.jpg\n",
      "000004.jpg\n",
      "000001.jpg\n",
      "000001.jpg\n",
      "000002.jpg\n",
      "000004.jpg\n",
      "000005.jpg\n",
      "000005.jpg\n",
      "000004.jpg\n",
      "000001.jpg\n",
      "000003.jpg\n",
      "000004.jpg\n",
      "000004.jpg\n",
      "000005.jpg\n",
      "000002.jpg\n",
      "000002.jpg\n",
      "000004.jpg\n",
      "000002.jpg\n",
      "000004.jpg\n",
      "000005.jpg\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import shutil\n",
    "import random\n",
    "\n",
    "def split_data(input_directory, output_train_directory, output_test_directory, split_ratio=0.8):\n",
    "    \"\"\"\n",
    "    Split data from input_directory into training and test sets.\n",
    "\n",
    "    Args:\n",
    "        input_directory (str): Path to the directory containing subdirectories of class data.\n",
    "        output_train_directory (str): Path to the directory where training data will be stored.\n",
    "        output_test_directory (str): Path to the directory where test data will be stored.\n",
    "        split_ratio (float): Split ratio for training data (default is 0.8 for 80% training and 20% testing).\n",
    "    \"\"\"\n",
    "    # Get a list of all subdirectories in the input directory\n",
    "    subdirectories = [subdir for subdir in os.listdir(input_directory) if os.path.isdir(os.path.join(input_directory, subdir))]\n",
    "    \n",
    "    # Create train and test directories if they don't exist\n",
    "    os.makedirs(output_train_directory, exist_ok=True)\n",
    "    os.makedirs(output_test_directory, exist_ok=True)\n",
    "\n",
    "    for subdir in subdirectories:\n",
    "        subdir_path = os.path.join(input_directory, subdir)\n",
    "        image_files = [filename for filename in os.listdir(subdir_path) if filename.endswith('.jpg')]\n",
    "\n",
    "        # Shuffle the list of image files for randomness\n",
    "        random.shuffle(image_files)\n",
    "\n",
    "        # Calculate the split point\n",
    "        split_point = int(len(image_files) * split_ratio)\n",
    "\n",
    "        # Divide the image files into training and test sets\n",
    "        train_images = image_files[:split_point]\n",
    "        test_images = image_files[split_point:]\n",
    "\n",
    "        # Copy images to the train and test directories\n",
    "        for image in train_images:\n",
    "            source_path = os.path.join(subdir_path, image)\n",
    "            image = 'genuine' +image\n",
    "            destination_path = os.path.join(output_train_directory, subdir, image)\n",
    "            \n",
    "            os.makedirs(os.path.dirname(destination_path), exist_ok=True)\n",
    "            shutil.copy(source_path, destination_path)\n",
    "\n",
    "        for image in test_images:\n",
    "            print(image)\n",
    "            source_path = os.path.join(subdir_path, image)\n",
    "            image = 'genuine' +image\n",
    "            destination_path = os.path.join(output_test_directory, subdir, image)\n",
    "            os.makedirs(os.path.dirname(destination_path), exist_ok=True)\n",
    "            shutil.copy(source_path, destination_path)\n",
    "\n",
    "# Example usage:\n",
    "input_directory = \"C:/Users/satya/Downloads/AIML/Dataset/output\"  # Directory containing all the image subdirectories\n",
    "output_train_directory = 'C:/Users/satya/Downloads/AIML/Dataset/FakeLogoCategorize/train_data'  # Directory where training images will be stored\n",
    "output_test_directory = 'C:/Users/satya/Downloads/AIML/Dataset/FakeLogoCategorize/test_data'  # Directory where test images will be stored\n",
    "\n",
    "split_data(input_directory, output_train_directory, output_test_directory, split_ratio=0.8)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ab6a0afe",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dir = r\"D:\\Project\\Web App Flask\\Proj\\FakeLogoCategorize\\train_data\"\n",
    "test_dir = r\"D:\\Project\\Web App Flask\\Proj\\FakeLogoCategorize\\test_data\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14ce0dd1",
   "metadata": {},
   "source": [
    "## Data Augmentation and Processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5adc56dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "datagen = ImageDataGenerator(\n",
    "    rescale=1./255,\n",
    "#     rotation_range=15,\n",
    "#     width_shift_range=0.1,\n",
    "#     height_shift_range=0.1,\n",
    "    shear_range=0.2,\n",
    "    zoom_range=0.2,\n",
    "    horizontal_flip=True,\n",
    "#     brightness_range = [0.7,1.3],\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aeec9aee",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 636 images belonging to 63 classes.\n"
     ]
    }
   ],
   "source": [
    "train_data = datagen.flow_from_directory(\n",
    "    train_dir,\n",
    "    target_size=(224,224),\n",
    "    batch_size=15,\n",
    "    class_mode='categorical'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "67cc2b2b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 189 images belonging to 63 classes.\n"
     ]
    }
   ],
   "source": [
    "test_data = datagen.flow_from_directory(\n",
    "    test_dir,\n",
    "    target_size=(224,224),\n",
    "    batch_size=15,\n",
    "    class_mode='categorical'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59e7c4be",
   "metadata": {},
   "source": [
    "## MODEL BUILDING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "93a31799",
   "metadata": {},
   "outputs": [],
   "source": [
    "Image_size=[224,224]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "27a4b8be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg19/vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5\n",
      "80134624/80134624 [==============================] - 209s 3us/step\n"
     ]
    }
   ],
   "source": [
    "base_model = VGG19(input_shape=Image_size+[3],weights='imagenet',include_top=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6232d2f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in base_model.layers:\n",
    "    i.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b6ac1985",
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "\n",
    "model.add(base_model)\n",
    "model.add(Flatten())\n",
    "model.add(Dense(63,activation='softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "18762adf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " vgg19 (Functional)          (None, 7, 7, 512)         20024384  \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 25088)             0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 63)                1580607   \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 21604991 (82.42 MB)\n",
      "Trainable params: 1580607 (6.03 MB)\n",
      "Non-trainable params: 20024384 (76.39 MB)\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f7dba6f6",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "    optimizer='adam',\n",
    "    loss='categorical_crossentropy',\n",
    "    metrics = ['Accuracy']\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1694c9e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "697112f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "43/43 [==============================] - 242s 6s/step - loss: 4.3897 - Accuracy: 0.3129 - val_loss: 1.4323 - val_Accuracy: 0.6825\n",
      "Epoch 2/10\n",
      "43/43 [==============================] - 2057s 49s/step - loss: 0.5806 - Accuracy: 0.8553 - val_loss: 0.7637 - val_Accuracy: 0.7778\n",
      "Epoch 3/10\n",
      "43/43 [==============================] - 214s 5s/step - loss: 0.2594 - Accuracy: 0.9355 - val_loss: 0.3940 - val_Accuracy: 0.8889\n",
      "Epoch 4/10\n",
      "43/43 [==============================] - 205s 5s/step - loss: 0.1182 - Accuracy: 0.9717 - val_loss: 0.3183 - val_Accuracy: 0.9153\n",
      "Epoch 5/10\n",
      "43/43 [==============================] - 197s 5s/step - loss: 0.0746 - Accuracy: 0.9796 - val_loss: 0.3401 - val_Accuracy: 0.9101\n",
      "Epoch 6/10\n",
      "43/43 [==============================] - 194s 5s/step - loss: 0.0515 - Accuracy: 0.9890 - val_loss: 0.2000 - val_Accuracy: 0.9206\n",
      "Epoch 7/10\n",
      "43/43 [==============================] - 197s 5s/step - loss: 0.0160 - Accuracy: 1.0000 - val_loss: 0.2417 - val_Accuracy: 0.9312\n",
      "Epoch 8/10\n",
      "43/43 [==============================] - 213s 5s/step - loss: 0.0109 - Accuracy: 0.9969 - val_loss: 0.1654 - val_Accuracy: 0.9524\n",
      "Epoch 9/10\n",
      "43/43 [==============================] - 213s 5s/step - loss: 0.0088 - Accuracy: 1.0000 - val_loss: 0.1228 - val_Accuracy: 0.9841\n",
      "Epoch 10/10\n",
      "43/43 [==============================] - 206s 5s/step - loss: 0.0046 - Accuracy: 1.0000 - val_loss: 0.1178 - val_Accuracy: 0.9683\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/GPU:0'):\n",
    "    history = model.fit(\n",
    "        train_data,\n",
    "        validation_data =test_data,\n",
    "        epochs = 10,\n",
    "        batch_size = 15,\n",
    "        shuffle = True\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "99f8217d",
   "metadata": {},
   "outputs": [],
   "source": [
    "acc = history.history['Accuracy']\n",
    "val_acc = history.history['val_Accuracy']\n",
    "\n",
    "loss = history.history['loss']\n",
    "val_loss = history.history['val_loss']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "01e5a1de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'training and validation Accuracy')"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(8,8))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(range(10),acc,label='Training Accuracy')\n",
    "plt.plot(range(10),val_acc,label='Validation Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('training and validation Accuracy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "14d7cc9e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 2s 2s/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(15, 63)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.predict([test_data[1][0]]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "146ef95f",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\patel\\anaconda3\\lib\\site-packages\\keras\\src\\engine\\training.py:3079: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n",
      "  saving_api.save_model(\n"
     ]
    }
   ],
   "source": [
    "model.save(\"Logo_classification.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e74a02e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "17fa2cbb",
   "metadata": {},
   "source": [
    "### Testing the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fe18f72a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import load_model\n",
    "model = load_model(\"Logo_classification.h5\",compile=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "962785c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing import image\n",
    "img_test = image.load_img(r\"D:\\Project\\Web App Flask\\Proj\\FakeLogoCategorize\\train_data\\Cadbury\\Fake000002.jpg\", target_size=(224,224))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "d886c4ad",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.Image.Image image mode=RGB size=224x224 at 0x1D7016556A0>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "c0ba6150",
   "metadata": {},
   "outputs": [],
   "source": [
    "img_arr = image.img_to_array(img_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "3eb65abf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       ...,\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]],\n",
       "\n",
       "       [[0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        ...,\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.],\n",
       "        [0., 0., 0.]]], dtype=float32)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "38b81369",
   "metadata": {},
   "outputs": [],
   "source": [
    "img_arr = np.expand_dims(img_arr, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "71fb0a32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_arr.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "6ca18f45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 224, 224, 3)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "img_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "14755f73",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 1s 791ms/step\n"
     ]
    }
   ],
   "source": [
    "predimg = model.predict(img_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "b013d954",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        1.1111087e-22, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 1.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 1.6753346e-25, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        1.7619399e-12, 7.8083017e-22, 0.0000000e+00, 3.8725477e-37,\n",
       "        3.2782198e-32, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 0.0000000e+00, 0.0000000e+00, 0.0000000e+00,\n",
       "        0.0000000e+00, 1.0185592e-33, 0.0000000e+00]], dtype=float32)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predimg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "1408c3e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Adidas',\n",
       " 'Amazon',\n",
       " 'Android',\n",
       " 'Apple',\n",
       " 'Ariel',\n",
       " 'BMW',\n",
       " 'Bic',\n",
       " 'Burger King',\n",
       " 'Cadbury',\n",
       " 'Chevrolet',\n",
       " 'Chrome',\n",
       " 'Coca Cola',\n",
       " 'Cowbell',\n",
       " 'Dominos',\n",
       " 'Fila',\n",
       " 'Gillette',\n",
       " 'Google',\n",
       " 'Goya oil',\n",
       " 'Guinness',\n",
       " 'Heinz',\n",
       " 'Honda',\n",
       " 'Hp',\n",
       " 'Huawei',\n",
       " 'Instagram',\n",
       " 'KFC',\n",
       " 'Krisspy Kreme',\n",
       " 'Lays',\n",
       " 'Levis',\n",
       " 'Lg',\n",
       " 'Lipton',\n",
       " 'Mars',\n",
       " 'Marvel',\n",
       " 'McDonald',\n",
       " 'Mercedes Benz',\n",
       " 'Microsoft',\n",
       " 'MnM',\n",
       " 'Mtn',\n",
       " 'Mountain dew',\n",
       " 'NASA',\n",
       " 'Nescafe',\n",
       " 'Nestle',\n",
       " 'Nestle milo',\n",
       " 'Netflix',\n",
       " 'Nike',\n",
       " 'Nutella',\n",
       " 'Oral-B',\n",
       " 'Oreo',\n",
       " 'Pay pal',\n",
       " 'Peak milk',\n",
       " 'Pepsi',\n",
       " 'PlayStation',\n",
       " 'Pringles',\n",
       " 'Puma',\n",
       " 'Reebok',\n",
       " 'Rolex',\n",
       " 'Samsung',\n",
       " 'Sprite',\n",
       " 'Starbucks',\n",
       " 'Tesla',\n",
       " 'Tiktok',\n",
       " 'Twitter',\n",
       " 'YouTube',\n",
       " 'Zara']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index = ['Adidas', 'Amazon', 'Android', 'Apple', 'Ariel', 'BMW', 'Bic', 'Burger King', 'Cadbury', 'Chevrolet', 'Chrome', 'Coca Cola', 'Cowbell', 'Dominos', 'Fila', 'Gillette', 'Google', 'Goya oil', 'Guinness', 'Heinz', 'Honda', 'Hp', 'Huawei', 'Instagram', 'KFC', 'Krisspy Kreme', 'Lays', 'Levis', 'Lg', 'Lipton', 'Mars', 'Marvel', 'McDonald', 'Mercedes Benz', 'Microsoft', 'MnM', 'Mtn', 'Mountain dew', 'NASA', 'Nescafe', 'Nestle', 'Nestle milo', 'Netflix', 'Nike', 'Nutella', 'Oral-B', 'Oreo', 'Pay pal', 'Peak milk', 'Pepsi', 'PlayStation', 'Pringles', 'Puma', 'Reebok', 'Rolex', 'Samsung', 'Sprite', 'Starbucks', 'Tesla', 'Tiktok', 'Twitter', 'YouTube', 'Zara']\n",
    "index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "b2cb4335",
   "metadata": {},
   "outputs": [],
   "source": [
    "pred_class = np.argmax(predimg, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "fd473654",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pred_class[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "649bd973",
   "metadata": {},
   "outputs": [],
   "source": [
    "index = ['Adidas', 'Amazon', 'Android', 'Apple', 'Ariel', 'BMW', 'Bic', 'Burger King', 'Cadbury', 'Chevrolet', 'Chrome', 'Coca Cola', 'Cowbell', 'Dominos', 'Fila', 'Gillette', 'Google', 'Goya oil', 'Guinness', 'Heinz', 'Honda', 'Hp', 'Huawei', 'Instagram', 'KFC', 'Krisspy Kreme', 'Lays', 'Levis', 'Lg', 'Lipton', 'Mars', 'Marvel', 'McDonald', 'Mercedes Benz', 'Microsoft', 'MnM', 'Mtn', 'Mountain dew', 'NASA', 'Nescafe', 'Nestle', 'Nestle milo', 'Netflix', 'Nike', 'Nutella', 'Oral-B', 'Oreo', 'Pay pal', 'Peak milk', 'Pepsi', 'PlayStation', 'Pringles', 'Puma', 'Reebok', 'Rolex', 'Samsung', 'Sprite', 'Starbucks', 'Tesla', 'Tiktok', 'Twitter', 'YouTube', 'Zara']\n",
    "result = str(index[pred_class[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c5bed017",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Heinz'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "eae3c8c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100.0 <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "maxval = np.amax(predimg, axis=1)\n",
    "print(maxval[0]*100 , type(maxval))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "4371b9dc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 176ms/step\n",
      "[[0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 1.1111087e-22 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 1.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 1.6753346e-25 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 1.7619399e-12\n",
      "  7.8083017e-22 0.0000000e+00 3.8725477e-37 3.2782198e-32 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n",
      "  0.0000000e+00 1.0185592e-33 0.0000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "imagesx = np.vstack([img_arr])\n",
    "classes = model.predict(imagesx)\n",
    "print(classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "28bedce3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes.argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "8c5a22ef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "caefed06",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46, 49, 50,\n",
       "        51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 30, 29, 31, 27,  1,  2,\n",
       "         3,  4,  5,  6,  7,  9, 10, 11, 12, 13, 28, 62, 15, 16, 17, 18,\n",
       "        26, 20, 14, 21, 23, 24, 25, 47, 61, 48, 22,  8, 45, 44, 19]],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes.argsort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "007d158f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Oral-B'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "ad3fb9aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Nutella'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[44]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "40df633d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Cadbury'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "471bf77b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b170ec8e",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}