5.6-MNIST_ConclusaoEstudo.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMg6IDKi4YhNNHCHrYPsW6k"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "#MNIST - Conclusão dos Estudos"
      ],
      "metadata": {
        "id": "qfCalkYkTKHc"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mKtJxZ2KTCWH"
      },
      "outputs": [],
      "source": [
        "import warnings; warnings.simplefilter('ignore')\n",
        "\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib\n",
        "import tensorflow as tf\n",
        "import requests\n",
        "import joblib\n",
        "\n",
        "from keras.datasets import mnist\n",
        "from tensorflow import keras\n",
        "from io import BytesIO\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Carregar um dígito do Dataset original"
      ],
      "metadata": {
        "id": "sIV0f9TyTV3u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "(X_train, y_train), (X_test, y_test) = mnist.load_data()\n",
        "X_train = (X_train.astype(np.float32) - 127.5)/127.5  \n",
        "X_train = X_train.reshape(60000, 784)"
      ],
      "metadata": {
        "id": "D-Z7CbbNTQ34"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#indice = 1980 #4\n",
        "#indice = 666 #7\n",
        "#indice = 1234 #8\n",
        "#indice = 100 #6\n",
        "indice = 1983 #3\n",
        "\n",
        "digitoDataset = X_test[indice]\n",
        "print(\"Distribuição dos pixels originalmente: \" + str(digitoDataset.shape))\n",
        "\n",
        "digitoDataset = digitoDataset.reshape(28,28)\n",
        "print(\"Distribuição dos pixels redistribuído para 28X28: \" + str(digitoDataset.shape))\n",
        "\n",
        "print(\"No dataset, representa o numero: %d\" % y_test[indice])\n",
        "\n",
        "plt.figure(figsize=(0.28, 0.28))\n",
        "plt.imshow(digitoDataset, cmap=matplotlib.cm.binary)\n",
        "plt.axis('off')\n",
        "plt.subplot()    \n",
        "plt.tight_layout()\n",
        "plt.savefig(\"digito_gerado.png\", dpi=100)\n",
        "plt.show()\n",
        "\n",
        "digito = digitoDataset.reshape(1,784)"
      ],
      "metadata": {
        "id": "bEnjb_AVTQ8m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Carregar o gerador e criar um novo dígito"
      ],
      "metadata": {
        "id": "TCZcBSkLTbR9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!wget \"https://github.com/diegonogare/MachineLearning/blob/main/gerador.h5?raw=true\""
      ],
      "metadata": {
        "id": "uH-qGd0M98ol"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!mv \"/content/gerador.h5?raw=true\" \"/content/gerador.h5\""
      ],
      "metadata": {
        "id": "Y8nLNRC6-G8b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "z_dim = 100\n",
        "\n",
        "g = keras.models.load_model('/content/gerador.h5')\n",
        "g.summary()"
      ],
      "metadata": {
        "id": "pKJZlrbETQ-8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "A Rede Geradora de uma GAN é um tipo de modelo de aprendizado de máquina que é capaz de gerar novas imagens a partir de um conjunto de treinamento. Em geral, a arquitetura de uma rede geradora GAN é composta por três componentes principais:\n",
        "\n",
        "* Uma camada de entrada que recebe as informações sobre o que a rede geradora deve gerar. Isso pode incluir dados aleatórios, como ruído branco, ou informações sobre a classe de imagem que a rede deve gerar, como \"gato\" ou \"cachorro\".\n",
        "* Várias camadas de processamento que manipulam os dados de entrada e os transformam em imagens. Essas camadas podem incluir camadas de convolução, camadas de normalização, entre outras.\n",
        "* Uma camada de saída que produz a imagem gerada pela rede. Esta camada pode ser uma camada de deconvolução que amplia a imagem gerada ou uma camada de ativação que aplica uma função de ativação para a imagem gerada."
      ],
      "metadata": {
        "id": "NpbFNFynx9sF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def gerar_digito(n_ex=10, dim=(1, 10), figsize=(2, 2)):\n",
        "    noise = np.random.normal(0, 1, size=(n_ex, z_dim))\n",
        "    generated_images = g.predict(noise)\n",
        "    generated_images = generated_images.reshape(28, 28)\n",
        "    \n",
        "    plt.figure(figsize=figsize)\n",
        "    plt.imshow(generated_images, interpolation='nearest', cmap=matplotlib.cm.binary)\n",
        "    plt.axis('off')\n",
        "    plt.subplot()    \n",
        "    plt.tight_layout()\n",
        "    plt.savefig(\"digito_gerado.png\")\n",
        "\n",
        "    plt.show()  "
      ],
      "metadata": {
        "id": "QGd3HVmLTRBV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "gerar_digito(n_ex=1)"
      ],
      "metadata": {
        "id": "WYs0rG8nTRDH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Transformar a imagem em um array de pixels"
      ],
      "metadata": {
        "id": "vGAa_MjXTqio"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "image_list = '/content/digito_gerado.png'\n",
        "array_list = tf.keras.preprocessing.image.img_to_array(tf.keras.preprocessing.image.load_img(image_list, color_mode='grayscale', target_size=(28,28))).reshape(1,784).astype(np.int32)\n",
        "\n",
        "plt.imshow(array_list.reshape(28,28), cmap='gray')\n",
        "plt.axis('off')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "xfmk_lP4ToJJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Carregar os modelos treinados"
      ],
      "metadata": {
        "id": "3gcQkBH0T1RI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mLink = 'https://github.com/diegonogare/MachineLearning/blob/main/modelo_dt_mnist.pkl?raw=true'\n",
        "mfile = BytesIO(requests.get(mLink).content)\n",
        "modelo_dt = joblib.load(mfile)\n",
        "\n",
        "mLink = 'https://github.com/diegonogare/MachineLearning/blob/main/modelo_knn_mnist.pkl?raw=true'\n",
        "mfile = BytesIO(requests.get(mLink).content)\n",
        "modelo_knn = joblib.load(mfile)\n",
        "\n",
        "mLink = 'https://github.com/diegonogare/MachineLearning/blob/main/modelo_mlp_mnist.pkl?raw=true'\n",
        "mfile = BytesIO(requests.get(mLink).content)\n",
        "modelo_mlp = joblib.load(mfile)"
      ],
      "metadata": {
        "id": "tAOOnN0YTRFl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Predizer qual é o digito gerado"
      ],
      "metadata": {
        "id": "aPma7L9hT4Py"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "imprimir_digito = abs(255-array_list) #Numero gerado\n",
        "\n",
        "plt.imshow(imprimir_digito.reshape(28,28), cmap='gray')\n",
        "plt.axis('off')\n",
        "plt.show()\n",
        "\n",
        "predicao_dt = modelo_dt.predict(imprimir_digito)\n",
        "predicao_dt = predicao_dt.astype(np.int64)\n",
        "\n",
        "predicao_knn = modelo_knn.predict(imprimir_digito)\n",
        "predicao_knn = predicao_knn.astype(np.int64)\n",
        "\n",
        "predicao_mlp = modelo_mlp.predict(imprimir_digito)\n",
        "predicao_mlp = predicao_mlp.astype(np.int64)\n",
        "\n",
        "print(\"Com Decisin Tree o modelo identificou: \", predicao_dt);\n",
        "print(\"Com KNN o modelo identificou: \", predicao_knn);\n",
        "print(\"Com MultiLayer Perceptron o modelo identificou: \", predicao_mlp);"
      ],
      "metadata": {
        "id": "XjhiA9lSTvfF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Referência\n",
        "\n",
        "Goodfellow, Ian, et al. \"Generative adversarial nets.\" Advances in neural information processing systems, 2014, pp. 2672-2680."
      ],
      "metadata": {
        "id": "PKDLavYdyLdd"
      }
    }
  ]
}