Model 6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.models import load_model\n",
    "from tensorflow.keras import layers, activations\n",
    "from tensorflow.keras.layers import *\n",
    "from tensorflow.keras.optimizers import *\n",
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "\n",
    "from tinymlgen import port\n",
    "\n",
    "import numpy as np\n",
    "from numpy import asarray\n",
    "\n",
    "from utils.preprocessing import preprocessImage\n",
    "from utils.grad_cam import get_img_array, make_gradcam_heatmap, save_and_display_gradcam\n",
    "from utils.image_display import imageDisplay\n",
    "from utils.transform_data import transformData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Preprocessing\n",
    "resize_image = True\n",
    "#new_size = (480, 640)\n",
    "new_size = (640, 480)\n",
    "grey_scale = True\n",
    "rgb_or_grey = 3\n",
    "normalize_image = False\n",
    "thresholding = False\n",
    "erosion = False\n",
    "kernel = np.ones((2, 2), np.uint8)\n",
    "cut_image = False\n",
    "turn_image = False\n",
    "\n",
    "#Scaling\n",
    "min_max = False\n",
    "z_score = False\n",
    "\n",
    "min_max_labels = True\n",
    "z_score_labels = False\n",
    "\n",
    "#Training\n",
    "batch_size = 16\n",
    "epochs = 150\n",
    "\n",
    "if resize_image == True:\n",
    "    #new_size = (300, 225)\n",
    "    #new_size = (225, 300)\n",
    "    if turn_image == True:\n",
    "        #new_size = (160, 120)\n",
    "        new_size = (120, 160)\n",
    "        #new_size = (240, 320)\n",
    "    else:\n",
    "        new_size = (160, 120)\n",
    "        #new_size = (320, 240)\n",
    "\n",
    "if grey_scale == True:\n",
    "    rgb_or_grey = 1\n",
    "\n",
    "preprocessImage = preprocessImage()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "imageFolderPath: ../Bilder/Manometer/Blindset final test\n"
     ]
    }
   ],
   "source": [
    "imageFoldersValidation = \"../Bilder/Manometer/Blindset final test\"\n",
    "\n",
    "#Load in Images and Clean DataFrame\n",
    "validation_images, validation_labels = preprocessImage.load_images(imageFoldersValidation, True, grey_scale, resize_image, new_size, normalize_image, thresholding, erosion, kernel, cut_image, turn_image)\n",
    "\n",
    "validation_images = validation_images.reshape(len(validation_labels), new_size[1], new_size[0], rgb_or_grey)\n",
    "nRows,nCols,nDims = validation_images.shape[1:]\n",
    "validation_images = validation_images.reshape(validation_images.shape[0], nRows, nCols, nDims)\n",
    "#Scale Data\n",
    "transformer = transformData()\n",
    "\n",
    "#Parameters Training data\n",
    "mean_value = 114.31817292906746\n",
    "standard_deviation = 77.30169303183406\n",
    "\n",
    "min_value = 0\n",
    "max_value = 255\n",
    "\n",
    "#Parameters Targetr Data\n",
    "mean_value_labels = 5.035714285714286\n",
    "standard_deviation_labels = 3.0150275548430043\n",
    "\n",
    "min_labels = 0\n",
    "max_labels = 10\n",
    "\n",
    "\n",
    "if min_max == True:\n",
    "    validation_images = transformer.scale_min_max(validation_images, min_value, max_value)\n",
    "\n",
    "if z_score == True:\n",
    "    validation_images = transformer.scale_z_score(validation_images, mean_value, standard_deviation)\n",
    "\n",
    "\n",
    "if min_max_labels == True:\n",
    "    validation_labels = transformer.scale_min_max(validation_labels, min_labels, max_labels)\n",
    "\n",
    "if z_score_labels == True:\n",
    "    validation_labels = transformer.scale_z_score(validation_labels, mean_value_labels, standard_deviation_labels)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'True Value': 'Predction',\n",
       " 0.3: 0.91834015,\n",
       " 0.5: 1.0550447,\n",
       " 0.8: 1.0550447,\n",
       " 0.0: 0.89755774,\n",
       " 1.3: 1.0437521,\n",
       " 1.5: 0.95331585,\n",
       " 1.7999999999999998: 1.743305,\n",
       " 1.0: 1.0047672,\n",
       " 10.0: 9.565529,\n",
       " 2.3: 2.1721296,\n",
       " 2.5: 2.2158856,\n",
       " 2.8: 3.240428,\n",
       " 2.0: 2.1594462,\n",
       " 3.3: 2.8606687,\n",
       " 3.5: 3.342731,\n",
       " 3.8: 3.3293092,\n",
       " 3.0: 2.684673,\n",
       " 4.3: 4.2687616,\n",
       " 4.5: 4.664156,\n",
       " 4.8: 4.180715,\n",
       " 4.0: 3.9558747,\n",
       " 5.300000000000001: 4.807865,\n",
       " 5.5: 5.157948,\n",
       " 5.8: 5.6252427,\n",
       " 5.0: 4.724704,\n",
       " 6.3: 6.568692,\n",
       " 6.5: 6.7139273,\n",
       " 6.799999999999999: 6.9439926,\n",
       " 6.0: 6.2688084,\n",
       " 7.3: 6.6504474,\n",
       " 7.5: 7.2631073,\n",
       " 7.800000000000001: 7.942863,\n",
       " 7.0: 6.856549,\n",
       " 8.3: 8.396479,\n",
       " 8.5: 8.834189,\n",
       " 8.8: 9.236258,\n",
       " 8.0: 7.8413286,\n",
       " 9.3: 9.829292,\n",
       " 9.5: 9.830502,\n",
       " 9.8: 9.60359,\n",
       " 9.0: 9.664692}"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image_num = len(validation_labels)-1\n",
    "\n",
    "path = \"models/model6/model.tflite\"\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "preds = []\n",
    "\n",
    "interpreter = tf.lite.Interpreter(model_path=path)\n",
    "interpreter.allocate_tensors()\n",
    "\n",
    "for element in range(len(validation_labels)):\n",
    "    \n",
    "    input_details = interpreter.get_input_details()\n",
    "    output_details = interpreter.get_output_details()\n",
    "\n",
    "    input_data = validation_images[element].reshape(1, 120, 160, 1)#.flatten()\n",
    "    input_data = np.float32(input_data)\n",
    "    interpreter.set_tensor(input_details[0]['index'], input_data)\n",
    "\n",
    "    predictions=interpreter.invoke()\n",
    "\n",
    "    output_data = interpreter.get_tensor(output_details[0]['index'])\n",
    "\n",
    "    output_data = output_data[0] * 10\n",
    "\n",
    "    preds.append(output_data)\n",
    "\n",
    "dict = {\"True Value\":\"Predction\"}\n",
    "for A, B in zip(validation_labels*10, preds):\n",
    "    dict[A] = B[0]\n",
    "\n",
    "dict\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.523705158873302"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "errors = mean_absolute_error(validation_labels*10, preds)\n",
    "errors"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tf_gpu",
   "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.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}