Apresentacao.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1><b>Projeto 2<br>Aprendizado de máquina: reconhecimento de números</b></h1><br>\n",
    "<h1>Introdução</h1><br>\n",
    "Machine Learning, ou aprendizado de máquina, é uma  área da inteligência artificial onde é possível criar algoritmos para ensinar uma máquina a desempenhar tarefas que automatizam modelos analíticos e estocásticos.\n",
    "\n",
    "Baseia-se na ideia de que sistemas podem aprender com dados, identificar padrões e tomar decisões com o mínimo de intervenção humana. Ou seja, pega-se um conjunto de dados de entrada e com base em determinados padrões encontrados gera-se saídas das quais podem ser usadas para diversos fins. Muitas de nossas atividades diárias são alimentadas por algoritmos de machine learning que podem incluir:\n",
    "\n",
    "* Detecção de fraudes.\n",
    "* Resultados de pesquisa na Web.\n",
    "* Anúncios em tempo real, tanto em páginas da web como em dispositivos móveis.\n",
    "* Pontuação de crédito e melhores ofertas.\n",
    "* Previsão de falhas em equipamento.\n",
    "* Detecção de invasão em uma determinada rede.\n",
    "* Reconhecimento de determinados padrões e imagens.\n",
    "\n",
    "Na década de 1950, o pai da computação, Alan Turing, fez a célebre pergunta: “As máquinas podem pensar?”. Nessa época, ele desenvolveu o famoso Teste de Turing, que testava a capacidade das máquinas de raciocinar como seres humanos.\n",
    "\n",
    "Alguns anos depois, em 1952, um engenheiro do MIT e pioneiro em inteligência artificial Arthur Samuel criou o primeiro programa capaz de aprender. Tratava-se de um jogo de damas que ia melhorando seu desempenho a cada partida, estudando movimentos e propondo novas estratégias. Esse passo foi fundamental para que, em 1959, Samuel usasse pela primeira vez o termo <b>machine learning</b>.\n",
    "\n",
    "<h1>Conceitos</h1><br>\n",
    "As redes neurais artificiais são baseadas nas tentativas de simular o sistema nervoso humano no que se refere a sua capacidade de aprender e de se adaptar, em outras palavras, uma simulação muito simplificada da operação do cérebro humano. Estas redes neurais artificiais são constituídas de neurônios artificiais.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/neuron.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 1 - Diagramação de um neurônio artificial.</center>\n",
    "\n",
    "A estrutura de um neurônio pode ser representada como uma composição das seguintes unidades:\n",
    "* Entrada de dados: <b>Xi,...,Xn</b>;\n",
    "\n",
    "* Pesos: <b>Wi,...,Wn</b>;\n",
    "\n",
    "* Função de transferência: <b>$\\sum$</b>;\n",
    "\n",
    "* Entrada de rede de um neurônio: <b>NET</b>;\n",
    "\n",
    "* Função de ativação: <b>F(x)</b>;\n",
    "\n",
    "* Saída: <b>Out.</b>\n",
    "\n",
    "Porém, podemos agora pensar como uma rede de neurônios funciona e com isto, o esquema muda um pouco. A camada de entradas se mantém, mas por outro lado, as camadas intermediárias passam a interagir, buscar padrões, refinar e redefinir opções para melhor processar os dados até que se tenha uma saída.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/neuronet__1.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 2 - Esquema de uma rede neural artificial.</center>\n",
    "\n",
    "Alternativamente, no caso de reconhecimento de números, temos ao todo 10 números (do 0 ao 9), ou seja 10 nós, fazendo as interações passamos para 512 nós por cada camada de interação. Quanto mais camadas, mais vai demandar do seu computador.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/neuronet_nodes.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 3 - Esquema de interações por camadas.</center>\n",
    "\n",
    "Mas para a máquina aprender, precisa-se que seja ensinado a ela como \"pensar\". Para isto, existem algumas metodologias que se adaptam melhor para cada tipo de problema a ser estudado pela máquina.\n",
    "\n",
    "* <b>Aprendizado supervisionado:</b> que consiste em exemplos rotulados. O algoritmo de aprendizagem recebe um conjunto de entradas junto com as saídas corretas correspondentes, e o algoritmo aprende comparando a saída real com as saídas corretas para encontrar erros. Em seguida, ele modifica o modelo de acordo com o que foi aprendido.\n",
    "\n",
    "* <b>Aprendizado não supervisionado:</b> é usado em dados que não possuem uma saída certa correspondente. O algoritmo deve descobrir o que está sendo mostrado e tem por objetivo explorar os dados e assim encontrar alguma estrutura neles. O aprendizado não supervisionado funciona bem em dados transacionais.\n",
    "\n",
    "* <b>Aprendizado semisupervisionado:</b> geralmente é usado para as mesmas aplicações que o aprendizado supervisionado, porém ele pode usar tanto dados rotulados quanto não rotulados para o treinamento. Normalmente, utiliza-se uma pequena quantidade de dados rotulados com uma grande quantidade de dados não rotulados. Esse tipo de aprendizagem pode ser usado com métodos como a classificação, regressão e previsão. Os primeiros exemplos disso incluem a identificação do rosto de uma pessoa em uma webcam.\n",
    "\n",
    "* <b>Aprendizado por reforço:</b> essa opção é muitas vezes usado para a robótica, jogos e navegação. Com o aprendizado por reforço, o algoritmo descobre por meio de tentativa e erro quais ações geram as melhores recompensas.\n",
    "\n",
    "Então, o processo de aprendizado de máquina pode ser entendido pelas seguintes etapas mostradas na figura abaixo.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/fluxograma%20machine%20learning.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 4 - Fluxograma simplificado: machine learning.</center>\n",
    "\n",
    "* Etapa 1: Pensar no problema a ser estudado;\n",
    "* Etapa 2: Prepare seus dados (dados brutos, extração de recursos, etc.);\n",
    "* Etapa 3: Verificação dos algoritmos;\n",
    "* Etapa 4: Examinar os resultados;\n",
    "* Etapa 5: Reforçar o treino dos algoritmos que melhor trabalharam.\n",
    "\n",
    "Como queremos reconhecer caracteres (números) a partir de imagens, trabalharemos com a rede neural convolucional (CNN), que basicamente, é um tipo especial de rede neural que realiza bem tarefas de compreensão de imagem. Operam diretamente nas intensidades de pixel da imagem de entrada - sem necessidade de executar a extração de recurso!\n",
    "\n",
    "Internamente, cada camada de convolução de uma CNN está aprendendo uma forma de extrair características da imagem (filtros). Aplica-se a convolução a esses filtros juntamente com as imagens de entrada e os padrões são aprendidos automaticamente.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/convolu%C3%A7%C3%A3o%20neural.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 5 - Esquema de uma rede neural convolucional.</center>\n",
    "\n",
    "<h1>Camada de convolução</h1><br>\n",
    "\n",
    "É a primeira camada onde são extraídas característcas pela passagem do kernel (filtro) pela imagem.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/conv.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 6 - Esquema de convolução de uma CNN.</center>\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/Convolution_schematic.gif?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 7 - Animação de como acontece a convolução de uma CNN.</center>\n",
    "\n",
    "<h1>Camada de Pooling</h1><br>\n",
    "\n",
    "Quando se contrói uma CNN, é comum inserir camadas de pooling, onde reduz o tamanho espacial da representação pegando o valor máximo de cada kernel.\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/pool.png?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 8 - Esquema de pooling de uma CNN.</center>\n",
    "\n",
    "<img src=\"https://github.com/wars2/mnist-intropython/blob/master/Imagens/maxpool_animation.gif?raw=true\" align=\"center\"></img>\n",
    "<center>Figura 9 - Animação de como acontece o pooling de uma CNN.</center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1>O programa</h1><br>O programa foi separado em partes para melhor compreensão do mesmo. O primeiro bloco importa todos os módulos necessários para rodar o programa (Keras, Numpy, OpenCV, SYS, OS e Time)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "\"\"\"\n",
    "Created on 10/07/2019 - 13:57:43\n",
    "@author: Hamilton S. Gama Filho e Hugo B. S. Borges\n",
    "\"\"\"\n",
    "\n",
    "from keras.datasets import mnist\n",
    "from keras.utils import to_categorical\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Conv2D, Flatten\n",
    "from keras import backend as K\n",
    "from keras.layers.convolutional import MaxPooling2D\n",
    "from keras.layers import Dropout\n",
    "import numpy as np\n",
    "import cv2\n",
    "import sys\n",
    "import os\n",
    "import time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Roda os dois módulos criados para formatar a imagem no padrão MNIST e criar o modelo de análise para predição."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def img_to_array(img, image_data_format='default'):\n",
    "    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    img = cv2.bitwise_not(img)\n",
    "\n",
    "    if image_data_format == \"default\":\n",
    "        image_data_format = K.image_data_format()\n",
    "\n",
    "    if image_data_format not in ['channels_first', 'channels_last']:\n",
    "        raise Exception('Formato da imagem desconhecido: ', image_data_format)\n",
    "\n",
    "    x = np.asarray(img, dtype=K.floatx())\n",
    "\n",
    "    # imagem colorida\n",
    "    # (channel, height, width)\n",
    "    if len(x.shape) == 3:\n",
    "        if image_data_format == 'channels_first':\n",
    "            x = x.transpose(2, 0, 1)\n",
    "\n",
    "    # grayscale\n",
    "    elif len(x.shape) == 2:\n",
    "        # already for th format\n",
    "        x = np.expand_dims(x, axis=0)\n",
    "        if image_data_format == 'channels_last':\n",
    "            #(height, channel, width)\n",
    "            x = x.reshape((x.shape[1], x.shape[2], x.shape[0]))\n",
    "            #print(\"CHANNEL\")\n",
    "            #print(x.shape[2])\n",
    "    # quando o tipo for desconhecido\n",
    "    else:\n",
    "        raise Exception('Formato da imagem não suportado: ', x.shape)\n",
    "\n",
    "    return x\n",
    "#-----------------------------------------------------------------------------------------------------\n",
    "def base_model():\n",
    "    model = Sequential()\n",
    "    # add model layers\n",
    "    model.add(Conv2D(64, kernel_size=3, activation='relu', input_shape=(28, 28, 1)))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Conv2D(15, (3, 3), activation='relu'))\n",
    "    model.add(MaxPooling2D(pool_size=(2, 2)))\n",
    "    model.add(Dropout(0.2))\n",
    "    model.add(Flatten())\n",
    "    model.add(Dense(128, activation='relu'))\n",
    "    model.add(Dense(50, activation='relu'))\n",
    "    model.add(Dense(num_classes, activation='softmax'))\n",
    "\n",
    "    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])\n",
    "\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Roda o programa de treino ou predição, de acordo com o argumento colocado, ou seja, se não tiver argumento para o diretório o programa realizará o treino na máquina. Caso haja um argumento para o diretório ele analisará os arquivos e fará a predição."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "print(\"Número de classes\")\n",
    "print(np.unique(y_train))\n",
    "\n",
    "x_train = x_train.reshape(60000,28, 28, 1)\n",
    "x_test = x_test.reshape(10000,28,28, 1)\n",
    "y_train = to_categorical(y_train)\n",
    "y_test = to_categorical(y_test)\n",
    "\n",
    "global num_pixels\n",
    "num_pixels = x_train.shape[1] * x_train.shape[2]\n",
    "\n",
    "model_name = str(sys.argv[0]).split(\".\")[0]+\".h5\" # cria o modelo com o nome do script python.\n",
    "\n",
    "batch_size  = 32 \n",
    "num_classes = 10\n",
    "epochz      = 6 # Nao precisa mais que 1 epoch para o MNIST(treino). Evite overfitting.\n",
    "\n",
    "global density\n",
    "density     = 128\n",
    "\n",
    "#se não tem argumento para o programa, faz o treino e salva o modelo com o nome do script python.\n",
    "if len(sys.argv) == 1:\n",
    "    cnn_n = base_model()\n",
    "    cnn_n.summary()\n",
    "    cnn = cnn_n.fit(x_train, y_train, batch_size=batch_size, epochs=epochz, validation_data=(x_test,y_test),shuffle=True)\n",
    "    cnn_n.save_weights(model_name, overwrite=True)\n",
    "\n",
    "    scores = cnn_n.evaluate(x_test, y_test, verbose=0)\n",
    "    print(\"Acurácia: %.2f%%\" % (scores[1] * 100))\n",
    "\n",
    "#se tiver argumento, faz predição do diretório de imagem passado como parametro\n",
    "else:\n",
    "    if not os.path.isdir(sys.argv[1]):\n",
    "        print(\"Diretório não encontrado. Saindo...\")\n",
    "        exit(0)\n",
    "\n",
    "    #faz loop nos arquivos e limpa os nomes\n",
    "    directory = sys.argv[1]\n",
    "    files     = os.listdir(directory)\n",
    "\n",
    "    files = [w.replace(\"\\n\", \"\") for w in files]\n",
    "    #print(files)\n",
    "\n",
    "    #se for diretório vazio, sai sem dar erro\n",
    "    if len(files) < 1:\n",
    "        print(\"Não existe arquivos no diretório: \\'\"+directory+\"\\'. Saindo...\")\n",
    "        exit(0)\n",
    "\n",
    "    #se tiver arquivos, faz a predição\n",
    "    cnn_n = base_model()\n",
    "    cnn_n.load_weights(model_name)\n",
    "\n",
    "    font = cv2.FONT_HERSHEY_SIMPLEX\n",
    "\n",
    "    #lê imagens de um diretório e redimensiona para o padrão do MNIST\n",
    "    for filename in files:\n",
    "        print(filename)\n",
    "        img = cv2.imread(directory + \"/\" +filename)\n",
    "        img = cv2.resize(img, (28, 28), 1)\n",
    "\n",
    "        xxx = img_to_array(img)\n",
    "        #print(str(xxx.shape))\n",
    "        xxx = np.expand_dims(xxx, axis=0)\n",
    "        #print(str(xxx))\n",
    "\n",
    "        start_t = time.time()\n",
    "\n",
    "        res = cnn_n.predict(xxx, verbose=0)\n",
    "\n",
    "        print(\"res.argmax e res 0 argmax\")\n",
    "        print(res.argmax())\n",
    "        print(res[0][res.argmax()])\n",
    "        #print(res[0])\n",
    "\n",
    "        detected = res.argmax()\n",
    "\n",
    "        print(round(res[0][res.argmax()]*100))\n",
    "\n",
    "        imgRead = cv2.imread(directory + \"/\" + filename, cv2.IMREAD_GRAYSCALE)\n",
    "        cv2.putText(imgRead, str(res.argmax()), (2, 22), font, 1, (100, 100, 100), 2, cv2.LINE_AA)\n",
    "\n",
    "        cv2.imshow(\"MINIST\", imgRead)\n",
    "        pressed = cv2.waitKey(0)\n",
    "        if pressed == 27:\n",
    "            exit(0)\n",
    "        cv2.destroyAllWindows()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Referências:</h2><br>\n",
    "\n",
    "* https://www.cetax.com.br/blog/machine-learning/\n",
    "\n",
    "* https://www.dobitaobyte.com.br/como-fazer-predicao-com-mnist-usando-arquivos-externos/\n",
    "\n",
    "* https://penseallen.github.io/PensePython2e/\n",
    "\n",
    "* https://github.com/wxs/keras-mnist-tutorial/blob/master/MNIST%20in%20Keras.ipynb\n",
    "\n",
    "* https://scikit-learn.org/stable/auto_examples/classification/plot_digits_classification.html#sphx-glr-auto-examples-classification-plot-digits-classification-py\n",
    "\n",
    "* https://medium.com/data-hackers/entendendo-o-que-%C3%A9-matriz-de-confus%C3%A3o-com-python-114e683ec509\n",
    "\n",
    "* https://towardsdatascience.com/image-classification-in-10-minutes-with-mnist-dataset-54c35b77a38d"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}