Deep Learning parte 2: como a rede aprende

Indo por dentro da rede neural - Introdução

Sejam bem-vindos e bem-vindas à segunda parte do nosso curso de deep learning. Aqui seremos mais teóricos, tentaremos mostrar ilustrando o que acontece por debaixo do pano do nosso modelo.

Por exemplo, vamos ver o sumário do modelo, os shapes de output, o que está saindo e entrando nas camadas, quais nossos parâmetros, por que eles são treináveis. Vamos entender o que são os pesos de uma camada. Como esses parâmetros podem alterar ou não nosso modelo.

Também vamos ver o que são outros parâmetros, como esses vieses. Vamos entender o que acontece quando inicializamos, não inicializamos, o que pode acontecer. Vamos entender o que está acontecendo por dentro da relu, o que acontece quando passamos todos esses parâmetros dentro da nossa rede neural.

Veremos outras maneiras de salvar o modelo. Vamos usar outros call-backs do Keras. Vamos aprender a mexer com hiper parâmetros, que fazemos antes de treinar o modelo. Vamos ver tudo isso para ter um entendimento melhor do que está acontecendo na nossa rede neural, vamos entender gradiente descendente, retro propagação, entre várias coisas que você já deve ter visto por aí.

Espero que você goste bastante do curso.

Indo por dentro da rede neural - O que acontece na rede

Tínhamos montado uma rede neural usando a camada flatten, a relu e a softmax. O que cada uma delas fazia primeiro era achatar as imagens, depois da relu introduzia uma não linearidade no modelo e alterava os valores usando uma função. Então, a softmax fazia uma conta para classificar nossos inputs e ter nosso output.

Mas o que será que está acontecendo por debaixo dos panos? Se olharmos para esse slide, conseguimos ver inputs que entram para flatten e que vão para relu. Com isso, temos valores indo para a frente. Na relu, também temos outros valores sendo jogados para a frente, até chegarmos na softmax.

Será que passar esses valores para a frente é o bastante para uma rede aprender? Estamos fazendo algo chamado propagação, ou fowardpropagation. Para nossa rede começar a entender o que estamos fazendo não basta fazer uma vez. Temos que passar os valores em um segundo movimento para trás. Pegamos os resultados e voltamos.

O que acontece numa rede neural que não falamos no curso anterior é que tem esses dois movimentos. O primeiro de propagação para a frente e o segundo de retropropagação.

Voltando ao nosso projeto, primeiro vou clicar em run time e rodar tudo. Se olharmos o código, vemos que quando criamos a rede, passamos aqueles números. Qual a relação deles com os valores que estão indo e voltando da nossa rede?

Para termos uma ideia, podemos criar mais uma célula. Escrevemos modelo.summary. Vamos chamar essa função. Ele retorna uma tabela que resume nosso modelo. Podemos ver aqui os números. Eles têm relação com os números que escolhemos.

Olhando para a última coluna, temos parâmetros, variáveis. A primeiro linha é zero, porque não aconteceu muita coisa. Na dense vamos fazer uma conta. Temos 784 valores iniciais, e teremos 256 neurônios na nossa rede que vão receber. Podemos multiplicar uma pela outra, e vai dar 200.704. Fica diferente do valor do dense.

Nós já percebemos que os inputs são multiplicados pelo número de unidades que definimos na camada dense. Já iremos ver o motivo de ter dado um número maior.

Indo por dentro da rede neural - Valores propagados e pesos

Para entender melhor o que esses parâmetros são, vamos voltar e olhar a representação do modelo. Vamos tentar visualizar uma simulação de onde os valores vem.

Na camada flatten, cada unidade tem um valor de entrada. Esses valores não importam tanto. O importante é o que vai acontecer com eles. Eles são propagados para a frente. Chegando na softmax, temos o percentual do que está certo e o que não está.

Podemos considerar que o 0.8 é 80% de chance de estar certo. Se considerarmos como um acerto da rede, no final teremos como se o 1 tivesse virado 0.8. Se pegarmos só esse exemplo, temos dois número 1 e o 0.8.

Se 0.8 foi o valor que chegou mais próximo, o que fazemos com os outros? Podemos considerar que o 2, o 1, o outro 1 são mais importantes do que os valores que nem consideramos mais. Eles têm um peso maior no modelo.

Podemos multiplicar esses números por 1, continuando com o mesmo resultado. Se multiplicarmos por mais, aumentamos o resultado. Temos que ver o que fazer com os pesos dessa camada e da outra.

A parte boa é que o Keras já cuida de tudo isso para nós. Podendo visualizar sabendo que essas variáveis têm nossos pesos. Temos um parâmetro para cada peso que vamos colocar.

Do mesmo jeito que fizemos um modelo.summary, vamos criar mais uma célula de código para ver o que são esses pesos. Vamos escolher a camada, que em inglês é layers. Entre colchetes, coloco a número 1, que é a relu, e depois pegamos nossos pesos, com get_weights.

Executando, vem vários arrays. Quando falamos de peso nessa explicação, nesse exemplo, mostramos por que e para que vamos multiplicar cada um desses inputs do módulo, e vemos que não é tão simples. Repare que o que acontece com nossos pesos é que é um array muito grande. No fundo, o que está rolando é multiplicação de matrizes.

Começamos a entender melhor o que está acontecendo por debaixo dos panos. Mas tem mais coisa para ver.

Sobre o curso Deep Learning parte 2: como a rede aprende

O curso Deep Learning parte 2: como a rede aprende possui 116 minutos de vídeos, em um total de 40 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:

• Indo por dentro da rede neural
• Estudando os pesos e vieses
• Entendendo as unidades e buscando a menor perda
• Como o modelo fica ótimo
• Testando os hiperparâmetros da rede