Upload 4 files

app.py

@@ -0,0 +1,14 @@
+import gradio as gr
+import tensorflow as tf
+
+model = tf.keras.models.load_model("model.h5")
+
+
+def sketch_recognition(img):
+    img = img.reshape(1, 28, 28, 1).astype('float32') / 255
+    prediction = model.predict(img)
+    return int(tf.argmax(prediction, 1))
+
+
+gr.Interface(fn=sketch_recognition, inputs="sketchpad",
+             outputs="text").launch()

model.h5

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

train_model.ipynb

@@ -0,0 +1,271 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-01-18 06:19:20.044209: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
+      "2023-01-18 06:19:20.044256: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:`period` argument is deprecated. Please use `save_freq` to specify the frequency in number of batches seen.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-01-18 06:19:24.572788: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n",
+      "2023-01-18 06:19:24.572842: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n",
+      "2023-01-18 06:19:24.572888: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (Tasus): /proc/driver/nvidia/version does not exist\n",
+      "2023-01-18 06:19:24.573984: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
+      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/7\n",
+      "1719/1719 [==============================] - 19s 11ms/step - loss: 0.1568 - accuracy: 0.9527 - val_loss: 0.0546 - val_accuracy: 0.9846\n",
+      "Epoch 2/7\n",
+      "1719/1719 [==============================] - 19s 11ms/step - loss: 0.0528 - accuracy: 0.9837 - val_loss: 0.0425 - val_accuracy: 0.9888\n",
+      "Epoch 3/7\n",
+      "1719/1719 [==============================] - 19s 11ms/step - loss: 0.0365 - accuracy: 0.9887 - val_loss: 0.0359 - val_accuracy: 0.9894\n",
+      "Epoch 4/7\n",
+      "1719/1719 [==============================] - 18s 10ms/step - loss: 0.0267 - accuracy: 0.9913 - val_loss: 0.0347 - val_accuracy: 0.9894\n",
+      "Epoch 5/7\n",
+      "1719/1719 [==============================] - 18s 11ms/step - loss: 0.0198 - accuracy: 0.9940 - val_loss: 0.0402 - val_accuracy: 0.9888\n",
+      "Epoch 6/7\n",
+      "1719/1719 [==============================] - 18s 10ms/step - loss: 0.0162 - accuracy: 0.9945 - val_loss: 0.0366 - val_accuracy: 0.9898\n",
+      "Epoch 7/7\n",
+      "1719/1719 [==============================] - 18s 10ms/step - loss: 0.0126 - accuracy: 0.9954 - val_loss: 0.0317 - val_accuracy: 0.9924\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2023-01-18 06:21:33.070595: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "INFO:tensorflow:Assets written to: model.pb/assets\n",
+      "Test accuracy: 0.9905999898910522\n"
+     ]
+    }
+   ],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers\n",
+    "from tensorflow.keras.callbacks import ModelCheckpoint\n",
+    "from keras.preprocessing.image import ImageDataGenerator\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "\n",
+    "\n",
+    "# Load the MNIST dataset\n",
+    "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
+    "x_train = x_train.reshape(-1, 28, 28, 1).astype('float32') / 255\n",
+    "x_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255\n",
+    "\n",
+    "x_val = x_train[:5000]\n",
+    "y_val = y_train[:5000]\n",
+    "x_train = x_train[5000:]\n",
+    "y_train = y_train[5000:]\n",
+    "\n",
+    "# Define the model\n",
+    "model = keras.Sequential()\n",
+    "model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))\n",
+    "model.add(layers.MaxPooling2D((2, 2)))\n",
+    "model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
+    "model.add(layers.MaxPooling2D((2, 2)))\n",
+    "model.add(layers.Flatten())\n",
+    "model.add(layers.Dense(64, activation='relu'))\n",
+    "model.add(layers.Dense(10, activation='softmax'))\n",
+    "\n",
+    "# Compile the model\n",
+    "model.compile(optimizer='adam',\n",
+    "              loss='sparse_categorical_crossentropy',\n",
+    "              metrics=['accuracy'])\n",
+    "checkpoint = ModelCheckpoint('model.h5', save_best_only=True, save_weights_only=False, mode='auto', period=1)\n",
+    "\n",
+    "\n",
+    "# Train the model\n",
+    "history = model.fit(x_train, y_train, epochs=7, validation_data=(x_val, y_val), callbacks=[checkpoint])\n",
+    "\n",
+    "# Plot accuracy vs epoch\n",
+    "plt.plot(history.history['accuracy'])\n",
+    "plt.plot(history.history['val_accuracy'])\n",
+    "plt.title('Model accuracy')\n",
+    "plt.ylabel('Accuracy')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.legend(['Train', 'Validation'], loc='upper left')\n",
+    "plt.show()\n",
+    "\n",
+    "# Plot loss vs epoch\n",
+    "plt.plot(history.history['loss'])\n",
+    "plt.plot(history.history['val_loss'])\n",
+    "plt.title('Model loss')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.xlabel('Epoch')\n",
+    "plt.legend(['Train', 'Validation'], loc='upper left')\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "# Save the model in protobuf format\n",
+    "tf.saved_model.save(model, 'model.pb')\n",
+    "\n",
+    "# Evaluate the model on test data\n",
+    "test_loss, test_acc = model.evaluate(x_test, y_test, verbose=0)\n",
+    "print('Test accuracy:',test_acc)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "313/313 [==============================] - 1s 4ms/step - loss: 0.0314 - accuracy: 0.9906\n",
+      "Test accuracy: 0.9905999898910522\n"
+     ]
+    }
+   ],
+   "source": [
+    "test_loss, test_acc = model.evaluate(x_test, y_test)\n",
+    "print('Test accuracy:', test_acc)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running on local URL:  http://127.0.0.1:7860\n",
+      "\n",
+      "To create a public link, set `share=True` in `launch()`.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div><iframe src=\"http://127.0.0.1:7860/\" 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"
+    }
+   ],
+   "source": [
+    "import gradio as gr\n",
+    "import tensorflow as tf\n",
+    "\n",
+    "model = tf.keras.models.load_model(\"model.h5\")\n",
+    "\n",
+    "def sketch_recognition(img):\n",
+    "    img = img.reshape(1, 28, 28, 1).astype('float32') / 255\n",
+    "    prediction = model.predict(img)\n",
+    "    return int(tf.argmax(prediction, 1))\n",
+    "\n",
+    "gr.Interface(fn=sketch_recognition, inputs=\"sketchpad\", outputs=\"label\").launch()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.10.9"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "e7370f93d1d0cde622a1f8e1c04877d8463912d04d973331ad4851f04de6915a"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}