MiniImageToolsClassifierFromDysk.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "MiniImageToolsClassifierFromDysk.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "1Vp1aDEGK9BlBYYn3K4s4swwsAY_Gqw9E",
      "authorship_tag": "ABX9TyOWKk1gbjZ6eMq6K4OM/31R",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/pepek1910/LearnKeras/blob/master/MiniImageToolsClassifierFromDysk.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3AaIhtGIg5Iw"
      },
      "source": [
        "#dane Image 150x150\n",
        "#adjustable shape triangle wrench \n",
        "https://www.youtube.com/watch?v=u2TjZzNuly8"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "djAChtTjg75o",
        "outputId": "6b002c42-3adf-4d9e-ae80-b6607dd63c0d"
      },
      "source": [
        "import os\n",
        "\n",
        "shape_dir = os.path.join('/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/shape')\n",
        "triangle_dir = os.path.join('/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/triangle')\n",
        "wrench_dir = os.path.join('/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/wrench')\n",
        "adjustable_dir = os.path.join('/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/adjustable')\n",
        "\n",
        "print('total training shape images:', len(os.listdir(shape_dir)))\n",
        "print('total training triangle images:', len(os.listdir(triangle_dir)))\n",
        "print('total training wrench images:', len(os.listdir(wrench_dir)))\n",
        "print('total training adjustable images:', len(os.listdir(adjustable_dir)))\n",
        "\n",
        "shape_files = os.listdir(shape_dir)\n",
        "print(shape_files[:10])\n",
        "\n",
        "triangle_files = os.listdir(triangle_dir)\n",
        "print(triangle_files[:10])\n",
        "\n",
        "wrench_files = os.listdir(wrench_dir)\n",
        "print(wrench_files[:10])\n",
        "\n",
        "adjustable_files = os.listdir(adjustable_dir)\n",
        "print(adjustable_files[:10])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "total training shape images: 696\n",
            "total training triangle images: 696\n",
            "total training wrench images: 696\n",
            "total training adjustable images: 696\n",
            "['ksztaltMiniRot0_44.bmp', 'ksztaltMiniRot0_13.bmp', 'ksztaltMiniRot0_18.bmp', 'ksztaltMiniRot0_21.bmp', 'ksztaltMiniRot0_35.bmp', 'ksztaltMiniRot0_5.bmp', 'ksztaltMiniRot0_38.bmp', 'ksztaltMiniRot0_37.bmp', 'ksztaltMiniRot0_4.bmp', 'ksztaltMiniRot0_34.bmp']\n",
            "['trojkatmini22.bmp', 'trojkatmini52.bmp', 'trojkatmini44.bmp', 'trojkatmini31.bmp', 'trojkatmini47.bmp', 'trojkatmini61.bmp', 'trojkatmini2.bmp', 'trojkatmini8.bmp', 'trojkatmini36.bmp', 'trojkatmini55.bmp']\n",
            "['kluczMini188.bmp', 'kluczMini187.bmp', 'kluczMini212.bmp', 'kluczMini216.bmp', 'kluczMini169.bmp', 'kluczMini218.bmp', 'kluczMini190.bmp', 'kluczMini207.bmp', 'kluczMini168.bmp', 'kluczMini170.bmp']\n",
            "['francuzMini95.bmp', 'francuzMini88.bmp', 'francuzMini70.bmp', 'francuzMini82.bmp', 'francuzMini66.bmp', 'francuzMini81.bmp', 'francuzMini76.bmp', 'francuzMini15.bmp', 'francuzMini43.bmp', 'francuzMini86.bmp']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "8hXXFnLAndIK",
        "outputId": "d551b21e-147a-4cba-8a9c-13d7aa51a447"
      },
      "source": [
        "%matplotlib inline\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "\n",
        "pic_index = 2\n",
        "\n",
        "next_shape = [os.path.join(shape_dir, fname) \n",
        "                for fname in shape_files[pic_index-2:pic_index]]\n",
        "next_triangle = [os.path.join(triangle_dir, fname) \n",
        "                for fname in triangle_files[pic_index-2:pic_index]]\n",
        "next_wrench = [os.path.join(wrench_dir, fname) \n",
        "                for fname in wrench_files[pic_index-2:pic_index]]\n",
        "next_adjustable = [os.path.join(adjustable_dir, fname) \n",
        "                for fname in adjustable_files[pic_index-2:pic_index]]\n",
        "\n",
        "for i, img_path in enumerate(next_shape+next_triangle+next_wrench):\n",
        "\n",
        "  print(img_path)\n",
        "  img = mpimg.imread(img_path)\n",
        "  plt.imshow(img)\n",
        "  plt.axis('Off')\n",
        "  plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/shape/ksztaltMiniRot0_44.bmp\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/shape/ksztaltMiniRot0_13.bmp\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/triangle/trojkatmini22.bmp\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/triangle/trojkatmini52.bmp\n"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAH/UlEQVR4nO3dy0uUXxzH8e+TlhhG1iLMblIhXTZNbhIhiRYJtWgTSIsI2rbIRX+Bi2jVIkoClxm1ixCCqaSC6IKliIu07ELThS7ibWxyLue3iN+PX6jdnHnO55l5v+Bs5iLfzdvnzEGfCZxzBkDPIt8DAJgbcQKiiBMQRZyAKOIERJX/7MkgCDjKBQrMORfM9ThXTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkBUue8B8GsVFRW2adMmC4LAzMycczYyMmLfvn3zPBkKiTgjoL6+3vr7+394LBaL2cDAgKeJEAbijIggCH64cp4/f94mJyd/eE0ymbQjR47Y9PS0jxGRZ8QZQUEQWFNT06zHp6ambM+ePZZMJmc93tvbG9Z4yBPiLCJVVVXW3d096/H+/n6LxWIeJsJCcForrr293a5cubKgn1FfX29Pnjyxx48f27lz5/I0GQqNOMXV1dXZ1q1b//u8+TeWLl1qsVjMxsbGLJFI5HE6FBLb2hLS3t5ut2/f9j0GfhNXTkAUV84S8OnTJ+vq6mJLGzHEKSoIAquqqrLFixcv+Ge9ffvW2tra8jAVwkScolavXm19fX1WXV3texR4QpyigiCw6upqW7JkyYJ+TldXl8Xj8TxNhTARZ5Hr7u62y5cv+x4Df4HTWkAUcRapz58/29GjR+3Bgwe+R8FfYlsrqKamZsF/FTQ9PW2XLl2ydDqdx8kQJq6cgk6cOGHxeNzKy/ndWcqIU9T//3/zT3V0dNjhw4ctk8nkeSqEiV/NRejZs2d2794932NggYiziDjnfI+APCLOIjI1NWUtLS02PDzsexTkAXEKKS8vt4MHD9q2bdv+6v3ZbNYGBwdtYmIiz5PBh+BnW6EgCNgnhWjZsmX2+vVrW7FixR+/N5vN2ujoqG3evJk4I8Y5N+fJH6e1RaKzs9N27Ngx6458iC62tUVicnLS3r1753sM5BFxRpxzziYmJiyVSvkeBXlGnBGXTqetsbHRXrx44XsU5Blxiti9e7cdOnTIKisr//i9k5OTfG9KESJOEbFYzI4fP/5H70kmk/bhwwfLZrMFmgo+cVobYdeuXbMtW7bY+/fvfY+CAiDOCMvlcvxxexFjWxtBzjl7+vSpvXr1yvcoKCDijKjW1la+n7PIEadnZWVldvHiRWtoaPA9CsQQp2dBEFhjY6Nt2LDht17/5csX6+3t5c/0SgBxRkx/f7+1tLT4HgMh4LQWEMWVM0Li8bjdunXL9xgICXF6tGjRIquoqPjl63K5nKXTaTt9+rT19PSEMBkUsK316MCBAzY8PGxr1qz56euGhoZs48aN3LSrxHDl9KiystJqa2t/+bp0Os3/apYgrpzipqamuO1IiSJOcW1tbbZv3z7fY8AD4hT39etXm56e9j0GPOAzpye1tbW2atWqeZ/PZDL25s0bSyaTIU4FJdwa05OHDx9aQ0ODlZWVzfl8IpGw+vp6S6VS3Mm9yHFrTDFlZWXzhvmvTCZDmCWMOAUlEgkbGBggzBJHnILOnj1r+/fv5y4HJY44AVGc1oZs5cqVtmvXLlu+fPms5zKZjPX09NjIyIiHySDHOTfvMjPHyu9qbm528xkfH3fV1dXeZ2SFu+brj20tIIptrYjBwUG7c+eOzczM+B4FIohTxM2bN62trc33GBDCthYQxZUzRK2trbZ3794fHstms9bR0WE3btzwNBVkcVob3rp+/fqsE9qZmRm3fv1677Ox/C1Oa4GIYVvrUW9vr3V2dtro6KjvUSCIOD16/vy5XbhwwfcYEMW2FhDFlTME69atszNnzlgsFjMzM+ecnTx50u7evet5MkjjtLbwa/v27S6bzf53QpvL5dzOnTu9z8XSWJzWAhFDnCHr6+uzpqYmGxoa8j0KxPGZM2Tj4+N2//5932MgArhyFlgQBBYE32+ulsvluC8Qfh8HQoVdp06dci9fvnS5XM4dO3bMrV271vtMLK01X39sawuspqbG6urqzOz7XfUSiYTfgRAZxBmCXC5nqVTKstms71EQIcQZguHhYWtubraxsTHfoyBCiLPArl69ao8ePbKPHz/6HgURw3elAJ7xXSlAxBAnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkAUcQKiiBMQRZyAKOIERBEnIIo4AVHECYgiTkBU4JzzPQOAOXDlBEQRJyCKOAFRxAmIIk5AFHECov4BQhj41OxB+iEAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/wrench/kluczMini188.bmp\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData/wrench/kluczMini187.bmp\n"
          ]
        },
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zsv31hNcnhmY",
        "outputId": "d788554a-8d6a-4d30-d6ef-5886b97c6ea7"
      },
      "source": [
        "import tensorflow as tf\n",
        "import keras_preprocessing\n",
        "from keras_preprocessing import image\n",
        "from keras_preprocessing.image import ImageDataGenerator\n",
        "#opis posczegolnych bibliotek\n",
        "#https://www.geeksforgeeks.org/python-image-classification-using-keras/\n",
        "img_width = 150\n",
        "img_height = 150\n",
        "if tf.keras.backend.image_data_format() == 'channels_first':\n",
        "    input_shape = (3, img_width, img_height)\n",
        "else:\n",
        "    input_shape = (img_width, img_height, 3)\n",
        "\n",
        "TRAINING_DIR = \"/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TrainingMiniData\"\n",
        "training_datagen = ImageDataGenerator(\n",
        "      rescale = 1./255,\n",
        "\t    # rotation_range=40,\n",
        "      # width_shift_range=0.2,\n",
        "      # height_shift_range=0.2,\n",
        "      # shear_range=0.2,\n",
        "      # zoom_range=0.2,\n",
        "      # horizontal_flip=True,\n",
        "      #fill_mode='nearest'\n",
        "      )\n",
        "\n",
        "VALIDATION_DIR = \"/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/TestMiniData\"\n",
        "validation_datagen = ImageDataGenerator(rescale = 1./255)\n",
        "\n",
        "train_generator = training_datagen.flow_from_directory(\n",
        "\tTRAINING_DIR,\n",
        "\ttarget_size=(150,150),\n",
        "\tclass_mode='categorical',\n",
        "  batch_size=64 #test z 64\n",
        ")\n",
        "\n",
        "validation_generator = validation_datagen.flow_from_directory(\n",
        "\tVALIDATION_DIR,\n",
        "\ttarget_size=(150,150),\n",
        "\tclass_mode='categorical',\n",
        "  batch_size=64 #test z 64\n",
        ")\n",
        "\n",
        "model = tf.keras.models.Sequential([\n",
        "    # Note the input shape is the desired size of the image 150x150 with 3 bytes color\n",
        "    # This is the first convolution\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=input_shape),  #ostatnio zmienono kernel size z 10  na 15, jak po testach z 5\n",
        "    tf.keras.layers.Activation(activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2, 2),\n",
        "    ##\n",
        "    # The second convolution\n",
        "    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    # The third convolution\n",
        "    tf.keras.layers.Conv2D(128, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    # The fourth convolution\n",
        "    tf.keras.layers.Conv2D(128, (3,3), activation='relu'),\n",
        "    tf.keras.layers.MaxPooling2D(2,2),\n",
        "    ##\n",
        "    #Flatten the results to feed into a DNN\n",
        "    tf.keras.layers.Flatten(),\n",
        "    tf.keras.layers.Dropout(0.5),\n",
        "    # 512 neuron hidden layer\n",
        "    tf.keras.layers.Dense(512, activation='relu'),\n",
        "    tf.keras.layers.Dense(4, activation='softmax')#softmax #sigmoid binary\n",
        "])\n",
        "\n",
        "\n",
        "model.summary()\n",
        "\n",
        "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])#(loss = 'categorical_crossentropy', optimizer='adam', metrics=['accuracy']) #optimizer='rmsprop'\n",
        "\n",
        "  #checkpoint_path = \"model1/cp.ckpt\"\n",
        "  #checkpoint_dir = os.path.dirname(checkpoint_path)\n",
        "\n",
        "  #cp_callback = tf.keras.callbacks.ModelCheckpoint(checkpoint_path,save_weights_only=True, werbose = 1)\n",
        "\n",
        "  #history = model.fit(train_generator, epochs=1, steps_per_epoch=1, validation_data = validation_generator, verbose = 1, validation_steps=3,callbacks= [cp_callback])\n",
        "history = model.fit(train_generator, epochs=10, steps_per_epoch=20, validation_data = validation_generator, verbose = 1, validation_steps=3)\n",
        "\n",
        "model.save(\"ToolsClassifierModel.h5\")\n"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Found 2784 images belonging to 4 classes.\n",
            "Found 696 images belonging to 4 classes.\n",
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 148, 148, 64)      1792      \n",
            "                                                                 \n",
            " activation (Activation)     (None, 148, 148, 64)      0         \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2D  (None, 74, 74, 64)       0         \n",
            " )                                                               \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 72, 72, 64)        36928     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPooling  (None, 36, 36, 64)       0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 34, 34, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPooling  (None, 17, 17, 128)      0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " conv2d_3 (Conv2D)           (None, 15, 15, 128)       147584    \n",
            "                                                                 \n",
            " max_pooling2d_3 (MaxPooling  (None, 7, 7, 128)        0         \n",
            " 2D)                                                             \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 6272)              0         \n",
            "                                                                 \n",
            " dropout (Dropout)           (None, 6272)              0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 512)               3211776   \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 4)                 2052      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 3,473,988\n",
            "Trainable params: 3,473,988\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "Epoch 1/10\n",
            "20/20 [==============================] - 309s 15s/step - loss: 0.8418 - accuracy: 0.6290 - val_loss: 0.4648 - val_accuracy: 0.7969\n",
            "Epoch 2/10\n",
            "20/20 [==============================] - 170s 8s/step - loss: 0.3832 - accuracy: 0.8181 - val_loss: 0.3377 - val_accuracy: 0.8177\n",
            "Epoch 3/10\n",
            "20/20 [==============================] - 112s 5s/step - loss: 0.3073 - accuracy: 0.8391 - val_loss: 0.3199 - val_accuracy: 0.8385\n",
            "Epoch 4/10\n",
            "20/20 [==============================] - 99s 5s/step - loss: 0.2455 - accuracy: 0.8950 - val_loss: 0.1990 - val_accuracy: 0.9219\n",
            "Epoch 5/10\n",
            "20/20 [==============================] - 92s 5s/step - loss: 0.1865 - accuracy: 0.9191 - val_loss: 0.2280 - val_accuracy: 0.9010\n",
            "Epoch 6/10\n",
            "20/20 [==============================] - 88s 4s/step - loss: 0.1431 - accuracy: 0.9461 - val_loss: 0.2918 - val_accuracy: 0.8698\n",
            "Epoch 7/10\n",
            "20/20 [==============================] - 84s 4s/step - loss: 0.1508 - accuracy: 0.9343 - val_loss: 0.3393 - val_accuracy: 0.8750\n",
            "Epoch 8/10\n",
            "20/20 [==============================] - 87s 4s/step - loss: 0.1370 - accuracy: 0.9406 - val_loss: 0.2471 - val_accuracy: 0.9167\n",
            "Epoch 9/10\n",
            "20/20 [==============================] - 86s 4s/step - loss: 0.1097 - accuracy: 0.9602 - val_loss: 0.2578 - val_accuracy: 0.9167\n",
            "Epoch 10/10\n",
            "20/20 [==============================] - 86s 4s/step - loss: 0.1170 - accuracy: 0.9617 - val_loss: 0.1911 - val_accuracy: 0.9323\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZEPc7qXylMRx"
      },
      "source": [
        "import tensorflow as tf\n",
        "import keras_preprocessing\n",
        "from keras_preprocessing import image\n",
        "from keras_preprocessing.image import ImageDataGenerator"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T_EBvAw-Q3m7",
        "outputId": "794597aa-3d74-4df7-f4ea-d9c76603bbb0"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": [
              "{'adjustable': 0, 'shape': 1, 'triangle': 2, 'wrench': 3}"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gXApIfkja2zP"
      },
      "source": [
        "# #Save Model\n",
        "# #https://www.youtube.com/watch?v=HxtBIwfy0kM\n",
        "# #model.save_weights('./checkpoints/my_checkpoint')\n",
        "# #model.load_weights('./checkpoints/my_checkpoint')\n",
        "# #!ls {checkpoint_dir}\n",
        "# #to powinno zadzialac\n",
        "# # Load Model\n",
        "# import tensorflow as tf\n",
        "# model = tf.keras.models.load_model('/content/drive/MyDrive/Colab/LearningBasic/ToolsImageClassification/rps.h5')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 298
        },
        "id": "ATuhqFdDtnFx",
        "outputId": "0b337344-9683-4d1f-b82f-2671ba3437a2"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(len(acc))\n",
        "\n",
        "plt.plot(epochs, acc, 'r', label='Training accuracy')\n",
        "plt.plot(epochs, val_acc, 'b', label='Validation accuracy')\n",
        "plt.title('Training and validation accuracy')\n",
        "plt.legend(loc=0)\n",
        "plt.figure()\n",
        "\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "resources": {
            "http://localhost:8080/nbextensions/google.colab/files.js": {
              "data": "Ly8gQ29weXJpZ2h0IDIwMTcgR29vZ2xlIExMQwovLwovLyBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgIkxpY2Vuc2UiKTsKLy8geW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLgovLyBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXQKLy8KLy8gICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAKLy8KLy8gVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZQovLyBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiAiQVMgSVMiIEJBU0lTLAovLyBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4KLy8gU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZAovLyBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS4KCi8qKgogKiBAZmlsZW92ZXJ2aWV3IEhlbHBlcnMgZm9yIGdvb2dsZS5jb2xhYiBQeXRob24gbW9kdWxlLgogKi8KKGZ1bmN0aW9uKHNjb3BlKSB7CmZ1bmN0aW9uIHNwYW4odGV4dCwgc3R5bGVBdHRyaWJ1dGVzID0ge30pIHsKICBjb25zdCBlbGVtZW50ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc3BhbicpOwogIGVsZW1lbnQudGV4dENvbnRlbnQgPSB0ZXh0OwogIGZvciAoY29uc3Qga2V5IG9mIE9iamVjdC5rZXlzKHN0eWxlQXR0cmlidXRlcykpIHsKICAgIGVsZW1lbnQuc3R5bGVba2V5XSA9IHN0eWxlQXR0cmlidXRlc1trZXldOwogIH0KICByZXR1cm4gZWxlbWVudDsKfQoKLy8gTWF4IG51bWJlciBvZiBieXRlcyB3aGljaCB3aWxsIGJlIHVwbG9hZGVkIGF0IGEgdGltZS4KY29uc3QgTUFYX1BBWUxPQURfU0laRSA9IDEwMCAqIDEwMjQ7CgpmdW5jdGlvbiBfdXBsb2FkRmlsZXMoaW5wdXRJZCwgb3V0cHV0SWQpIHsKICBjb25zdCBzdGVwcyA9IHVwbG9hZEZpbGVzU3RlcChpbnB1dElkLCBvdXRwdXRJZCk7CiAgY29uc3Qgb3V0cHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG91dHB1dElkKTsKICAvLyBDYWNoZSBzdGVwcyBvbiB0aGUgb3V0cHV0RWxlbWVudCB0byBtYWtlIGl0IGF2YWlsYWJsZSBmb3IgdGhlIG5leHQgY2FsbAogIC8vIHRvIHVwbG9hZEZpbGVzQ29udGludWUgZnJvbSBQeXRob24uCiAgb3V0cHV0RWxlbWVudC5zdGVwcyA9IHN0ZXBzOwoKICByZXR1cm4gX3VwbG9hZEZpbGVzQ29udGludWUob3V0cHV0SWQpOwp9CgovLyBUaGlzIGlzIHJvdWdobHkgYW4gYXN5bmMgZ2VuZXJhdG9yIChub3Qgc3VwcG9ydGVkIGluIHRoZSBicm93c2VyIHlldCksCi8vIHdoZXJlIHRoZXJlIGFyZSBtdWx0aXBsZSBhc3luY2hyb25vdXMgc3RlcHMgYW5kIHRoZSBQeXRob24gc2lkZSBpcyBnb2luZwovLyB0byBwb2xsIGZvciBjb21wbGV0aW9uIG9mIGVhY2ggc3RlcC4KLy8gVGhpcyB1c2VzIGEgUHJvbWlzZSB0byBibG9jayB0aGUgcHl0aG9uIHNpZGUgb24gY29tcGxldGlvbiBvZiBlYWNoIHN0ZXAsCi8vIHRoZW4gcGFzc2VzIHRoZSByZXN1bHQgb2YgdGhlIHByZXZpb3VzIHN0ZXAgYXMgdGhlIGlucHV0IHRvIHRoZSBuZXh0IHN0ZXAuCmZ1bmN0aW9uIF91cGxvYWRGaWxlc0NvbnRpbnVlKG91dHB1dElkKSB7CiAgY29uc3Qgb3V0cHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKG91dHB1dElkKTsKICBjb25zdCBzdGVwcyA9IG91dHB1dEVsZW1lbnQuc3RlcHM7CgogIGNvbnN0IG5leHQgPSBzdGVwcy5uZXh0KG91dHB1dEVsZW1lbnQubGFzdFByb21pc2VWYWx1ZSk7CiAgcmV0dXJuIFByb21pc2UucmVzb2x2ZShuZXh0LnZhbHVlLnByb21pc2UpLnRoZW4oKHZhbHVlKSA9PiB7CiAgICAvLyBDYWNoZSB0aGUgbGFzdCBwcm9taXNlIHZhbHVlIHRvIG1ha2UgaXQgYXZhaWxhYmxlIHRvIHRoZSBuZXh0CiAgICAvLyBzdGVwIG9mIHRoZSBnZW5lcmF0b3IuCiAgICBvdXRwdXRFbGVtZW50Lmxhc3RQcm9taXNlVmFsdWUgPSB2YWx1ZTsKICAgIHJldHVybiBuZXh0LnZhbHVlLnJlc3BvbnNlOwogIH0pOwp9CgovKioKICogR2VuZXJhdG9yIGZ1bmN0aW9uIHdoaWNoIGlzIGNhbGxlZCBiZXR3ZWVuIGVhY2ggYXN5bmMgc3RlcCBvZiB0aGUgdXBsb2FkCiAqIHByb2Nlc3MuCiAqIEBwYXJhbSB7c3RyaW5nfSBpbnB1dElkIEVsZW1lbnQgSUQgb2YgdGhlIGlucHV0IGZpbGUgcGlja2VyIGVsZW1lbnQuCiAqIEBwYXJhbSB7c3RyaW5nfSBvdXRwdXRJZCBFbGVtZW50IElEIG9mIHRoZSBvdXRwdXQgZGlzcGxheS4KICogQHJldHVybiB7IUl0ZXJhYmxlPCFPYmplY3Q+fSBJdGVyYWJsZSBvZiBuZXh0IHN0ZXBzLgogKi8KZnVuY3Rpb24qIHVwbG9hZEZpbGVzU3RlcChpbnB1dElkLCBvdXRwdXRJZCkgewogIGNvbnN0IGlucHV0RWxlbWVudCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGlucHV0SWQpOwogIGlucHV0RWxlbWVudC5kaXNhYmxlZCA9IGZhbHNlOwoKICBjb25zdCBvdXRwdXRFbGVtZW50ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQob3V0cHV0SWQpOwogIG91dHB1dEVsZW1lbnQuaW5uZXJIVE1MID0gJyc7CgogIGNvbnN0IHBpY2tlZFByb21pc2UgPSBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gewogICAgaW5wdXRFbGVtZW50LmFkZEV2ZW50TGlzdGVuZXIoJ2NoYW5nZScsIChlKSA9PiB7CiAgICAgIHJlc29sdmUoZS50YXJnZXQuZmlsZXMpOwogICAgfSk7CiAgfSk7CgogIGNvbnN0IGNhbmNlbCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2J1dHRvbicpOwogIGlucHV0RWxlbWVudC5wYXJlbnRFbGVtZW50LmFwcGVuZENoaWxkKGNhbmNlbCk7CiAgY2FuY2VsLnRleHRDb250ZW50ID0gJ0NhbmNlbCB1cGxvYWQnOwogIGNvbnN0IGNhbmNlbFByb21pc2UgPSBuZXcgUHJvbWlzZSgocmVzb2x2ZSkgPT4gewogICAgY2FuY2VsLm9uY2xpY2sgPSAoKSA9PiB7CiAgICAgIHJlc29sdmUobnVsbCk7CiAgICB9OwogIH0pOwoKICAvLyBXYWl0IGZvciB0aGUgdXNlciB0byBwaWNrIHRoZSBmaWxlcy4KICBjb25zdCBmaWxlcyA9IHlpZWxkIHsKICAgIHByb21pc2U6IFByb21pc2UucmFjZShbcGlja2VkUHJvbWlzZSwgY2FuY2VsUHJvbWlzZV0pLAogICAgcmVzcG9uc2U6IHsKICAgICAgYWN0aW9uOiAnc3RhcnRpbmcnLAogICAgfQogIH07CgogIGNhbmNlbC5yZW1vdmUoKTsKCiAgLy8gRGlzYWJsZSB0aGUgaW5wdXQgZWxlbWVudCBzaW5jZSBmdXJ0aGVyIHBpY2tzIGFyZSBub3QgYWxsb3dlZC4KICBpbnB1dEVsZW1lbnQuZGlzYWJsZWQgPSB0cnVlOwoKICBpZiAoIWZpbGVzKSB7CiAgICByZXR1cm4gewogICAgICByZXNwb25zZTogewogICAgICAgIGFjdGlvbjogJ2NvbXBsZXRlJywKICAgICAgfQogICAgfTsKICB9CgogIGZvciAoY29uc3QgZmlsZSBvZiBmaWxlcykgewogICAgY29uc3QgbGkgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCdsaScpOwogICAgbGkuYXBwZW5kKHNwYW4oZmlsZS5uYW1lLCB7Zm9udFdlaWdodDogJ2JvbGQnfSkpOwogICAgbGkuYXBwZW5kKHNwYW4oCiAgICAgICAgYCgke2ZpbGUudHlwZSB8fCAnbi9hJ30pIC0gJHtmaWxlLnNpemV9IGJ5dGVzLCBgICsKICAgICAgICBgbGFzdCBtb2RpZmllZDogJHsKICAgICAgICAgICAgZmlsZS5sYXN0TW9kaWZpZWREYXRlID8gZmlsZS5sYXN0TW9kaWZpZWREYXRlLnRvTG9jYWxlRGF0ZVN0cmluZygpIDoKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ24vYSd9IC0gYCkpOwogICAgY29uc3QgcGVyY2VudCA9IHNwYW4oJzAlIGRvbmUnKTsKICAgIGxpLmFwcGVuZENoaWxkKHBlcmNlbnQpOwoKICAgIG91dHB1dEVsZW1lbnQuYXBwZW5kQ2hpbGQobGkpOwoKICAgIGNvbnN0IGZpbGVEYXRhUHJvbWlzZSA9IG5ldyBQcm9taXNlKChyZXNvbHZlKSA9PiB7CiAgICAgIGNvbnN0IHJlYWRlciA9IG5ldyBGaWxlUmVhZGVyKCk7CiAgICAgIHJlYWRlci5vbmxvYWQgPSAoZSkgPT4gewogICAgICAgIHJlc29sdmUoZS50YXJnZXQucmVzdWx0KTsKICAgICAgfTsKICAgICAgcmVhZGVyLnJlYWRBc0FycmF5QnVmZmVyKGZpbGUpOwogICAgfSk7CiAgICAvLyBXYWl0IGZvciB0aGUgZGF0YSB0byBiZSByZWFkeS4KICAgIGxldCBmaWxlRGF0YSA9IHlpZWxkIHsKICAgICAgcHJvbWlzZTogZmlsZURhdGFQcm9taXNlLAogICAgICByZXNwb25zZTogewogICAgICAgIGFjdGlvbjogJ2NvbnRpbnVlJywKICAgICAgfQogICAgfTsKCiAgICAvLyBVc2UgYSBjaHVua2VkIHNlbmRpbmcgdG8gYXZvaWQgbWVzc2FnZSBzaXplIGxpbWl0cy4gU2VlIGIvNjIxMTU2NjAuCiAgICBsZXQgcG9zaXRpb24gPSAwOwogICAgZG8gewogICAgICBjb25zdCBsZW5ndGggPSBNYXRoLm1pbihmaWxlRGF0YS5ieXRlTGVuZ3RoIC0gcG9zaXRpb24sIE1BWF9QQVlMT0FEX1NJWkUpOwogICAgICBjb25zdCBjaHVuayA9IG5ldyBVaW50OEFycmF5KGZpbGVEYXRhLCBwb3NpdGlvbiwgbGVuZ3RoKTsKICAgICAgcG9zaXRpb24gKz0gbGVuZ3RoOwoKICAgICAgY29uc3QgYmFzZTY0ID0gYnRvYShTdHJpbmcuZnJvbUNoYXJDb2RlLmFwcGx5KG51bGwsIGNodW5rKSk7CiAgICAgIHlpZWxkIHsKICAgICAgICByZXNwb25zZTogewogICAgICAgICAgYWN0aW9uOiAnYXBwZW5kJywKICAgICAgICAgIGZpbGU6IGZpbGUubmFtZSwKICAgICAgICAgIGRhdGE6IGJhc2U2NCwKICAgICAgICB9LAogICAgICB9OwoKICAgICAgbGV0IHBlcmNlbnREb25lID0gZmlsZURhdGEuYnl0ZUxlbmd0aCA9PT0gMCA/CiAgICAgICAgICAxMDAgOgogICAgICAgICAgTWF0aC5yb3VuZCgocG9zaXRpb24gLyBmaWxlRGF0YS5ieXRlTGVuZ3RoKSAqIDEwMCk7CiAgICAgIHBlcmNlbnQudGV4dENvbnRlbnQgPSBgJHtwZXJjZW50RG9uZX0lIGRvbmVgOwoKICAgIH0gd2hpbGUgKHBvc2l0aW9uIDwgZmlsZURhdGEuYnl0ZUxlbmd0aCk7CiAgfQoKICAvLyBBbGwgZG9uZS4KICB5aWVsZCB7CiAgICByZXNwb25zZTogewogICAgICBhY3Rpb246ICdjb21wbGV0ZScsCiAgICB9CiAgfTsKfQoKc2NvcGUuZ29vZ2xlID0gc2NvcGUuZ29vZ2xlIHx8IHt9OwpzY29wZS5nb29nbGUuY29sYWIgPSBzY29wZS5nb29nbGUuY29sYWIgfHwge307CnNjb3BlLmdvb2dsZS5jb2xhYi5fZmlsZXMgPSB7CiAgX3VwbG9hZEZpbGVzLAogIF91cGxvYWRGaWxlc0NvbnRpbnVlLAp9Owp9KShzZWxmKTsK",
              "ok": true,
              "headers": [
                [
                  "content-type",
                  "application/javascript"
                ]
              ],
              "status": 200,
              "status_text": ""
            }
          },
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "NEjzjxhWtt-6",
        "outputId": "28116b7e-fb98-491b-a268-99fe8e4ccd26"
      },
      "source": [
        "import numpy as np\n",
        "from google.colab import files\n",
        "from keras.preprocessing import image\n",
        "\n",
        "uploaded = files.upload()\n",
        "class_names = train_generator.class_indices #train_generator.class_names\n",
        "print(class_names)\n",
        "\n",
        "adjustable = \"francuz\"\n",
        "shape = \"ksztalt\"\n",
        "triangle = \"trojkat\"\n",
        "wrench = \"klucz\"\n",
        "good_adjustable = 0\n",
        "good_shape = 0\n",
        "good_traingle = 0\n",
        "good_wrench = 0\n",
        "adjustable_number = 0\n",
        "shape_number = 0\n",
        "triangle_number = 0\n",
        "wrench_number = 0\n",
        "#print(train_generator.class_indices)\n",
        "#print(\"[Shape Triangle Wrench Adjustable]\")\n",
        "for fn in uploaded.keys():\n",
        "  path = fn\n",
        "  img = image.load_img(path, target_size=(150, 150))\n",
        "  x = image.img_to_array(img)\n",
        "  x = np.expand_dims(x, axis=0)\n",
        "\n",
        "  images = np.vstack([x])\n",
        "  classes = model.predict(images, batch_size=64)\n",
        "  print(fn)\n",
        "  print(classes)\n",
        "\n",
        "  pred = np.argmax(classes) #wskazanie do ktorej klasy została przporzadkowana dana testowa\n",
        "  print(pred)               # wyświetlenie klasyfikacji\n",
        "  #print(np.max(score))      # wyświetlnie prawdopodobieństwa klasyfikacji\n",
        "  print(\"-----------\")\n",
        "  # predicting images\n",
        "  # print(\"---\")\n",
        "  # predict_classes=np.argmax(classes,axis=1)\n",
        "  # print(classes)\n",
        "  # print(predict_classes)\n",
        "  \n",
        "  # score = tf.nn.softmax(images)\n",
        "  # print(score)\n",
        "  # print(\"--------\")\n",
        "  # ##########################################Test https://www.tensorflow.org/tutorials/images/classification\n",
        "  #do sprawdzenia https://www.tensorflow.org/tutorials/keras/classification\n",
        "\n",
        "  img_array = tf.keras.utils.img_to_array(img)\n",
        "  img_array = tf.expand_dims(img_array, 0) # Create a batch\n",
        "\n",
        "  predictions = model.predict(img_array)\n",
        "  score = tf.nn.softmax(predictions[0])\n",
        "  # print(\n",
        "  #   \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n",
        "  #   .format(class_names[np.argmax(score)], 100 * np.max(score))\n",
        "  # )\n",
        "  print((score))      # wyświetlnie prawdopodobieństwa klasyfikacji\n",
        "  # if pred == 0:\n",
        "  #   output_class= \"adjustable_wrench\"\n",
        "  # elif pred ==1:\n",
        "  #   output_class= \"shape\"\n",
        "  # elif pred ==2:\n",
        "  #   output_class= \"triangle\"\n",
        "  # elif pred ==3:\n",
        "  #   output_class= \"wrench\"\n",
        "\n",
        "  # print(\"NN predict output is\"+output_class+\" with posibility =\")\n",
        "  #############################################\n",
        "  # print(\n",
        "  #   \"This image most likely belongs to {} with a {:.2f} percent confidence.\"\n",
        "  #   .format(classes[np.argmax(score)], 100 * np.max(score)))\n",
        "  \n",
        "  # #print(tf.keras.applications.imagenet_utils.decode_predictions(images, top=3))\n",
        "  # # find the index of the class with maximum score\n",
        "  # pred = np.argmax(classes)\n",
        "\n",
        "  # # print the label of the class with maximum score\n",
        "  # print(predict_classes[pred])\n",
        "  # print(pred)\n",
        "  print(\"----------------------------------\")\n",
        "  print(path.find(adjustable))\n",
        "  print(path.find(shape))\n",
        "  print(path.find(triangle))\n",
        "  print(path.find(wrench))\n",
        "  print(pred)\n",
        "  if (path.find(adjustable)>=0):\n",
        "    adjustable_number = adjustable_number+1\n",
        "    if pred == 0:\n",
        "      good_adjustable = good_adjustable+1\n",
        "  elif (path.find(shape)>=0):\n",
        "    shape_number = shape_number +1\n",
        "    if pred ==1:\n",
        "      good_shape = good_shape+1\n",
        "  elif (path.find(triangle)>=0):\n",
        "    triangle_number = triangle_number+ 1\n",
        "    if pred ==2:\n",
        "      good_traingle= good_traingle+1\n",
        "  elif (path.find(wrench)>=0):\n",
        "    wrench_number = wrench_number +1\n",
        "    if pred ==3:\n",
        "      good_wrench = good_wrench+1\n",
        "  print(\"Koniec----------------------------------\")\n",
        "print(\"good adjustable = \"+str(good_adjustable))\n",
        "print(\"Number of adjustable = \"+str(adjustable_number))\n",
        "print(\"good shape = \"+str(good_shape))\n",
        "print(\"Number of shape = \"+str(shape_number)) \n",
        "print(\"good triangle = \"+str(good_traingle)) \n",
        "print(\"Number of triangle = \"+str(triangle_number))\n",
        "print(\"good wrench = \"+str(good_wrench))       \n",
        "print(\"Number of wrench = \"+str(wrench_number))"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "\n",
              "     <input type=\"file\" id=\"files-5dfa6d0c-e38c-43e9-b112-5039dd470838\" name=\"files[]\" multiple disabled\n",
              "        style=\"border:none\" />\n",
              "     <output id=\"result-5dfa6d0c-e38c-43e9-b112-5039dd470838\">\n",
              "      Upload widget is only available when the cell has been executed in the\n",
              "      current browser session. Please rerun this cell to enable.\n",
              "      </output>\n",
              "      <script src=\"/nbextensions/google.colab/files.js\"></script> "
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving francuzMini211.bmp to francuzMini211 (5).bmp\n",
            "Saving kluczMini945.bmp to kluczMini945 (5).bmp\n",
            "Saving ksztaltMiniRot225_38.bmp to ksztaltMiniRot225_38 (5).bmp\n",
            "Saving trojkatmini304.bmp to trojkatmini304 (5).bmp\n",
            "{'adjustable': 0, 'shape': 1, 'triangle': 2, 'wrench': 3}\n",
            "francuzMini211.bmp\n",
            "[[1. 0. 0. 0.]]\n",
            "0\n",
            "-----------\n",
            "tf.Tensor([0.47536692 0.17487772 0.17487772 0.17487772], shape=(4,), dtype=float32)\n",
            "----------------------------------\n",
            "0\n",
            "-1\n",
            "-1\n",
            "-1\n",
            "0\n",
            "Koniec----------------------------------\n",
            "kluczMini945.bmp\n",
            "[[0. 0. 0. 1.]]\n",
            "3\n",
            "-----------\n",
            "tf.Tensor([0.1748777  0.1748777  0.1748777  0.47536686], shape=(4,), dtype=float32)\n",
            "----------------------------------\n",
            "-1\n",
            "-1\n",
            "-1\n",
            "0\n",
            "3\n",
            "Koniec----------------------------------\n",
            "ksztaltMiniRot225_38.bmp\n",
            "[[0. 1. 0. 0.]]\n",
            "1\n",
            "-----------\n",
            "tf.Tensor([0.17487772 0.47536692 0.17487772 0.17487772], shape=(4,), dtype=float32)\n",
            "----------------------------------\n",
            "-1\n",
            "0\n",
            "-1\n",
            "-1\n",
            "1\n",
            "Koniec----------------------------------\n",
            "trojkatmini304.bmp\n",
            "[[0. 0. 1. 0.]]\n",
            "2\n",
            "-----------\n",
            "tf.Tensor([0.1748777  0.1748777  0.47536686 0.1748777 ], shape=(4,), dtype=float32)\n",
            "----------------------------------\n",
            "-1\n",
            "-1\n",
            "0\n",
            "-1\n",
            "2\n",
            "Koniec----------------------------------\n",
            "good adjustable = 1\n",
            "Number of adjustable = 1\n",
            "good shape = 1\n",
            "Number of shape = 1\n",
            "good triangle = 1\n",
            "Number of triangle = 1\n",
            "good wrench = 1\n",
            "Number of wrench = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "background_save": true
        },
        "id": "9RVRShiq6EVf"
      },
      "source": [
        "\n",
        "# inkrement dobre wartosci\n",
        "wrench.find(\"s\")\n",
        "#find(\"adjustable\",path )\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 325
        },
        "id": "Akfdipe5LEnl",
        "outputId": "26891b1f-fe81-4b7d-f088-d459b8682428"
      },
      "source": [
        "# print(train_generator.labels)\n",
        "plt.figure(figsize=(10,10))\n",
        "for i in range(25):\n",
        "    plt.subplot(5,5,i+1)\n",
        "    plt.xticks([])\n",
        "    plt.yticks([])\n",
        "    plt.grid(False)\n",
        "    #plt.imshow(train_generator[i], cmap=plt.cm.binary)\n",
        "    plt.xlabel(class_names[train_generator.labels[i]])\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "ename": "KeyError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-20-6c98cf077b2b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;31m#plt.imshow(train_generator[i], cmap=plt.cm.binary)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m     \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mclass_names\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mtrain_generator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlabels\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyError\u001b[0m: 0"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHIAAABvCAYAAAAwlZQ4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAABYElEQVR4nO3UwU0DUQxAwf2IEsKZ7b+WpIicoQfTQFBYKRHwNHO1D5ae5DUzG//fy28fwGMIGSFkhJARQkYIGfF6ZPl0Os2+7086hXsul8vnzLzdmh0Kue/7dj6fH3MVh621rt/NvNYIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjBAyQsgIISOEjFgz8/PltT62bbs+7xzueJ+Zt1uDQyH5u7zWCCEjhIwQMkLICCEjhIwQMkLIiC8Hohp/BhBaQAAAAABJRU5ErkJggg==\n",
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "vSVBlkFbdxQx",
        "outputId": "31368c95-8f5a-489a-9c11-c5ad77810aee"
      },
      "source": [
        "#tf.keras.utils.plot_model(model, \"multi_input_and_output_model.png\", show_shapes=True)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "execution_count": 43,
          "metadata": {},
          "output_type": "execute_result"
        }
      ]
    }
  ]
}