{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2021-11-07 16:35:43.845313: 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", "2021-11-07 16:35:43.845345: 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" ] } ], "source": [ "import os\n", "import numpy as np\n", "import tensorflow as tf\n", "assert tf.__version__.startswith('2')\n", "from tflite_model_maker import model_spec\n", "from tflite_model_maker import image_classifier\n", "from tflite_model_maker.config import ExportFormat\n", "from tflite_model_maker.config import QuantizationConfig\n", "from tflite_model_maker.image_classifier import DataLoader\n", "import matplotlib.pyplot as plt\n", "import tflite_model_maker\n", "from PIL import Image, ImageOps" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "image_path = 'bhavika_data/'" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Load image with size: 327, num_label: 2, labels: fall, no-fall.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2021-11-07 16:35:46.782860: 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", "2021-11-07 16:35:46.782884: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n", "2021-11-07 16:35:46.782903: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (bhavika-ML): /proc/driver/nvidia/version does not exist\n", "2021-11-07 16:35:46.783239: I tensorflow/core/platform/cpu_feature_guard.cc:142] 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" ] } ], "source": [ "data = DataLoader.from_folder(image_path)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "train_data, validation_data = data.split(0.8)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Retraining the models...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2021-11-07 16:36:09.169921: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Model: \"sequential\"\n", "_________________________________________________________________\n", "Layer (type) Output Shape Param # \n", "=================================================================\n", "hub_keras_layer_v1v2 (HubKer (None, 1280) 3413024 \n", "_________________________________________________________________\n", "dropout (Dropout) (None, 1280) 0 \n", "_________________________________________________________________\n", "dense (Dense) (None, 2) 2562 \n", "=================================================================\n", "Total params: 3,415,586\n", "Trainable params: 2,562\n", "Non-trainable params: 3,413,024\n", "_________________________________________________________________\n", "None\n", "Epoch 1/5\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "/home/bhavika/.local/lib/python3.8/site-packages/keras/optimizer_v2/optimizer_v2.py:355: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.\n", " warnings.warn(\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "32/32 [==============================] - 28s 824ms/step - loss: 0.7842 - accuracy: 0.6250 - val_loss: 0.7170 - val_accuracy: 0.7344\n", "Epoch 2/5\n", "32/32 [==============================] - 30s 969ms/step - loss: 0.4769 - accuracy: 0.8398 - val_loss: 0.9231 - val_accuracy: 0.7188\n", "Epoch 3/5\n", "32/32 [==============================] - 29s 920ms/step - loss: 0.4378 - accuracy: 0.8633 - val_loss: 0.6859 - val_accuracy: 0.8281\n", "Epoch 4/5\n", "32/32 [==============================] - 29s 940ms/step - loss: 0.3862 - accuracy: 0.9062 - val_loss: 0.5129 - val_accuracy: 0.7656\n", "Epoch 5/5\n", "32/32 [==============================] - 25s 811ms/step - loss: 0.3386 - accuracy: 0.9414 - val_loss: 0.5095 - val_accuracy: 0.8281\n", "\n" ] } ], "source": [ "model = image_classifier.create(train_data, model_spec='efficientnet_lite0', validation_data=validation_data, epochs=5, batch_size=8)\n", "print(model)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Assets written to: /tmp/tmpcironj4j/assets\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Assets written to: /tmp/tmpcironj4j/assets\n", "2021-11-07 16:41:26.748529: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 0\n", "2021-11-07 16:41:26.748700: I tensorflow/core/grappler/clusters/single_machine.cc:357] Starting new session\n", "2021-11-07 16:41:26.781690: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1137] Optimization results for grappler item: graph_to_optimize\n", " function_optimizer: Graph size after: 913 nodes (656), 923 edges (664), time = 17.393ms.\n", " function_optimizer: function_optimizer did nothing. time = 0.448ms.\n", "\n", "2021-11-07 16:41:27.507539: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.\n", "2021-11-07 16:41:27.507574: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.\n", "fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 3\n", "WARNING:absl:For model inputs containing unsupported operations which cannot be quantized, the `inference_input_type` attribute will default to the original type.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Label file is inside the TFLite model with metadata.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Label file is inside the TFLite model with metadata.\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:Saving labels in /tmp/tmpdd__n6_t/labels.txt\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:Saving labels in /tmp/tmpdd__n6_t/labels.txt\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "INFO:tensorflow:TensorFlow Lite model exported successfully: ai_models/john-custom-transfer-learned-fall-detect-model-efficientnet_lite.tflite\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "INFO:tensorflow:TensorFlow Lite model exported successfully: ai_models/john-custom-transfer-learned-fall-detect-model-efficientnet_lite.tflite\n" ] } ], "source": [ "model.export(export_dir='ai_models', tflite_filename='john-custom-transfer-learned-fall-detect-model-efficientnet_lite.tflite')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Model Inference" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "def thumbnail(image=None, desired_size=None):\n", " \"\"\"Resizes original image as close as possible to desired size.\n", " Preserves aspect ratio of original image.\n", " Does not modify the original image.\n", " :Parameters:\n", " ----------\n", " image : PIL.Image\n", " Input Image for AI model detection.\n", " desired_size : (width, height)\n", " Size expected by the AI model.\n", " :Returns:\n", " -------\n", " PIL.Image\n", " Resized image fitting for the AI model input tensor.\n", " \"\"\"\n", " assert image\n", " assert desired_size\n", " \n", " thumb = image.copy()\n", " w, h = desired_size\n", " try:\n", " # convert from numpy to native Python int type\n", " # that PIL expects\n", " if isinstance(w, np.generic):\n", " w = w.item()\n", " w = int(w)\n", " h = h.item()\n", " h = int(h)\n", " thumb.thumbnail((w, h))\n", " except Exception as e:\n", " msg = (f\"Exception in \"\n", " f\"PIL.image.thumbnail(desired_size={desired_size}):\"\n", " f\"type(width)={type(w)}, type(height)={type(h)}\"\n", " f\"\\n{e}\"\n", " )\n", " \n", " raise RuntimeError(msg)\n", " \n", " return thumb\n", "\n", "\n", "def resize(image=None, desired_size=None):\n", " \"\"\"Pad original image to exact size expected by input tensor.\n", " Preserve aspect ratio to avoid confusing the AI model with\n", " unnatural distortions. Pad the resulting image\n", " with solid black color pixels to fill the desired size.\n", " Do not modify the original image.\n", " :Parameters:\n", " ----------\n", " image : PIL.Image\n", " Input Image sized to fit an input tensor but without padding.\n", " Its possible that one size fits one tensor dimension exactly\n", " but the other size is smaller than\n", " the input tensor other dimension.\n", " desired_size : (width, height)\n", " Exact size expected by the AI model.\n", " :Returns:\n", " -------\n", " PIL.Image\n", " Resized image fitting exactly the AI model input tensor.\n", " \"\"\"\n", " assert image\n", " assert desired_size\n", " \n", " thumb = image.copy()\n", " delta_w = desired_size[0] - thumb.size[0]\n", " delta_h = desired_size[1] - thumb.size[1]\n", " padding = (0, 0, delta_w, delta_h)\n", " new_im = ImageOps.expand(thumb, padding)\n", " \n", " assert new_im.size == desired_size\n", " return new_im" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 224, 224, 3], dtype=int32)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "interpreter = tf.lite.Interpreter(model_path=\"ai_models/john-custom-transfer-learned-fall-detect-model-efficientnet_lite.tflite\")\n", "interpreter.allocate_tensors()\n", "\n", "input_details = interpreter.get_input_details()\n", "output_details = interpreter.get_output_details()\n", "\n", "input_shape = input_details[0]['shape']\n", "width, height = 224, 224\n", "input_shape" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def prediction(path_image):\n", "\n", " template_image_src = Image.open(path_image) \n", " plt.imshow(template_image_src)\n", " \n", " _thumbnail = thumbnail(image=template_image_src, desired_size=(width, height))\n", " img = resize(image=_thumbnail, desired_size=(width, height))\n", " \n", " img = np.expand_dims(img,0)\n", " \n", " interpreter.set_tensor(input_details[0]['index'], img)\n", " interpreter.invoke()\n", " output_data = interpreter.get_tensor(output_details[0]['index'])\n", " \n", " pred = \"fall\" if np.argmax(output_data[0])==0 else \"no-fall\"\n", " \n", " return pred" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "'no-fall'" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "path_image = \"Images/fall_img_8.png\"\n", "pred = prediction(path_image)\n", "pred" ] }, { "cell_type": "code", "execution_count": null, "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.8.8" } }, "nbformat": 4, "nbformat_minor": 4 }