art_classifier_final.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "art_classifier (1).ipynb",
      "version": "0.3.2",
      "provenance": []
    },
    "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.7.3"
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "N_TQRWLbqilU",
        "colab_type": "text"
      },
      "source": [
        "This script was made based on Tensorflow's tutorial: https://www.tensorflow.org/tutorials/load_data/images"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "95DooHwYqilW",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# imports\n",
        "\n",
        "from __future__ import absolute_import, division, print_function, unicode_literals\n",
        "import pathlib\n",
        "import random\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import tensorflow as tf\n",
        "\n",
        "tf.enable_eager_execution()  \n",
        "\n",
        "AUTOTUNE = tf.data.experimental.AUTOTUNE  # decidir o número de núcleos do processador a ser utilizado\n",
        "EPOCHS = 500\n",
        "IMG_W = 96\n",
        "IMG_H = 96\n",
        "TRAIN_TEST_RATIO = 0.8"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g_9EWSCOqilb",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "data_root = pathlib.Path('quadros')\n",
        "all_image_paths = list(data_root.glob('*/*.jpg'))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ZGNDwZAqilf",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "all_image_paths = [str(path) for path in all_image_paths]\n",
        "random.shuffle(all_image_paths)\n",
        "\n",
        "image_count = len(all_image_paths)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z9EqEz3Oqilj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "label_names = sorted(item.name for item in data_root.glob('*/') if item.is_dir())\n",
        "label_to_index = dict((name, index) for index,name in enumerate(label_names))\n",
        "all_image_labels = [label_to_index[pathlib.Path(path).parent.name] for path in all_image_paths]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y7WiFg1nqiln",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#pre-processamento\n",
        "\n",
        "def preprocess_image(image):\n",
        "  image = tf.image.decode_jpeg(image, channels=3)  #  carrega as imagens pra memória\n",
        "  image = tf.image.resize(image, [IMG_W, IMG_H])  #  redimensiona elas, porem causa distorcao\n",
        "  #image = tf.image.resize_image_with_pad(image, IMG_W, IMG_H) #Metodo que redimensiona e nao causa distorcoes na imagem\n",
        "  image = tf.image.rgb_to_grayscale(image)  #  trás pra escala de cinza [W x H x 3] -> [W x H]\n",
        "  image = tf.reshape(image, (9216,))  #  transforma em um vetor\n",
        "  image /= 255.0 # normaliza para o intervalo [0,1]\n",
        "  return image\n",
        "\n",
        "def load_and_preprocess_image(path):\n",
        "  image = tf.read_file(path)\n",
        "  return preprocess_image(image)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uA4zfvO1qilq",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#tensorflow dataset\n",
        "\n",
        "path_ds = tf.data.Dataset.from_tensor_slices(all_image_paths)\n",
        "\n",
        "image_ds = path_ds.map(load_and_preprocess_image, num_parallel_calls=AUTOTUNE)\n",
        "label_ds = tf.data.Dataset.from_tensor_slices(tf.cast(all_image_labels, tf.int64))\n",
        "\n",
        "image_label_ds = tf.data.Dataset.zip((image_ds, label_ds))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IbJ1OvjKqilt",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#preparando o dataset para ser treinado\n",
        "\n",
        "BATCH_SIZE = int(image_count * TRAIN_TEST_RATIO)  #para treinar o dataset completo em todas as epocas\n",
        "\n",
        "test_dataset = image_label_ds.skip(image_count - BATCH_SIZE) \n",
        "train_dataset = image_label_ds.take(BATCH_SIZE)\n",
        "\n",
        "ds = train_dataset.shuffle(buffer_size=BATCH_SIZE)\n",
        "ds = ds.repeat()\n",
        "ds = ds.batch(BATCH_SIZE)\n",
        "\n",
        "ds = ds.prefetch(buffer_size=AUTOTUNE)\n",
        "\n",
        "tds = test_dataset.shuffle(buffer_size=image_count-BATCH_SIZE)\n",
        "tds = tds.repeat()\n",
        "tds = tds.batch(image_count - BATCH_SIZE)\n",
        "tds = tds.prefetch(buffer_size=AUTOTUNE)\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iei9mVyBqilw",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Definindo o modelo da rede\n",
        "\n",
        "model = tf.keras.Sequential()\n",
        "model.add(tf.keras.layers.Dense(4608, input_dim=9216, activation='relu'))\n",
        "#model.add(tf.keras.layers.Dropout(0.25)) \n",
        "model.add(tf.keras.layers.Dense(2304, activation='relu'))\n",
        "#model.add(tf.keras.layers.Dropout(0.25))\n",
        "model.add(tf.keras.layers.Dense(19, activation='softmax'))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5hQpW6Fzqily",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "model.compile(\n",
        "    optimizer = 'SGD', \n",
        "    loss = tf.keras.losses.sparse_categorical_crossentropy,\n",
        "    metrics = [\"accuracy\"]\n",
        ")\n",
        "model.summary()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WLYMZUwNqil3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#treinando o modelo\n",
        "H = model.fit(\n",
        "    ds,  #dataset\n",
        "    epochs=EPOCHS,  \n",
        "    steps_per_epoch=int(len(all_image_paths)/BATCH_SIZE),  \n",
        ")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_6fpwVkDqil7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "score = model.evaluate(tds, verbose=1, steps=int(image_count - BATCH_SIZE))\n",
        "print('Test loss:', score[0])\n",
        "print('Test accuracy:', score[1])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q7gCRdu4qil-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Plotando no grafico\n",
        "\n",
        "plt.figure()\n",
        "plt.plot(np.arange(0, EPOCHS), H.history[\"loss\"], label=\"train_loss\")\n",
        "plt.plot(np.arange(0, EPOCHS), H.history[\"acc\"], label=\"train_acc\")\n",
        "# plt.plot(np.arange(0, EPOCHS), H.history[\"val_acc\"], label=\"val_acc\")\n",
        "# plt.plot(np.arange(0, EPOCHS), H.history[\"val_loss\"], label=\"val_loss\")\n",
        "plt.title(\"Accuracy\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Loss/Accuracy\")\n",
        "plt.legend()\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}