Deep Learning parte 1: Keras

Conhecendo o conjunto de dados - Introdução

Sejam muito bem vindos e bem vindas a este curso introdutório de Deep Learning, essa palavra da moda, certo? Ou podemos dizer Redes Neurais Profundas; estou com o projeto que iremos fazer aberto no Notebook do Google Colab, e o que faremos neste curso? Trabalharemos com um e-commerce que trabalha com roupas e quer classificar as imagens dessas roupas.

Para isso utilizaremos um conjunto de dados, um dataset chamado Fashion-MNIST, organizado com imagens de várias roupas diferentes, e foi feito pelo grupo de pesquisa denominado Zalando Research. Além disso, faremos nosso código com a biblioteca do Google especializada em Redes Neurais Profundas chamada TensorGlow, como a nossa camada de mais baixo nível para comunicação com uma máquina.

Depois, escreveremos a maior parte do código usando Keras, API alto nível que está acima do TensorFlow, e faremos tudo isso usando a linguagem Python. Importaremos estas bibliotecas, carregar nosso dataset, explorar e exibir nossos dados, fazer um gráfico, também iremos normalizar esta imagem, criar, compilar, treinar e salvar nosso modelo. Visualizaremos a acurácia, a perda, e entender o que é isso durante o curso, saber se o modelo está indo bem, ou não, ajustá-lo, testá-lo e avaliá-lo.

Com isso começaremos a entender o que é este mundo de Deep Learning, e como nos locomovemos em todas estas probabilidades que não são tão exatas como gostaríamos. Recomendo que você tenha feito o primeiro curso de Machine Learning, do Guilherme Silveira, que isso nos ajudará bastante a entendermos o que estamos fazendo neste curso, até porque o tal do Deep Learning é uma subcategoria do Machine Learning.

Também recomendo que você faça os cursos de Python aqui na plataforma da Alura. Espero que vocês gostem bastante, e até o próximo vídeo.

Conhecendo o conjunto de dados - Carregando o dataset

Neste curso iremos trabalhar com um e-commerce, uma loja de roupas, e toda vez que subirmos uma imagem para a plataforma, teremos que escrever se ela é uma camiseta, bota, saia, ou seja, precisamos classificar esta imagem quando a colocamos no site. O que eles pediram foi que automatizássemos este processo, então, a partir do momento em que alguém coloca uma imagem nova no site, já tenhamos algo na máquina que entenda e classifique-a automaticamente.

Então, resolveremos um problema de classificação automática de imagens; já tínhamos algo parecido no curso de Machine Learning, em que pegávamos imagens de porcos e cachorros e, com base em 3 perguntas, se era gordinho, se tinha pernas curtas e se fazia óinc, a gente escrevia os dados e marcações, treinava o modelo chamado Multinomial NB, que fazia a classificação dessas imagens entre porco e cachorro.

Essa foi uma solução que demos ao problema de classificação de imagens. Mas agora, se pensarmos nas nossas roupas, como diferenciaremos uma camiseta de uma camisa, por exemplo? Porque as duas possuem gola, mangas, e podem ter botões. Entender quais perguntas fazer para o nosso conjunto de dados, não está tão simples, sem pensarmos em outros exemplos, saias, botas, tênis, calça, vestido.

Além disso, temos outro problema: agora teremos 70 mil imagens, então imagine escrever dados e marcações para essa quantidade de imagens com base nestas perguntas que já não estão fáceis de serem definidas. Usaremos, portanto, uma outra técnica, porque o que acontece é que o aprendizado de máquina é uma área grande, geral, que abrange tudo isso que ensinamos para uma máquina, e usaremos uma subcategoria dela para resolvermos este problema, que é o Deep Learning, que seria o aprendizado profundo de máquina.

Então, neste caso, pegaremos as imagens e, em vez de indicarmos as características delas, como fizemos no outro curso, usaremos funções que entenderão essas imagens e extrairão essas características, então não mais nomearemos, pois essas funções é que terão que entender o que se encontra nas imagens.

Essas funções, que também são uma rede de unidades, ou rede neural, irão classificar as nossas imagens também, do mesmo modo que fizemos com Machine Learning, também poderíamos classificá-las em duas ou mais categorias. A principal diferença, aqui, é que agora iremos extrair as características das próprias imagens, entendendo o que existe dentro delas com funções, não iremos mais ensinar um modelo.

Agora que já entendemos isso, e como iremos utilizar o Deep Learning para resolver este problema da nossa loja de roupas, podemos começar a fazer nosso código. Para facilitar e não temos que ficar instalando o Tensor Flow ou o Keras, vamos utilizar o notebook da própria Google, que se chama Colaboratory, escreverendo o código em Python 3.

Então, a primeira coisa a se fazer é criar o notebook em Python 3, em "File > New Python 3 notebook". Nosso notebook começará a ser carregado, e começaremos dando um título ao nosso arquivo, que neste caso será "classificacao_roupas.ipynb". Começaremos a escrever o código no centro de onde está o Play.

Para começar a classificar nossas imagens, precisamos das nossas imagens que, como vimos, têm o nome fashion_mnist. Usaremos este conjunto de dados, que se encontra no keras, que fica em cima do TensorFlow. Dentro do Keras, ele está em uma parte de conjunto de dados, ou datasets. É assim que acessamos um dataset dentro do Keras.

keras.datasets.fashion_mnist

Já sabemos que estamos identificando o caminho do fashion_mnist, podemos guardar isto em uma variável denominada datasets.

dataset = keras.datasets.fashion_mnist

Para começarmos a carregar estes dados, será que basta executar este pedaço de código? Vamos fazê-lo para ver o que acontece. Podemos clicar neste Play. Muitas vezes, esta primeira célula demora um pouco para executar, depois as próximas serão mais rápidas.

Executamos, e recebemos a mensagem de erro dizendo que keras não está definido. O que acontece é que estamos acessando uma coisa que não importamos. Para resolvermos este erro, daremos um Enter no código e faremos o importe do Keras. Mas vimos anteriormente que o Keras está acima do tensorflow, isto é, dentro dele.

Sendo assim, antes deste import temos que falar que o Keras está vindo do tensorflow, e assim temos nosso dataset.

from tensorflow import keras

Só que agora temos outro problema, porque onde está o tensorflow? Escreveremos mais uma linha para importá-lo também.

import tensorflow

Assim, importamos tensorflow, de que importamos keras, e dele pegamos nosso dataset chamado fashion_mnist.

Vamos executar novamente nosso código, para vermos o que acontece. Para fazê-lo sem que tenhamos que clicar no botão de Play, podemos usar Cmd + Enter ou Ctrl + Enter. Desta vez nosso código roda bem, mas nada é exibido. Do mesmo modo que só chamávamos o modelo no Machine Learning, aqui só falamos mais ou menos onde está o dataset, e precisaremos carregá-lo em nosso notebook.

Para isso, daremos um Enter no código e escreveremos dataset e chamaremos uma função do keras chamado carregar dados, que em inglês fica load_data.

dataset.load_data()

Executaremos novamente, agora sim, tivemos algum retorno, dois arrays dentro de parênteses. A função load_data devolve duas tuplas no Python, dois conjuntos de dados que não podem ser modificados. É uma lista que não sofre alterações.

Então podemos pegar estas duas tuplas, que são exatamente os nossos dados de treino e teste, e guardar em nossos dados de treino e teste. Para isso, na frente de dataset, abriremos e fecharemos parênteses, acrescentaremos uma vírgula, abrir e fechar parênteses novamente, e pedir para que a primeira tupla seja salva como imagens_treino, identificacoes_treino.

Colocaremos mais uma tupla, para testes, então imagens_teste, identificacoes_teste. Aqui, se você quiser manter o padrão visto, e imagens_treino e identificacoes_treino ficar como x, e imagens_teste e identificacoes_teste chamar de y, sem problemas. O importante é que você saiba que load_data está devolvendo uma tupla, e que agora salvamos isso dentro dela, basta incluirmos um operador de atribuição.

Vamos executar mais uma vez com Cmd + Enter, e nosso código está certo. Agora, se clicarmos na célula e dermos Enter, e se escrevermos imagens_treino, podemos rodar mais uma vez, e teremos que nosso array está dentro, certinho e bonitinho.

Continuaremos explorando e entendendo o que vem dentro de imagens_treino, identificacoes_treino, imagens_teste e identificacoes_teste, que imagens são essas.

Conhecendo o conjunto de dados - Entendendo as imagens

Vimos que imagens_treino volta esse array para nós, mas precisamos investigar para entendermos melhor o que isso quer dizer.

array([[[0, 0, 0 ..., 0, 0, 0],
        [0, 0, 0 ..., 0, 0, 0],
        [0, 0, 0 ..., 0, 0, 0],
        ...,
        [0, 0, 0 ..., 0, 0, 0],
        [0, 0, 0 ..., 0, 0, 0],
        [0, 0, 0 ..., 0, 0, 0]]])

Como de costume, podemos ver qual a extensão deste imagens_treino, então usaremos o len do Python para isso.

len(imagens_treino)


60000

Conseguimos com isso entender que são 60000 imagens que temos para treino. Mas qual é a composição, o formato dessas imagens?

Para falarmos isso, usaremos imagens_treino.shape, e executaremos novamente.

len(imagens_treino)
imagens_treino.shape

(60000, 28, 28)

Então, podemos ver que o primeiro elemento que volta nesta resposta de 60000 é a len da nossa imagem, depois temos 28, 28, o que significa que temos um array de 28 linhas e 28 colunas, então são 28 vezes 28 posições que estão descrevendo a nossa imagem.

Temos 60000 imagens, mas lembra que eu tinha dito que teríamos 70000? O que houve com essas outras 10000 imagens? Acabamos de ver as imagens de treino, vamos dar uma olhada nas de teste escrevendo imagens_teste.shape, pois sabemos que no próprio shape sabemos qual é a len de cada uma delas. Com Cmd + Enter executamos o código.

imagens_test.shape

(10000, 28, 28)

Aqui estão as nossas 10000 imagens, e agora temos 70000, todas com 28 por 28 de dimensão. Sabemos que as imagens de treino e as de teste têm o mesmo tamanho, o que é muito bom quando formos treinar a nossa rede. Olhamos as imagens, mas não vimos as identificações, será que elas estão batendo, com a quantidade de imagens que temos?

Usaremos o len(identificacoes_treino) para verificar, que será 60000, como esperado, então podemos dar uma olhada nas de teste, para ver se está batendo. Teremos 10000, então nossas identificações ou labels estão batendo com as imagens. Legal, mas que imagens são essas, que até então não visualizamos?

Para isso, vamos usar uma biblioteca do Python chamada matplotlib, uma "lib" de biblioteca, "plot" de plotar, desenhar o gráfico, e "mat" de matemática. Usaremos algo interno a ela, específico para visualizarmos a nossa imagem, que se chama pyplot. E como vimos, para podermos usar o que está dentro dele, teremos que importá-lo, como plt. Trata-se de uma convenção dentro do Python, quando você vir já vai saber que vem do pyplot do matplotlib.

import matplotlib.pyplot as plt

Vamos executar a célula mais uma vez, agora podemos dar um Enter e tentar visualizar essa imagem. Para isso usaremos o imshow() do matplotlib, "im" de imagem e "show" de mostrar.

Dentro dessa função, vamos passar nossa primeira imagem, no caso, imagens_treino, colocando entre colchetes o índice 0, e como o imshow() está dentro do pyplot e o chamamos de plt, escreveremos, antes de imshow(), plt..

plt.imshow(imagens_treino[0])

Vamos executar e ver o que acontece? Já temos uma imagem. À esquerda, a numeração vai de 0 a pouco mais de 25, daquelas 28 dimensões que tínhamos falado, enquanto na base os números vão de 0 a pouco mais de 25 novamente.

Podemos ver que é uma imagem de 28 por 28 espaços, ou pixels, e cada um desses traz essa informação, que conseguimos visualizar agora.

A partir disso, vamos seguir com nosso projeto e código.

Sobre o curso Deep Learning parte 1: Keras

O curso Deep Learning parte 1: Keras possui 160 minutos de vídeos, em um total de 53 atividades. Gostou? Conheça nossos outros cursos de Machine Learning em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Conhecendo o conjunto de dados
• Começando a montar o modelo
• Adicionando camadas ocultas
• Ensinando o modelo
• Sabendo como medir o resultado do modelo
• Ajustando e salvando o modelo
• Revisando conceitos chave