initial commit

app.py

@@ -0,0 +1,111 @@
+import gradio as gr
+import tensorflow as tf
+from tensorflow import keras
+from custom_model import ImageClassifier
+from resnet_model import ResNetClassifier
+from vgg16_model import VGG16Classifier
+from inception_v3_model import InceptionV3Classifier
+from mobilevet_v2 import MobileNetClassifier
+
+CLASS_NAMES =['Airplane', 'Automobile', 'Bird', 'Cat', 'Deer', 'Dog', 'Frog', 'Horse', 'Ship', 'Truck']
+
+# models
+custom_model = ImageClassifier()
+custom_model.load_model("image_classifier_model.h5")
+resnet_model = ResNetClassifier()
+vgg16_model = VGG16Classifier()
+inceptionV3_model = InceptionV3Classifier()
+mobilenet_model = MobileNetClassifier()
+
+def make_prediction(image, model_type):
+  if "CNN (2 layer) - Custom" == model_type:
+    top_classes, top_probs = custom_model.classify_image(image, top_k=3)
+    return {CLASS_NAMES[cls_id]:str(prob) for cls_id, prob in zip(top_classes, top_probs)}
+  elif "ResNet50" == model_type:
+    predictions = resnet_model.classify_image(image)
+    return {class_name:str(prob) for _, class_name, prob in predictions}
+  elif "VGG16" == model_type:
+    predictions = vgg16_model.classify_image(image)
+    return {class_name:str(prob) for _, class_name, prob in predictions}
+  elif "Inception v3" == model_type:
+    predictions = inceptionV3_model.classify_image(image)
+    return {class_name:str(prob) for _, class_name, prob in predictions}
+  elif "Mobile Net v2" == model_type:
+    predictions = mobilenet_model.classify_image(image)
+    return {class_name:str(prob) for _, class_name, prob in predictions}
+  else:
+    return {"Select a model to classify image"}
+
+def train_model(epochs, batch_size, validation_split):
+
+  print("Training model")
+
+  # Create an instance of the ImageClassifier
+  classifier = ImageClassifier()
+
+  # Load the dataset
+  (x_train, y_train), (x_test, y_test) = classifier.load_dataset()
+
+  # Build and train the model
+  classifier.build_model(x_train)
+  classifier.train_model(x_train, y_train, batch_size=int(batch_size), epochs=int(epochs), validation_split=float(validation_split))
+
+  # Evaluate the model
+  classifier.evaluate_model(x_test, y_test)
+
+  # Save the trained model
+  print("Saving model ...")
+  classifier.save_model("image_classifier_model.h5")
+
+  custom_model = classifier
+
+
+def update_train_param_display(model_type):
+  if "CNN (2 layer) - Custom" == model_type:
+    return [gr.update(visible=True), gr.update(visible=False)]
+  return [gr.update(visible=False), gr.update(visible=True)]
+
+if __name__ == "__main__":
+  # gradio gui app
+  with gr.Blocks() as my_app:
+    gr.Markdown("<h1><center>Image Classification using TensorFlow</center></h1>")
+    gr.Markdown("<h3><center>This model classifies image using different models.</center></h3>")
+
+    with gr.Row():
+      with gr.Column(scale=1):
+          img_input = gr.Image()
+          model_type = gr.Dropdown(
+              ["CNN (2 layer) - Custom", 
+                "ResNet50", 
+                "VGG16",
+                "Inception v3",
+                "Mobile Net v2"], 
+              label="Model Type", value="CNN (2 layer) - Custom",
+              info="Select the inference model before running predictions!")
+                   
+          with gr.Column() as train_col:
+            gr.Markdown("Train Parameters")
+            with gr.Row():
+              epochs_inp = gr.Textbox(label="Epochs", value="10")
+              validation_split = gr.Textbox(label="Validation Split", value="0.1")
+            
+            with gr.Row():
+              batch_size = gr.Textbox(label="Batch Size", value="64")
+
+            with gr.Row():
+              train_btn = gr.Button(value="Train")  
+              predict_btn_1 = gr.Button(value="Predict")   
+
+          with gr.Column(visible=False) as no_train_col:
+            predict_btn_2 = gr.Button(value="Predict")                  
+
+      with gr.Column(scale=1):
+        output_label = gr.Label()
+    
+    # app logic
+    predict_btn_1.click(make_prediction, inputs=[img_input, model_type], outputs=[output_label])
+    predict_btn_2.click(make_prediction, inputs=[img_input, model_type], outputs=[output_label])
+    model_type.change(update_train_param_display, inputs=model_type, outputs=[train_col, no_train_col])
+    train_btn.click(train_model, inputs=[epochs_inp, batch_size, validation_split], outputs=[])
+
+my_app.queue(concurrency_count=5, max_size=20).launch(debug=True)

custom_model.py

@@ -0,0 +1,116 @@
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+import numpy as np
+import cv2
+
+
+class ImageClassifier:
+    def __init__(self):
+        self.model = None
+
+    def preprocess_image(self, image):
+        # Resize the image to (32, 32)
+        resized_image = cv2.resize(image, (32, 32))
+
+        # # Convert the image to grayscale
+        # gray_image = cv2.cvtColor(resized_image, cv2.COLOR_BGR2GRAY)
+
+        # # # Normalize the pixel values between 0 and 1
+        # normalized_image = gray_image.astype("float32") / 255.0
+
+        # # # Transpose the dimensions to match the model's input shape
+        # transposed_image = np.transpose(normalized_image, (1, 2, 0))
+
+        # # # Expand dimensions to match model input shape (add batch dimension)
+        # img_array = np.expand_dims(transposed_image, axis=0)
+        return resized_image
+
+    def load_dataset(self):
+        # Set up the dataset
+        (x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
+
+        # Normalize pixel values between 0 and 1
+        x_train = x_train.astype("float32") / 255.0
+        x_test = x_test.astype("float32") / 255.0
+
+        return (x_train, y_train), (x_test, y_test)
+
+    # def build_model(self, x_train):
+    #     # Define the model architecture
+    #     model = keras.Sequential([
+    #         # keras.Input(shape=x_train.shape[1]),
+    #         layers.Conv2D(32, kernel_size=(3, 3), activation="relu", padding='same'),
+    #         layers.MaxPooling2D(pool_size=(2, 2)),
+    #         layers.Conv2D(64, kernel_size=(3, 3), activation="relu", padding='same'),
+    #         layers.MaxPooling2D(pool_size=(2, 2)),
+    #         layers.Flatten(),
+    #         layers.Dropout(0.5),
+    #         layers.Dense(10, activation="softmax")
+    #     ])
+
+    #     # Compile the model
+    #     model.compile(loss="sparse_categorical_crossentropy", optimizer="adam", metrics=["accuracy"])
+
+    #     self.model = model
+    
+    def build_model(self, x_train):
+      # Define the model architecture
+      model = keras.Sequential([
+          layers.Conv2D(32, kernel_size=(3, 3), activation="relu", padding='same'),
+          layers.BatchNormalization(),
+          layers.MaxPooling2D(pool_size=(2, 2)),
+          layers.Dropout(0.25),
+
+          layers.Conv2D(64, kernel_size=(3, 3), activation="relu", padding='same'),
+          layers.BatchNormalization(),
+          layers.MaxPooling2D(pool_size=(2, 2)),
+          layers.Dropout(0.25),
+
+          layers.Conv2D(128, kernel_size=(3, 3), activation="relu", padding='same'),
+          layers.BatchNormalization(),
+          layers.MaxPooling2D(pool_size=(2, 2)),
+          layers.Dropout(0.25),
+
+          layers.Flatten(),
+          layers.Dense(256, activation="relu"),
+          layers.BatchNormalization(),
+          layers.Dropout(0.5),
+
+          layers.Dense(10, activation="softmax")
+      ])
+
+      # Compile the model
+      optimizer = keras.optimizers.RMSprop(learning_rate=0.001)
+      model.compile(loss="sparse_categorical_crossentropy", optimizer=optimizer, metrics=["accuracy"])
+
+      self.model = model
+
+    def train_model(self, x_train, y_train, batch_size, epochs, validation_split):
+        # Train the model
+        self.model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, verbose=1, validation_split=validation_split)
+
+    def evaluate_model(self, x_test, y_test):
+        # Evaluate the model on the test set
+        score = self.model.evaluate(x_test, y_test, verbose=0)
+        print("Test loss:", score[0])
+        print("Test accuracy:", score[1])
+
+    def save_model(self, filepath):
+        # Save the trained model
+        self.model.save(filepath)
+
+    def load_model(self, filepath):
+        # Load the trained model
+        self.model = keras.models.load_model(filepath)
+
+    def classify_image(self, image, top_k=3):
+        # Preprocess the image
+        preprocessed_image = self.preprocess_image(image)
+
+        # Perform inference
+        predicted_probs = self.model.predict(np.array([preprocessed_image]))
+        top_classes = np.argsort(predicted_probs[0])[-top_k:][::-1]
+        top_probs = predicted_probs[0][top_classes]
+
+        return top_classes, top_probs

demo.ipynb

@@ -0,0 +1,341 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "OdOgOEqcDzhY",
+        "outputId": "a1787cb0-c94a-4145-ef35-bb222f63a373"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n",
+            "/content/drive/My Drive/My Projects/Image_Classifier_TensorFlow\n"
+          ]
+        }
+      ],
+      "source": [
+        "# This mounts your Google Drive to the Colab VM.\n",
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')\n",
+        "\n",
+        "%cd /content/drive/My\\ Drive/My\\ Projects/Image_Classifier_TensorFlow"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pwd"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 36
+        },
+        "id": "EuUA1qNaEdGB",
+        "outputId": "b9b3ca06-157a-4686-92ab-72c080dddcfb"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'/content/drive/My Drive/My Projects/Image_Classifier_TensorFlow'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "# Gradio App"
+      ],
+      "metadata": {
+        "id": "6XXQqgGmErXJ"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# installations\n",
+        "!pip install gradio"
+      ],
+      "metadata": {
+        "id": "wSuhvzbEE8Ql"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "markdown",
+      "source": [
+        "## Training"
+      ],
+      "metadata": {
+        "id": "71zplmVlFU9J"
+      }
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "print(\"Training model...\")\n",
+        "# Create an instance of the ImageClassifier\n",
+        "classifier = ImageClassifier()\n",
+        "\n",
+        "# Load the dataset\n",
+        "(x_train, y_train), (x_test, y_test) = classifier.load_dataset()\n",
+        "\n",
+        "# Build and train the model\n",
+        "classifier.build_model(x_train)\n",
+        "classifier.train_model(x_train, y_train, batch_size=64, epochs=1, validation_split=0.1)\n",
+        "\n",
+        "# Evaluate the model\n",
+        "classifier.evaluate_model(x_test, y_test)\n",
+        "\n",
+        "# Save the trained model\n",
+        "print(\"Saving model ...\")\n",
+        "classifier.save_model(\"image_classifier_model.h5\")"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Q9vKOsnKFRu4",
+        "outputId": "93268865-5288-44a3-bc09-6d30620655f8"
+      },
+      "execution_count": 13,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Training model...\n",
+            "704/704 [==============================] - 187s 263ms/step - loss: 1.5925 - accuracy: 0.4633 - val_loss: 1.3171 - val_accuracy: 0.5372\n",
+            "Test loss: 1.3429059982299805\n",
+            "Test accuracy: 0.5228999853134155\n",
+            "Saving model ...\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import gradio as gr\n",
+        "import tensorflow as tf\n",
+        "from tensorflow import keras\n",
+        "from custom_model import ImageClassifier\n",
+        "from resnet_model import ResNetClassifier\n",
+        "from vgg16_model import VGG16Classifier\n",
+        "from inception_v3_model import InceptionV3Classifier\n",
+        "from mobilevet_v2 import MobileNetClassifier\n",
+        "\n",
+        "CLASS_NAMES =['Airplane', 'Automobile', 'Bird', 'Cat', 'Deer', 'Dog', 'Frog', 'Horse', 'Ship', 'Truck']\n",
+        "\n",
+        "# models\n",
+        "custom_model = ImageClassifier()\n",
+        "custom_model.load_model(\"image_classifier_model.h5\")\n",
+        "resnet_model = ResNetClassifier()\n",
+        "vgg16_model = VGG16Classifier()\n",
+        "inceptionV3_model = InceptionV3Classifier()\n",
+        "mobilenet_model = MobileNetClassifier()\n",
+        "\n",
+        "def make_prediction(image, model_type):\n",
+        "  if \"CNN (2 layer) - Custom\" == model_type:\n",
+        "    top_classes, top_probs = custom_model.classify_image(image, top_k=3)\n",
+        "    return {CLASS_NAMES[cls_id]:str(prob) for cls_id, prob in zip(top_classes, top_probs)}\n",
+        "  elif \"ResNet50\" == model_type:\n",
+        "    predictions = resnet_model.classify_image(image)\n",
+        "    return {class_name:str(prob) for _, class_name, prob in predictions}\n",
+        "  elif \"VGG16\" == model_type:\n",
+        "    predictions = vgg16_model.classify_image(image)\n",
+        "    return {class_name:str(prob) for _, class_name, prob in predictions}\n",
+        "  elif \"Inception v3\" == model_type:\n",
+        "    predictions = inceptionV3_model.classify_image(image)\n",
+        "    return {class_name:str(prob) for _, class_name, prob in predictions}\n",
+        "  elif \"Mobile Net v2\" == model_type:\n",
+        "    predictions = mobilenet_model.classify_image(image)\n",
+        "    return {class_name:str(prob) for _, class_name, prob in predictions}\n",
+        "  else:\n",
+        "    return {\"Select a model to classify image\"}\n",
+        "\n",
+        "def train_model(epochs, batch_size, validation_split):\n",
+        "\n",
+        "  print(\"Training model\")\n",
+        "\n",
+        "  # Create an instance of the ImageClassifier\n",
+        "  classifier = ImageClassifier()\n",
+        "\n",
+        "  # Load the dataset\n",
+        "  (x_train, y_train), (x_test, y_test) = classifier.load_dataset()\n",
+        "\n",
+        "  # Build and train the model\n",
+        "  classifier.build_model(x_train)\n",
+        "  classifier.train_model(x_train, y_train, batch_size=int(batch_size), epochs=int(epochs), validation_split=float(validation_split))\n",
+        "\n",
+        "  # Evaluate the model\n",
+        "  classifier.evaluate_model(x_test, y_test)\n",
+        "\n",
+        "  # Save the trained model\n",
+        "  print(\"Saving model ...\")\n",
+        "  classifier.save_model(\"image_classifier_model.h5\")\n",
+        "\n",
+        "  custom_model = classifier\n",
+        "\n",
+        "\n",
+        "def update_train_param_display(model_type):\n",
+        "  if \"CNN (2 layer) - Custom\" == model_type:\n",
+        "    return [gr.update(visible=True), gr.update(visible=False)]\n",
+        "  return [gr.update(visible=False), gr.update(visible=True)]\n",
+        "\n",
+        "if __name__ == \"__main__\":\n",
+        "  # gradio gui app\n",
+        "  with gr.Blocks() as my_app:\n",
+        "    gr.Markdown(\"<h1><center>Image Classification using TensorFlow</center></h1>\")\n",
+        "    gr.Markdown(\"<h3><center>This model classifies image using different models.</center></h3>\")\n",
+        "\n",
+        "    with gr.Row():\n",
+        "      with gr.Column(scale=1):\n",
+        "          img_input = gr.Image()\n",
+        "          model_type = gr.Dropdown(\n",
+        "              [\"CNN (2 layer) - Custom\",\n",
+        "                \"ResNet50\",\n",
+        "                \"VGG16\",\n",
+        "                \"Inception v3\",\n",
+        "                \"Mobile Net v2\"],\n",
+        "              label=\"Model Type\", value=\"CNN (2 layer) - Custom\",\n",
+        "              info=\"Select the inference model before running predictions!\")\n",
+        "\n",
+        "          with gr.Column() as train_col:\n",
+        "            gr.Markdown(\"Train Parameters\")\n",
+        "            with gr.Row():\n",
+        "              epochs_inp = gr.Textbox(label=\"Epochs\", value=\"10\")\n",
+        "              validation_split = gr.Textbox(label=\"Validation Split\", value=\"0.1\")\n",
+        "\n",
+        "            with gr.Row():\n",
+        "              batch_size = gr.Textbox(label=\"Batch Size\", value=\"64\")\n",
+        "\n",
+        "            with gr.Row():\n",
+        "              train_btn = gr.Button(value=\"Train\")\n",
+        "              predict_btn_1 = gr.Button(value=\"Predict\")\n",
+        "\n",
+        "          with gr.Column(visible=False) as no_train_col:\n",
+        "            predict_btn_2 = gr.Button(value=\"Predict\")\n",
+        "\n",
+        "      with gr.Column(scale=1):\n",
+        "        output_label = gr.Label()\n",
+        "\n",
+        "    # app logic\n",
+        "    predict_btn_1.click(make_prediction, inputs=[img_input, model_type], outputs=[output_label])\n",
+        "    predict_btn_2.click(make_prediction, inputs=[img_input, model_type], outputs=[output_label])\n",
+        "    model_type.change(update_train_param_display, inputs=model_type, outputs=[train_col, no_train_col])\n",
+        "    train_btn.click(train_model, inputs=[epochs_inp, batch_size, validation_split], outputs=[])\n",
+        "\n",
+        "my_app.queue(concurrency_count=5, max_size=20).launch(debug=True)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 936
+        },
+        "id": "1N6d3Y0oEozx",
+        "outputId": "07cc9273-30a8-4186-f0bf-e14a5aa45216"
+      },
+      "execution_count": 14,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/resnet/resnet50_weights_tf_dim_ordering_tf_kernels.h5\n",
+            "102967424/102967424 [==============================] - 1s 0us/step\n",
+            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/vgg16/vgg16_weights_tf_dim_ordering_tf_kernels.h5\n",
+            "553467096/553467096 [==============================] - 9s 0us/step\n",
+            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/inception_v3/inception_v3_weights_tf_dim_ordering_tf_kernels.h5\n",
+            "96112376/96112376 [==============================] - 1s 0us/step\n",
+            "Downloading data from https://storage.googleapis.com/tensorflow/keras-applications/mobilenet_v2/mobilenet_v2_weights_tf_dim_ordering_tf_kernels_1.0_224.h5\n",
+            "14536120/14536120 [==============================] - 0s 0us/step\n",
+            "Setting queue=True in a Colab notebook requires sharing enabled. Setting `share=True` (you can turn this off by setting `share=False` in `launch()` explicitly).\n",
+            "\n",
+            "Colab notebook detected. This cell will run indefinitely so that you can see errors and logs. To turn off, set debug=False in launch().\n",
+            "Running on public URL: https://bc9c4277de0c1cb0c9.gradio.live\n",
+            "\n",
+            "This share link expires in 72 hours. For free permanent hosting and GPU upgrades, run `gradio deploy` from Terminal to deploy to Spaces (https://huggingface.co/spaces)\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "<div><iframe src=\"https://bc9c4277de0c1cb0c9.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "1/1 [==============================] - 0s 178ms/step\n",
+            "1/1 [==============================] - 1s 1s/step\n",
+            "Downloading data from https://storage.googleapis.com/download.tensorflow.org/data/imagenet_class_index.json\n",
+            "35363/35363 [==============================] - 0s 0us/step\n",
+            "1/1 [==============================] - 1s 755ms/step\n",
+            "1/1 [==============================] - 2s 2s/step\n",
+            "Keyboard interruption in main thread... closing server.\n",
+            "Killing tunnel 127.0.0.1:7860 <> https://bc9c4277de0c1cb0c9.gradio.live\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": []
+          },
+          "metadata": {},
+          "execution_count": 14
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [],
+      "metadata": {
+        "id": "6p0TTCYYH2XA"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}

image_classifier_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5528c5c25c770c8ab4355b551b6856c842b7ef2507e81dfcf8674a2fd9f0ba98
+size 5045112

inception_v3_model.py

@@ -0,0 +1,26 @@
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+class InceptionV3Classifier:
+  def __init__(self):
+    self.model = keras.applications.InceptionV3(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
+  
+  def preprocess_image(self, image):
+    img = keras.preprocessing.image.array_to_img(image)
+    img = img.resize((299, 299))
+    img_array = keras.preprocessing.image.img_to_array(img)
+    img_array = tf.expand_dims(img_array, 0)
+    img_array = keras.applications.vgg16.preprocess_input(img_array)
+    return img_array
+
+  def classify_image(self, image):
+
+    # Preprocess the image
+    img_array = self.preprocess_image(image)
+
+    # Classify the image
+    predictions = self.model.predict(img_array)
+    predicted_classes = keras.applications.imagenet_utils.decode_predictions(predictions, top=3)[0]
+
+    return predicted_classes

mobilevet_v2.py

@@ -0,0 +1,26 @@
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+class MobileNetClassifier:
+  def __init__(self):
+    self.model = keras.applications.MobileNetV2(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
+  
+  def preprocess_image(self, image):
+    img = keras.preprocessing.image.array_to_img(image)
+    img = img.resize((224, 224))
+    img_array = keras.preprocessing.image.img_to_array(img)
+    img_array = tf.expand_dims(img_array, 0)
+    img_array = keras.applications.resnet50.preprocess_input(img_array)
+    return img_array
+
+  def classify_image(self, image):
+
+    # Preprocess the image
+    img_array = self.preprocess_image(image)
+
+    # Classify the image
+    predictions = self.model.predict(img_array)
+    predicted_classes = keras.applications.imagenet_utils.decode_predictions(predictions, top=3)[0]
+
+    return predicted_classes

requirements.txt

@@ -0,0 +1,20 @@
+# Base ----------------------------------------
+matplotlib>=3.2.2
+numpy>=1.21.6
+opencv-python>=4.6.0
+Pillow>=7.1.2
+PyYAML>=5.3.1
+requests>=2.23.0
+scipy>=1.4.1
+gradio>=3.36.1
+tensorflow==2.12.0
+tensorflow-datasets==4.9.2
+
+# Plotting ------------------------------------
+pandas>=1.1.4
+seaborn>=0.11.0
+
+
+# Extras --------------------------------------
+psutil  # system utilization
+thop>=0.1.1  # FLOPs computation

resnet_model.py

@@ -0,0 +1,25 @@
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+class ResNetClassifier:
+  def __init__(self):
+    self.model = keras.applications.ResNet50(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
+  
+  def preprocess_image(self, image):
+    img = keras.preprocessing.image.array_to_img(image)
+    img = img.resize((224, 224))
+    img_array = keras.preprocessing.image.img_to_array(img)
+    img_array = tf.expand_dims(img_array, 0)
+    img_array = keras.applications.resnet50.preprocess_input(img_array)
+    return img_array
+
+  def classify_image(self, image):
+    # Preprocess the image
+    img_array = self.preprocess_image(image)
+
+    # Classify the image
+    predictions = self.model.predict(img_array)
+    predicted_classes = keras.applications.imagenet_utils.decode_predictions(predictions, top=3)[0]
+
+    return predicted_classes

vgg16_model.py

@@ -0,0 +1,26 @@
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+
+class VGG16Classifier:
+  def __init__(self):
+    self.model = keras.applications.VGG16(include_top=True, weights='imagenet', input_tensor=None, input_shape=None, pooling=None, classes=1000)
+  
+  def preprocess_image(self, image):
+    img = keras.preprocessing.image.array_to_img(image)
+    img = img.resize((224, 224))
+    img_array = keras.preprocessing.image.img_to_array(img)
+    img_array = tf.expand_dims(img_array, 0)
+    img_array = keras.applications.vgg16.preprocess_input(img_array)
+    return img_array
+
+  def classify_image(self, image):
+
+    # Preprocess the image
+    img_array = self.preprocess_image(image)
+
+    # Classify the image
+    predictions = self.model.predict(img_array)
+    predicted_classes = keras.applications.imagenet_utils.decode_predictions(predictions, top=3)[0]
+
+    return predicted_classes