Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,21 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+dogs-vs-cats-model_transferlearning.keras filter=lfs diff=lfs merge=lfs -text
+images/dog1.jpeg filter=lfs diff=lfs merge=lfs -text
+pokemon_transferlearning.keras filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Charmeleon/00000027.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Charmeleon/00000207.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Hitmonchan/00000015.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Hitmonchan/00000025.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Hitmonchan/00000038.gif filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Hitmonchan/00000099.gif filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Hitmonchan/00000111.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Hitmonchan/00000169.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Pikachu/00000031.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Pikachu/00000034.png filter=lfs diff=lfs merge=lfs -text
+pokemons/train/Pikachu/00000122.png filter=lfs diff=lfs merge=lfs -text
+pokemons/val/Pikachu/00000154.jpg filter=lfs diff=lfs merge=lfs -text
+pokemons/val/Pikachu/00000188.gif filter=lfs diff=lfs merge=lfs -text
+pokemons/val/Pikachu/00000212.png filter=lfs diff=lfs merge=lfs -text
+pokemons/val/Pikachu/00000225.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,12 +1,6 @@
 ---
-title: Pokemon1
-emoji: 💻
-colorFrom: purple
-colorTo: pink
+title: pokemon1
+app_file: app.py
 sdk: gradio
 sdk_version: 4.27.0
-app_file: app.py
-pinned: false
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.ipynb

@@ -0,0 +1,187 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/loic/Library/Python/3.9/lib/python/site-packages/urllib3/__init__.py:35: NotOpenSSLWarning: urllib3 v2 only supports OpenSSL 1.1.1+, currently the 'ssl' module is compiled with 'LibreSSL 2.8.3'. See: https://github.com/urllib3/urllib3/issues/3020\n",
+      "  warnings.warn(\n",
+      "/Users/loic/Library/Python/3.9/lib/python/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import tensorflow as tf\n",
+    "import numpy as np\n",
+    "from PIL import Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_path = \"dogs-vs-cats-model_transferlearning.keras\"\n",
+    "model = tf.keras.models.load_model(model_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the core prediction function\n",
+    "def predict_cat_dog(image):\n",
+    "    # Preprocess image\n",
+    "    print(type(image))\n",
+    "    image = Image.fromarray(image.astype('uint8'))  # Convert numpy array to PIL image\n",
+    "    image = image.resize((150, 150)) #resize the image to 28x28 and converts it to gray scale\n",
+    "    image = np.array(image)\n",
+    "    image = np.expand_dims(image, axis=0) # same as image[None, ...]\n",
+    "    \n",
+    "    # Predict\n",
+    "    prediction = model.predict(image)\n",
+    "    \n",
+    "    # Because the output layer was dense(0) without an activation function, we need to apply sigmoid to get the probability\n",
+    "    # we could also change the output layer to dense(1, activation='sigmoid')\n",
+    "    prediction = np.round(float(tf.sigmoid(prediction)[0]), 2)\n",
+    "    p_cat = (1 - prediction)\n",
+    "    p_dog = prediction\n",
+    "    return {'cat': p_cat, 'dog': p_dog}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<tf.Tensor: shape=(), dtype=float32, numpy=0.6341356>"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "tf.sigmoid(0.55)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7863\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7863/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'numpy.ndarray'>\n",
+      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 32ms/step\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Traceback (most recent call last):\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/gradio/queueing.py\", line 527, in process_events\n",
+      "    response = await route_utils.call_process_api(\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/gradio/route_utils.py\", line 261, in call_process_api\n",
+      "    output = await app.get_blocks().process_api(\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/gradio/blocks.py\", line 1786, in process_api\n",
+      "    result = await self.call_function(\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/gradio/blocks.py\", line 1338, in call_function\n",
+      "    prediction = await anyio.to_thread.run_sync(\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/anyio/to_thread.py\", line 56, in run_sync\n",
+      "    return await get_async_backend().run_sync_in_worker_thread(\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/anyio/_backends/_asyncio.py\", line 2144, in run_sync_in_worker_thread\n",
+      "    return await future\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/anyio/_backends/_asyncio.py\", line 851, in run\n",
+      "    result = context.run(func, *args)\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/gradio/utils.py\", line 759, in wrapper\n",
+      "    response = f(*args, **kwargs)\n",
+      "  File \"/var/folders/vr/l64rqhls46j_2hyn4pdl0m880000gn/T/ipykernel_56385/4113486017.py\", line 15, in predict_cat_dog\n",
+      "    prediction = np.round(float(tf.sigmoid(prediction)[0]), 2)\n",
+      "  File \"/Users/loic/Library/Python/3.9/lib/python/site-packages/tensorflow/python/framework/ops.py\", line 307, in __float__\n",
+      "    return float(self._numpy())\n",
+      "TypeError: only length-1 arrays can be converted to Python scalars\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create the Gradio interface\n",
+    "input_image = gr.Image()\n",
+    "iface = gr.Interface(\n",
+    "    fn=predict_cat_dog,\n",
+    "    inputs=input_image, \n",
+    "    outputs=gr.Label(),\n",
+    "    examples=[\"images/cat1.jpeg\", \"images/cat2.jpeg\", \"images/cat3.jpeg\", \"images/cat4.jpeg\", \"images/dog1.jpeg\", \"images/dog2.jpeg\", \"images/dog3.jpeg\"],   \n",
+    "    description=\"A simple mlp classification model for image classification using the mnist dataset.\")\n",
+    "iface.launch()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "venv_new",
+   "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

app.py

@@ -0,0 +1,46 @@
+import gradio as gr
+import tensorflow as tf
+from PIL import Image
+import numpy as np
+
+# Load the pre-trained model
+model = tf.keras.models.load_model('pokemon_transferlearning.keras')
+
+def classify_image(img):
+    
+    if isinstance(img, np.ndarray):
+        img = Image.fromarray(img.astype('uint8'), 'RGB')
+
+    # Preprocess the image to fit the model's input requirements
+    img = img.resize((150, 150))  # Resize the image using PIL, which is intended here
+    img_array = np.array(img)  # Convert the resized PIL image to a numpy array
+    img_array = img_array / 255.0  # Normalize pixel values to [0, 1]
+    img_array = np.expand_dims(img_array, axis=0)  # Expand dimensions to fit model input shape
+
+    # Make prediction
+    prediction = model.predict(img_array)
+
+    # prediction = np.round(float(tf.sigmoid(prediction)), 2)
+    # p_cat = (1 - prediction)
+    # p_dog = prediction
+    # return {'cat': p_cat, 'dog': p_dog}
+
+    print(prediction)
+
+    probabilities = tf.sigmoid(prediction).numpy()  # Convert tensor to numpy array if using 
+
+    # Formatting the probabilities
+    class_names = ['Hitchoman', 'Pikachu', 'Charmeleon']
+    results = {class_names[i]: float(prediction[0][i]) for i in range(3)}  # Convert each probability to float
+    
+    return results
+
+# Create Gradio interface
+iface = gr.Interface(fn=classify_image,
+                     inputs=gr.Image(),
+                     outputs=gr.Label(num_top_classes=3),
+                     title="Pokemon Classifier",
+                     description="Upload an image of a pokemon classify.")
+
+# Launch the application
+iface.launch(share=True)

app_cat_dog.ipynb

@@ -0,0 +1,118 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7865\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7865/\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:6 out of the last 7 calls to <function TensorFlowTrainer.make_predict_function.<locals>.one_step_on_data_distributed at 0x315091670> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
+      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 608ms/step\n",
+      "[[0.49759743 0.50240254]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import tensorflow as tf\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "\n",
+    "# Load the pre-trained model\n",
+    "model = tf.keras.models.load_model('dogs-vs-cats-model_transferlearning.keras')\n",
+    "\n",
+    "def classify_image(img):\n",
+    "    \n",
+    "    if isinstance(img, np.ndarray):\n",
+    "        img = Image.fromarray(img.astype('uint8'), 'RGB')\n",
+    "\n",
+    "    # Preprocess the image to fit the model's input requirements\n",
+    "    img = img.resize((150, 150))  # Resize the image using PIL, which is intended here\n",
+    "    img_array = np.array(img)  # Convert the resized PIL image to a numpy array\n",
+    "    img_array = img_array / 255.0  # Normalize pixel values to [0, 1]\n",
+    "    img_array = np.expand_dims(img_array, axis=0)  # Expand dimensions to fit model input shape\n",
+    "\n",
+    "    # Make prediction\n",
+    "    prediction = model.predict(img_array)\n",
+    "\n",
+    "    # prediction = np.round(float(tf.sigmoid(prediction)), 2)\n",
+    "    # p_cat = (1 - prediction)\n",
+    "    # p_dog = prediction\n",
+    "    # return {'cat': p_cat, 'dog': p_dog}\n",
+    "\n",
+    "    print(prediction)\n",
+    "\n",
+    "    probabilities = tf.sigmoid(prediction).numpy()  # Convert tensor to numpy array if using \n",
+    "\n",
+    "    # Formatting the probabilities\n",
+    "    class_names = ['Cat', 'Dog']\n",
+    "    results = {class_names[i]: float(prediction[0][i]) for i in range(2)}  # Convert each probability to float\n",
+    "    \n",
+    "    return results\n",
+    "\n",
+    "# Create Gradio interface\n",
+    "iface = gr.Interface(fn=classify_image,\n",
+    "                     inputs=gr.Image(),\n",
+    "                     outputs=gr.Label(num_top_classes=2),\n",
+    "                     title=\"Cat vs Dog Classifier\",\n",
+    "                     description=\"Upload an image of a cat or dog to classify.\")\n",
+    "\n",
+    "# Launch the application\n",
+    "iface.launch()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

app_pokemon.ipynb

@@ -0,0 +1,120 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7862\n",
+      "Running on public URL: https://59007d69f4a41b96f2.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"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"https://59007d69f4a41b96f2.gradio.live\" width=\"100%\" height=\"500\" allow=\"autoplay; camera; microphone; clipboard-read; clipboard-write;\" frameborder=\"0\" allowfullscreen></iframe></div>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 628ms/step\n",
+      "[[0.33698466 0.33483982 0.32817554]]\n",
+      "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 35ms/step\n",
+      "[[0.33667472 0.33442825 0.32889706]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import tensorflow as tf\n",
+    "from PIL import Image\n",
+    "import numpy as np\n",
+    "\n",
+    "# Load the pre-trained model\n",
+    "model = tf.keras.models.load_model('pokemon_transferlearning.keras')\n",
+    "\n",
+    "def classify_image(img):\n",
+    "    \n",
+    "    if isinstance(img, np.ndarray):\n",
+    "        img = Image.fromarray(img.astype('uint8'), 'RGB')\n",
+    "\n",
+    "    # Preprocess the image to fit the model's input requirements\n",
+    "    img = img.resize((150, 150))  # Resize the image using PIL, which is intended here\n",
+    "    img_array = np.array(img)  # Convert the resized PIL image to a numpy array\n",
+    "    img_array = img_array / 255.0  # Normalize pixel values to [0, 1]\n",
+    "    img_array = np.expand_dims(img_array, axis=0)  # Expand dimensions to fit model input shape\n",
+    "\n",
+    "    # Make prediction\n",
+    "    prediction = model.predict(img_array)\n",
+    "\n",
+    "    # prediction = np.round(float(tf.sigmoid(prediction)), 2)\n",
+    "    # p_cat = (1 - prediction)\n",
+    "    # p_dog = prediction\n",
+    "    # return {'cat': p_cat, 'dog': p_dog}\n",
+    "\n",
+    "    print(prediction)\n",
+    "\n",
+    "    probabilities = tf.sigmoid(prediction).numpy()  # Convert tensor to numpy array if using \n",
+    "\n",
+    "    # Formatting the probabilities\n",
+    "    class_names = ['Hitchoman', 'Pikachu', 'Charmeleon']\n",
+    "    results = {class_names[i]: float(prediction[0][i]) for i in range(3)}  # Convert each probability to float\n",
+    "    \n",
+    "    return results\n",
+    "\n",
+    "# Create Gradio interface\n",
+    "iface = gr.Interface(fn=classify_image,\n",
+    "                     inputs=gr.Image(),\n",
+    "                     outputs=gr.Label(num_top_classes=3),\n",
+    "                     title=\"Pokemon Classifier\",\n",
+    "                     description=\"Upload an image of a pokemon to classify.\")\n",
+    "\n",
+    "# Launch the application\n",
+    "iface.launch(share=True)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

dogs-vs-cats-model_transferlearning.keras

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