TensorFlow, Keras e aprendizado profundo, sem um doutorado

1. Visão geral

Este tutorial foi atualizado para o TensorFlow 2.2.

Neste codelab, você vai aprender a criar e treinar uma rede neural que reconhece dígitos escritos à mão. Ao aprimorar sua rede neural para atingir 99% de precisão, você também descobrirá as ferramentas do comércio que os profissionais de aprendizado profundo usam para treinar modelos com eficiência.

Este codelab usa o conjunto de dados MNIST, uma coleção de 60.000 dígitos rotulados que mantém gerações de PhDs ocupadas por quase duas décadas. Você resolverá o problema com menos de 100 linhas de código Python / TensorFlow.

O que você vai aprender

• O que é uma rede neural e como treiná-la
• Como criar uma rede neural básica de uma camada usando o tf.keras
• Como adicionar mais camadas
• Como configurar uma programação de taxa de aprendizado
• Como criar redes neurais convolucionais
• Como usar técnicas de regularização: dropout e normalização em lote.
• O que está overfitting

O que é necessário

Apenas um navegador. É possível realizar este workshop inteiramente com o Google Colaboratory.

Feedback

Avise nossa equipe se você encontrar algo errado no laboratório ou achar que ele precisa ser melhorado. O feedback é resolvido por problemas do GitHub [link do feedback].

2. Guia de início rápido do Google Colaboratory

Este laboratório usa o Google Colaboratory e não exige configuração. Ele pode ser executado em um Chromebook. Abra o arquivo abaixo e execute as células para se familiarizar com os notebooks do Colab.

Welcome to Colab.ipynb

Confira mais instruções abaixo:

Selecionar um back-end de GPU

No menu do Colab, selecione Ambiente de execução > Mude o tipo de ambiente de execução e selecione a GPU. A conexão com o ambiente de execução vai ocorrer automaticamente na primeira execução ou você pode usar o botão "Conectar" no canto superior direito.

Execução do notebook

Execute uma célula de cada vez clicando em uma célula e usando Shift-ENTER. Também é possível executar todo o notebook em Ambiente de execução > Executar tudo

Índice

Todos os notebooks têm um índice. Para abri-lo, use a seta preta à esquerda.

Células ocultas

Algumas células mostrarão apenas o título. Este é um recurso de notebook específico para o Colab. É possível clicar duas vezes neles para ver o código deles, mas normalmente não é muito interessante. Normalmente, são funções de suporte ou visualização. Você ainda precisa executar essas células para que as funções internas sejam definidas.

3. Treinar uma rede neural

Primeiro vamos ver um treinamento de rede neural. Abra o notebook abaixo e execute todas as células. Não preste atenção ao código ainda, vamos começar a explicá-lo mais tarde.

keras_01_mnist.ipynb

Ao executar o notebook, concentre-se nas visualizações. Veja as explicações abaixo.

Dados de treinamento

Temos um conjunto de dados de dígitos manuscritos que foram rotulados para saber o que cada imagem representa, por exemplo, um número entre 0 e 9. No notebook, você verá um trecho:

A rede neural que criaremos classifica os dígitos escritos à mão nas 10 classes (0, ..., 9). Isso é feito com base em parâmetros internos que precisam ter um valor correto para que a classificação funcione bem. O "valor correto" é aprendida por meio de um processo de treinamento que requer um "conjunto de dados rotulado" com imagens e as respostas corretas associadas.

Como saber se a rede neural treinada tem um bom desempenho? Usar o conjunto de dados de treinamento para testar a rede seria fraude. Ele já viu esse conjunto de dados várias vezes durante o treinamento e, com certeza, tem muito desempenho nele. Precisamos de outro conjunto de dados rotulados, nunca visto durante o treinamento, para avaliar o "mundo real" desempenho da rede. Ele é chamado de "conjunto de dados de validação".

Há 50.000 dígitos de treinamento neste conjunto de dados. Alimentamos um "lote" deles de tamanho 128 no loop de treinamento em cada iteração, de modo que o sistema tenha visto todos os dígitos de treinamento uma vez após 391 iterações. Chamamos isso de "época".

Há também 10.000 dígitos de "validação" diferentes para testar o desempenho do modelo.

Treinamento

Conforme o treinamento avança, um lote de dados de treinamento por vez, os parâmetros internos do modelo são atualizados e o modelo reconhece cada vez mais os dígitos escritos à mão. É possível vê-lo no gráfico de treinamento:

À direita, a "precisão" é simplesmente a porcentagem de dígitos corretamente reconhecidos. Ele aumenta conforme o treinamento avança, o que é bom.

À esquerda, podemos ver a "perda". Para conduzir o treinamento, vamos definir uma "perda" que representa o quão mal o sistema reconhece os dígitos e tenta minimizá-los. O que você vê aqui é que a perda diminui nos dados de treinamento e de validação à medida que o treinamento avança: isso é bom. Significa que a rede neural está aprendendo.

O eixo X representa o número de "épocas" ou iterações em todo o conjunto de dados.

Previsões

Quando o modelo é treinado, podemos usá-lo para reconhecer dígitos escritos à mão. A próxima visualização mostra o desempenho em alguns dígitos renderizados de fontes locais (primeira linha) e, em seguida, nos 10.000 dígitos do conjunto de dados de validação. A classe prevista aparece abaixo de cada dígito, em vermelho se estiver errada.

Como você pode ver, esse modelo inicial não é muito bom, mas ainda reconhece alguns dígitos corretamente. A acurácia da validação final é de cerca de 90%, o que não é tão ruim para o modelo simplista com o qual estamos começando,mas ainda significa que ele deixa passar 1.000 dígitos de validação dos 10.000. É muito mais do que o que pode ser mostrado, e é por isso que parece que todas as respostas estão erradas (vermelho).

Tensores

Os dados são armazenados em matrizes. Uma imagem em escala de cinza de 28 x 28 pixels se encaixa em uma matriz bidimensional de 28 x 28. Mas para uma imagem colorida, precisamos de mais dimensões. Existem três valores de cor por pixel (vermelho, verde, azul). Portanto, é necessária uma tabela tridimensional com dimensões [28, 28, 3]. Para armazenar um lote de 128 imagens coloridas, é necessária uma tabela de quatro dimensões com dimensões [128, 28, 28, 3].

Essas tabelas multidimensionais são chamadas de "tensores", e a lista das dimensões é o "shape" delas.

4. [INFORMAÇÃO]: introdução às redes neurais

Resumindo

Se todos os termos em negrito no próximo parágrafo já forem conhecidos, siga para o próximo exercício. Se você está começando no aprendizado profundo, dê as boas-vindas e continue lendo.

Um classificador de rede neural é composto por várias camadas de neurônios. Para a classificação de imagens, elas podem ser camadas densas ou, mais frequentemente, convolucionais. Normalmente, elas são ativadas com a função de ativação relu. A última camada usa o mesmo número de neurônios que as classes e é ativada com o softmax. Para classificação, a entropia cruzada é a função de perda mais usada, comparando os rótulos codificados one-hot (ou seja, respostas corretas) com as probabilidades previstas pela rede neural. Para minimizar a perda, é melhor escolher um otimizador com momentum, por exemplo, Adam, e treinar em lotes de imagens e rótulos de treinamento.

Para modelos criados como uma sequência de camadas, o Keras oferece a API Sequential. Por exemplo, um classificador de imagens que usa três camadas densas pode ser escrito em Keras como:

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=[28, 28, 1]),
    tf.keras.layers.Dense(200, activation="relu"),
    tf.keras.layers.Dense(60, activation="relu"),
    tf.keras.layers.Dense(10, activation='softmax') # classifying into 10 classes
])

# this configures the training of the model. Keras calls it "compiling" the model.
model.compile(
  optimizer='adam',
  loss= 'categorical_crossentropy',
  metrics=['accuracy']) # % of correct answers

# train the model
model.fit(dataset, ... )

Uma única camada densa

Os dígitos escritos à mão no conjunto de dados MNIST são imagens em escala de cinza de 28 x 28 pixels. A abordagem mais simples para classificá-los é usar 28x28=784 pixels como entradas para uma rede neural de uma camada.

Cada "neurônio" de uma rede neural faz uma soma ponderada de todas as entradas e adiciona uma constante chamada de "viés". e, em seguida, alimenta o resultado por meio de alguma "função de ativação" não linear. Os "pesos" e "vieses" são parâmetros que serão determinados por meio do treinamento. Eles são inicializados com valores aleatórios no início.

A imagem acima representa uma rede neural de uma camada com 10 neurônios de saída, já que queremos classificar dígitos em 10 classes (0 a 9).

Com uma multiplicação de matrizes

Veja como uma camada de rede neural, processando uma coleção de imagens, pode ser representada por uma multiplicação de matrizes:

Usando a primeira coluna de pesos na matriz de pesos W, calculamos a soma ponderada de todos os pixels da primeira imagem. Essa soma corresponde ao primeiro neurônio. Usando a segunda coluna de pesos, fazemos o mesmo para o segundo neurônio e assim por diante até o 10o. Podemos repetir a operação para as 99 imagens restantes. Se chamarmos X a matriz que contém nossas 100 imagens, todas as somas ponderadas dos 10 neurônios, calculadas em 100 imagens, serão simplesmente X.W, uma multiplicação de matrizes.

Agora, cada neurônio precisa adicionar um viés (uma constante). Como temos 10 neurônios, temos 10 constantes de viés. Vamos chamar esse vetor de 10 valores de b. Ele precisa ser adicionado a cada linha da matriz calculada anteriormente. Usar um pouco de mágica chamado "transmissão" vamos escrever isso com um simples sinal de mais.

"Transmissão" é um truque padrão usado no Python e no numpy, sua biblioteca de computação científica. Ela amplia o funcionamento das operações normais em matrizes com dimensões incompatíveis. "Adicionar transmissão" significa "se você está adicionando duas matrizes, mas não pode porque suas dimensões não são compatíveis, tente replicar a pequena o quanto for necessário para que ela funcione".

Por fim, aplicamos uma função de ativação, por exemplo, "softmax". (explicado abaixo) e receba a fórmula que descreve uma rede neural de uma camada, aplicada a 100 imagens:

No Keras

Com bibliotecas de rede neural de alto nível, como a Keras, não precisamos implementar essa fórmula. No entanto, é importante entender que uma camada de rede neural é apenas um monte de multiplicações e adições. No Keras, uma camada densa seria escrita como:

tf.keras.layers.Dense(10, activation='softmax')

Vá além

É comum encadear camadas de redes neurais. A primeira camada calcula somas ponderadas de pixels. As camadas subsequentes calculam somas ponderadas das saídas das camadas anteriores.

A única diferença, além do número de neurônios, será a escolha da função de ativação.

Funções de ativação: relu, softmax e sigmoid

Você normalmente usaria a função "relu" função de ativação para todas as camadas, exceto a última. A última camada de um classificador usaria "softmax" ativação.

Mais uma vez, um "neurônio" calcula uma soma ponderada de todas as entradas, adiciona um valor chamado "viés" e alimenta o resultado com a função de ativação.

A função de ativação mais conhecida é chamada de "RELU" (unidade linear retificada). Essa é uma função muito simples, como mostra o gráfico acima.

A função de ativação tradicional em redes neurais era o "sigmoide", mas a "relu" mostrou ter melhores propriedades de convergência em quase todos os lugares e agora é o preferido.

Ativação do Softmax para classificação

A última camada da rede neural tem 10 neurônios porque queremos classificar dígitos manuscritos em 10 classes (0, 9). Ela deve gerar 10 números entre 0 e 1, representando a probabilidade desse dígito ser 0, 1, 2 e assim por diante. Para isso, na última camada, usaremos uma função de ativação chamada "softmax".

A aplicação de softmax a um vetor é feita tomando a exponencial de cada elemento e, em seguida, normalizando o vetor, normalmente dividindo-o por seu "L1" norma (ou seja, soma de valores absolutos) para que os valores normalizados somem 1 e possam ser interpretados como probabilidades.

A saída da última camada, antes da ativação, às vezes é chamada de "logits". Se esse vetor for L = [L0, L1, L2, L3, L4, L5, L6, L7, L8, L9], então:

Por que "softmax" chamada softmax? A exponencial é uma função que aumenta drasticamente. Isso aumenta as diferenças entre as saídas dos neurônios. Depois, quando normalizar o vetor, o maior elemento, que domina a norma, será normalizado para um valor próximo de 1, enquanto todos os outros elementos serão divididos por um valor grande e normalizados para algo próximo de 0. O vetor resultante mostra claramente qual é a classe vencedora, a "max", mas mantém a ordem relativa original dos valores, portanto, a "soft".

Perda de entropia cruzada

Agora que nossa rede neural produz previsões a partir de imagens de entrada, precisamos medir a qualidade delas, ou seja, a distância entre o que a rede nos diz e as respostas corretas, geralmente chamadas de "rótulos". Lembre-se de que temos rótulos corretos para todas as imagens no conjunto de dados.

Qualquer distância funcionaria, mas, para problemas de classificação, a chamada "distância da entropia cruzada" é o mais eficaz. Vamos chamar isso de erro ou "perda" função:

One-hot codificação significa que você representa o rótulo "este é o dígito 3" usando um vetor de 10 valores, todos zeros, exceto o terceiro valor, que é 1. Esse vetor representa uma probabilidade de 100% de ser o "dígito 3". A rede neural também gera previsões como um vetor de 10 valores de probabilidade. Eles são fáceis de comparar.

Gradiente descendente

"Treinamento" a rede neural significa usar imagens e rótulos de treinamento para ajustar pesos e vieses, minimizando a função de perda de entropia cruzada. Confira como funciona.

A entropia cruzada é uma função de pesos, vieses, pixels da imagem de treinamento e sua classe conhecida.

Se computamos os derivados parciais da entropia cruzada em relação a todos os pesos e todas as tendências, obtemos um "gradiente", calculado para uma determinada imagem, rótulo e valor presente de pesos e tendências. Lembre-se de que podemos ter milhões de pesos e vieses, então calcular o gradiente parece muito trabalho. Felizmente, o TensorFlow faz isso por nós. A propriedade matemática de um gradiente é que ele aponta para "para cima". Como queremos chegar onde a entropia cruzada é baixa, vamos na direção oposta. Atualizamos os pesos e as tendências por uma fração do gradiente. Em seguida, fazemos a mesma coisa várias vezes usando os próximos lotes de imagens e rótulos de treinamento, em um loop de treinamento. Com sorte, isso converge para um lugar em que a entropia cruzada é mínima, embora nada garanta que esse mínimo seja único.

Taxa de aprendizado: não é possível atualizar seus pesos e vieses por todo o comprimento do gradiente em cada iteração. Seria como tentar chegar ao fundo de um vale usando chuteiras de sete ligas. Você pularia de um lado do vale para o outro. Para chegar ao mínimo, você precisa executar etapas menores, ou seja, usar apenas uma fração do gradiente, normalmente no intervalo 1/1000. Essa fração é chamada de "taxa de aprendizado".

Minilote e momentum

É possível calcular o gradiente em apenas uma imagem de exemplo e atualizar os pesos e vieses imediatamente. No entanto, ao fazer isso em um lote de, por exemplo, 128 imagens, o gradiente representa melhor as restrições impostas por diferentes exemplos de imagem e, portanto, provavelmente converge para a solução mais rapidamente. O tamanho do minilote é um parâmetro ajustável.

Essa técnica, às vezes chamada de "gradiente descendente estocástico" tem outro benefício mais pragmático: trabalhar com lotes também significa trabalhar com matrizes maiores, e elas geralmente são mais fáceis de otimizar em GPUs e TPUs.

No entanto, a convergência pode ser um pouco caótica e até parar se o vetor do gradiente for todo zero. Isso significa que encontramos um mínimo? Nem sempre. Um componente de gradiente pode ser zero no mínimo ou no máximo. Em um vetor de gradiente com milhões de elementos, se todos eles forem zeros, a probabilidade de que cada zero corresponda a um mínimo e nenhum deles a um ponto máximo será muito pequena. Em um espaço de muitas dimensões, os pontos de sela são muito comuns e não queremos parar neles.

Ilustração: um suporte para sentar. O gradiente é 0, mas não é o mínimo em todas as direções. (Atribuição da imagem Wikimedia: por Nicoguaro - Próprio trabalho, CC BY 3.0)

A solução é adicionar um pouco de impulso ao algoritmo de otimização para que ele possa ultrapassar os pontos de obstáculos sem parar.

A biblioteca do TensorFlow oferece uma grande variedade de otimizadores, começando com o gradiente descendente básico tf.keras.optimizers.SGD, que agora tem um parâmetro momentum opcional. Os otimizadores conhecidos mais avançados que têm um momentum integrado são tf.keras.optimizers.RMSprop ou tf.keras.optimizers.Adam.

Glossário

lote ou minilote: o treinamento é sempre executado em lotes de dados de treinamento e rótulos. Isso ajuda o algoritmo a convergir. O "lote" normalmente é a primeira dimensão dos tensores de dados. Por exemplo, um tensor de forma [100, 192, 192, 3] contém 100 imagens de 192x192 pixels com três valores por pixel (RGB).

perda de entropia cruzada: uma função de perda especial usada com frequência em classificadores.

camada densa: uma camada de neurônios em que cada um deles está conectado a todos os neurônios da camada anterior.

features: as entradas de uma rede neural às vezes são chamadas de "atributos". A arte de descobrir quais partes de um conjunto de dados (ou combinações de partes) devem ser alimentadas em uma rede neural para receber boas previsões é chamada de "engenharia de atributos".

labels: outro nome para "classes" ou respostas corretas em um problema de classificação supervisionado

Taxa de aprendizado: fração do gradiente em que pesos e vieses são atualizados a cada iteração do loop de treinamento.

logits: as saídas de uma camada de neurônios antes da aplicação da função de ativação são chamadas de "logits". O termo vem da "função logística", também conhecida como "função sigmoide" que costumava ser a função de ativação mais conhecida. "Saídas de neurônios antes da função logística" foi encurtado para "logits".

loss: a função de erro que compara as saídas da rede neural com as respostas corretas

neuron: calcula a soma ponderada das entradas, adiciona uma polarização e alimenta o resultado com uma função de ativação.

codificação one-hot: a classe 3 de 5 é codificada como um vetor de cinco elementos, todos os zeros, exceto o terceiro, que é 1.

relu: unidade linear retificada. Uma função de ativação conhecida para os neurônios.

sigmoid: outra função de ativação que era conhecida e ainda é útil em casos especiais.

softmax: uma função de ativação especial que atua em um vetor, aumenta a diferença entre o maior componente e todos os outros, além de normalizar o vetor para ter uma soma de 1, de modo que possa ser interpretado como um vetor de probabilidades. Usado como a última etapa em classificadores.

tensor: um "tensor" é como uma matriz, mas com um número arbitrário de dimensões. Um tensor unidimensional é um vetor. Um tensor de duas dimensões é uma matriz. Você pode ter tensores com 3, 4, 5 ou mais dimensões.

5. Vamos direto ao código

Voltando ao notebook do estudo, agora vamos ler o código.

keras_01_mnist.ipynb

MÁXIMO:

Sua tarefa nesta seção é ler e entender o código para melhorar mais tarde.

Vamos analisar todas as células deste notebook.

Célula "Parâmetros"

Aqui são definidos o tamanho do lote, o número de períodos de treinamento e o local dos arquivos de dados. Os arquivos de dados são hospedados em um bucket do Google Cloud Storage (GCS). É por isso que o endereço começa com gs://.

Célula "Importações"

Todas as bibliotecas Python necessárias são importadas aqui, incluindo o TensorFlow e também matplotlib para visualizações.

Célula "Utilitários de visualização [RUN ME]****"

Esta célula contém um código de visualização desinteressante. Ele fica recolhido por padrão, mas você pode abri-lo e ver o código quando tiver tempo, clicando duas vezes nele.

Execute esta célula (SHIFT-ENTER). Caso contrário, as funções definidas nela não serão analisadas, e você receberá erros mais tarde.

Célula "tf.data.Dataset: analisar arquivos e preparar conjuntos de dados de treinamento e validação"

Esta célula usou a API tf.data.Dataset para carregar o conjunto de dados do MNIST dos arquivos de dados. Não é necessário gastar muito tempo nessa célula. Se você tiver interesse na API tf.data.Dataset, confira um tutorial que explica o assunto: pipelines de dados de velocidade da TPU. Por enquanto, os princípios básicos são:

As imagens e os rótulos (respostas corretas) do conjunto de dados MNIST são armazenados em registros de comprimento fixo em quatro arquivos. Os arquivos podem ser carregados com a função de registro fixo dedicada:

imagedataset = tf.data.FixedLengthRecordDataset(image_filename, 28*28, header_bytes=16)

Agora temos um conjunto de dados de bytes de imagem. Eles precisam ser decodificados em imagens. Para isso, definimos uma função. A imagem não está compactada, então a função não precisa decodificar nada (decode_raw praticamente não faz nada). A imagem é então convertida em valores de ponto flutuante entre 0 e 1. Podemos remodelá-la aqui como uma imagem 2D, mas, na verdade, a mantemos como uma matriz plana de pixels de tamanho 28 x 28, porque é isso que nossa camada densa inicial espera.

def read_image(tf_bytestring):
    image = tf.io.decode_raw(tf_bytestring, tf.uint8)
    image = tf.cast(image, tf.float32)/256.0
    image = tf.reshape(image, [28*28])
    return image

Aplicamos essa função ao conjunto de dados usando .map e recebemos um conjunto de dados de imagens:

imagedataset = imagedataset.map(read_image, num_parallel_calls=16)

Fazemos o mesmo tipo de leitura e decodificação para rótulos e .zip imagens e rótulos juntos:

dataset = tf.data.Dataset.zip((imagedataset, labelsdataset))

Agora temos um conjunto de dados de pares (imagem, rótulo). Isso é o que nosso modelo espera. Ainda não estamos prontos para usá-lo na função de treinamento:

dataset = dataset.cache()
dataset = dataset.shuffle(5000, reshuffle_each_iteration=True)
dataset = dataset.repeat()
dataset = dataset.batch(batch_size)
dataset = dataset.prefetch(tf.data.experimental.AUTOTUNE)

A API tf.data.Dataset tem todas as funções de utilitário necessárias para preparar conjuntos de dados:

.cache armazena o conjunto de dados em cache na RAM. Esse é um conjunto de dados pequeno, por isso ele funcionará. .shuffle o embaralha com um buffer de 5.000 elementos. É importante que os dados de treinamento sejam bem embaralhados. .repeat repete o conjunto de dados. Vamos treinar nela várias vezes (vários períodos). .batch reúne várias imagens e rótulos em um minilote. Por fim, .prefetch pode usar a CPU para preparar o próximo lote enquanto o atual está sendo treinado na GPU.

O conjunto de dados de validação é preparado de maneira semelhante. Agora estamos prontos para definir um modelo e usar esse conjunto de dados para treiná-lo.

Célula "Keras Model"

Todos os nossos modelos serão sequências retas de camadas para que possamos usar o estilo tf.keras.Sequential para criá-los. Inicialmente aqui, é uma única camada densa. Ela tem 10 neurônios porque estamos classificando dígitos escritos à mão em 10 classes. Ela usa "softmax" porque ele é a última camada do classificador.

Um modelo do Keras também precisa saber o formato das entradas. tf.keras.layers.Input pode ser usado para defini-lo. Aqui, os vetores de entrada são vetores planos de valores de pixel com comprimento de 28 x 28.

model = tf.keras.Sequential(
  [
    tf.keras.layers.Input(shape=(28*28,)),
    tf.keras.layers.Dense(10, activation='softmax')
  ])

model.compile(optimizer='sgd',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# print model layers
model.summary()

# utility callback that displays training curves
plot_training = PlotTraining(sample_rate=10, zoom=1)

A configuração do modelo é feita no Keras usando a função model.compile. Aqui, usamos o otimizador básico 'sgd' (gradiente descendente estocástico). Um modelo de classificação requer uma função de perda de entropia cruzada chamada 'categorical_crossentropy' no Keras. Por fim, pedimos para o modelo calcular a métrica 'accuracy', que é a porcentagem de imagens classificadas corretamente.

O Keras oferece o utilitário model.summary(), que mostra os detalhes do modelo que você criou. O instrutor do tipo adicionou o utilitário PlotTraining (definido na célula "utilitários de visualização") que vai mostrar várias curvas de treinamento durante o treinamento.

Célula "Treinar e validar o modelo"

É aqui que o treinamento acontece, chamando model.fit e transmitindo os conjuntos de dados de treinamento e validação. Por padrão, o Keras executa uma rodada de validação ao final de cada período.

model.fit(training_dataset, steps_per_epoch=steps_per_epoch, epochs=EPOCHS,
          validation_data=validation_dataset, validation_steps=1,
          callbacks=[plot_training])

No Keras, é possível usar callbacks para adicionar comportamentos personalizados durante o treinamento. Foi assim que o gráfico de treinamento com atualização dinâmica foi implementado neste workshop.

Célula "Visualizar previsões"

Depois que o modelo for treinado, poderemos fazer previsões dele chamando model.predict():

probabilities = model.predict(font_digits, steps=1)
predicted_labels = np.argmax(probabilities, axis=1)

Preparamos um conjunto de dígitos impressos renderizados com fontes locais como teste. Lembre-se de que a rede neural retorna um vetor de 10 probabilidades a partir do "softmax" final. Para conseguir o rótulo, precisamos descobrir qual a probabilidade mais alta. O np.argmax da biblioteca numpy faz isso.

Para entender por que o parâmetro axis=1 é necessário, lembre-se de que processamos um lote de 128 imagens e, portanto, o modelo retorna 128 vetores de probabilidades. O formato do tensor de saída é [128, 10]. Estamos calculando o argmax nas 10 probabilidades retornadas para cada imagem, portanto, axis=1 (o primeiro eixo é 0).

Esse modelo simples já reconhece 90% dos dígitos. Nada mal, mas agora você vai melhorar isso significativamente.

6. Adicionar camadas

Para melhorar a precisão do reconhecimento, vamos adicionar mais camadas à rede neural.

Mantemos a softmax como a função de ativação na última camada porque é o que funciona melhor para a classificação. No entanto, em camadas intermediárias, usaremos a função de ativação mais clássica: sigmoide:

MÁXIMO:

Adicione algumas camadas densas intermediárias ativadas com "sigmoide" antes da sua "softmax" camada O número de neurônios neles pode ser qualquer coisa entre 784 (o número de pixels de entrada) e 10 (o número de neurônios de saída). Em seguida, treine o modelo novamente.

Aviso: para treinar novamente, execute novamente o "modelo do Keras" para definir um novo modelo e, em seguida, a célula de treinamento. Apenas executar novamente a célula de treinamento dará continuidade ao treinamento do modelo anterior.

Por exemplo, seu modelo pode ter esta aparência (não se esqueça das vírgulas, tf.keras.Sequential usa uma lista de camadas separada por vírgulas):

model = tf.keras.Sequential(
  [
      tf.keras.layers.Input(shape=(28*28,)),
      tf.keras.layers.Dense(200, activation='sigmoid'),
      tf.keras.layers.Dense(60, activation='sigmoid'),
      tf.keras.layers.Dense(10, activation='softmax')
  ])

Veja o "resumo" de seu modelo. Agora, ela tem pelo menos 10 vezes mais parâmetros. Deve ser 10 vezes melhor! Mas, por algum motivo, não é ...

A perda parece ter chegado no telhado também. Algo não está certo.

7. Cuidado especial para redes profundas

Você acabou de experimentar redes neurais, como as pessoas costumavam projetá-las nos anos 80 e 90. Não é à toa que eles desistiram da ideia, inaugurando o chamado "inverno da IA". De fato, à medida que você adiciona camadas, as redes neurais têm cada vez mais dificuldade para convergir.

Acontece que redes neurais profundas com muitas camadas (20, 50 e até mesmo 100 hoje) podem funcionar muito bem, com alguns truques matemáticos sujos para fazê-las convergir. A descoberta desses truques simples é uma das razões para o renascimento do aprendizado profundo na década de 2010.

Ativação RELU

A função de ativação sigmoide é, na verdade, bastante problemática em redes profundas. Ela comprime todos os valores entre 0 e 1 e, quando você faz isso repetidamente, as saídas de neurônios e seus gradientes podem desaparecer completamente. Isso foi mencionado por motivos históricos, mas as redes modernas usam a Unidade Linear Retificada (RELU, na sigla em inglês), que tem esta aparência:

MÁXIMO:

Substitua todos os activation='sigmoid' por activation='relu' nas camadas e treine novamente.

Por que o sigmoide é problemático? Veja como ele se comporta nas laterais: fica nivelado.

Isso significa que seu derivado está próximo de zero. Lembre-se de como o treinamento progride, seguindo o gradiente, que é um vetor de derivadas. Com a ativação sigmoide, especialmente se houver muitas camadas, o gradiente pode ficar muito pequeno e o treinamento fica mais lento.

O relu, por outro lado, tem uma derivada de 1, pelo menos em seu lado direito. Com a ativação RELU, mesmo que os gradientes provenientes de alguns neurônios possam ser zero, sempre haverá outros oferecendo um gradiente diferente de zero claro, e o treinamento pode continuar em um bom ritmo.

Um otimizador melhor

Em espaços com dimensões muito altas como aqui, temos cerca de 10 mil pesos e vieses, "pontos de dificuldade" são frequentes. Esses são pontos que não são mínimos locais, mas onde o gradiente é zero e o otimizador do gradiente descendente permanece preso ali. O TensorFlow tem uma variedade completa de otimizadores disponíveis, incluindo alguns que funcionam com bastante inércia e vão navegar com segurança além dos pontos de controle.

MÁXIMO:

Substitua o otimizador 'sgd' por um melhor, por exemplo, 'adam', e treine novamente.

Inicializações aleatórias

A arte de inicializar os vieses de pesos antes do treinamento é uma área de pesquisa por si só, com vários artigos publicados sobre o assunto. Veja todos os inicializadores disponíveis no Keras aqui. Felizmente, o Keras faz a coisa certa por padrão e usa o inicializador 'glorot_uniform', que é o melhor em quase todos os casos.

Você não precisa fazer nada, porque o Keras já faz a coisa certa.

NaN ???

A fórmula de entropia cruzada envolve um logaritmo e log(0) não é um número (NaN, uma falha numérica, se você preferir). A entrada para a entropia cruzada pode ser 0? A entrada vem da softmax, que é essencialmente uma exponencial, que nunca é zero. Então, estamos bem!

Mesmo? No belo mundo da matemática, estaríamos seguros, mas no mundo da computação, exp(-150), representado no formato float32, é o mesmo que ZERO, e a entropia cruzada falha.

Felizmente, você também não precisa fazer nada aqui, já que o Keras cuida disso e calcula o softmax seguido pela entropia cruzada com bastante cuidado para garantir a estabilidade numérica e evitar os temidos NaNs.

Sucesso?

Agora você terá 97% de precisão. O objetivo deste workshop é ficar significativamente acima de 99%, então vamos continuar.

Se você não souber o que fazer, veja a solução neste momento:

keras_02_mnist_dense.ipynb

8. Redução da taxa de aprendizado

Talvez possamos tentar treinar mais rápido? A taxa de aprendizado padrão no otimizador Adam é de 0,001. Vamos tentar aumentá-la.

MÁXIMO:

Aumente a taxa de aprendizado do valor padrão de 0,001 para 0,01. Para isso, você terá que substituir o otimizador predefinido 'adam' por uma instância real do otimizador Adam para ter acesso aos parâmetros de configuração:

optimizer=tf.keras.optimizers.Adam(lr=0.01)

Aumente também o fator de zoom para 5 no PlotTraining. Esse valor aumenta em torno de 0 nas perdas e em torno de 1 nas imprecisões para ajudar você a entender o que está acontecendo: PlotTraining(sample_rate=10, zoom=5)

Acelerar não parece ajudar muito, e o que é todo esse barulho?

As curvas de treinamento têm muito ruído e analisam as duas curvas de validação: elas saltam para cima e para baixo. Isso significa que estamos indo muito rápido. Poderíamos voltar à velocidade anterior, mas há uma maneira melhor.

A melhor solução é começar rápido e diminuir exponencialmente a taxa de aprendizado. No Keras, é possível fazer isso com o callback tf.keras.callbacks.LearningRateScheduler.

MÁXIMO:

Implemente uma programação que reduza a taxa de aprendizado exponencialmente. A seguir, você encontra snippets de código úteis.

Código útil para copiar e colar:

# lr decay function
def lr_decay(epoch):
  return 0.01 * math.pow(0.6, epoch)

# lr schedule callback
lr_decay_callback = tf.keras.callbacks.LearningRateScheduler(lr_decay, verbose=True)

# important to see what you are doing
plot_learning_rate(lr_decay, EPOCHS)

Não se esqueça de usar o lr_decay_callback que você criou. Adicione-o à lista de callbacks em model.fit:

model.fit(...,  callbacks=[plot_training, lr_decay_callback])

O impacto dessa pequena mudança é espetacular. Observe que a maior parte do ruído desapareceu e a precisão do teste agora está acima de 98% de forma contínua.

9. Dropout, overfitting

Agora o modelo está convergindo bem. Vamos tentar ir ainda mais fundo.

MÁXIMO:

Caso ainda não tenha feito isso, aumente a profundidade do modelo para pelo menos quatro camadas densas e treine novamente. É possível usar o seguinte número de neurônios nas camadas: 200, 100, 60, 10.

Aumente também o fator de zoom para 10 no PlotTraining. Esse valor aumenta em torno de 0 nas perdas e em torno de 1 nas imprecisões para ajudar você a entender o que está acontecendo: PlotTraining(sample_rate=10, zoom=10)

Isso ajudou?

Na verdade, não. A precisão ainda está presa em 98%. Analise a perda de validação. Está subindo! O algoritmo de aprendizado só trabalha com dados de treinamento e otimiza a perda de treinamento de acordo com isso. Ele nunca vê dados de validação. Por isso, não surpreende que, depois de um tempo, seu trabalho não tenha mais efeito na perda de validação, que para de cair e, às vezes, até mesmo retorna.

Isso não afeta imediatamente os recursos de reconhecimento do seu modelo no mundo real, mas impede que você execute muitas iterações e geralmente é um sinal de que o treinamento não está mais tendo um efeito positivo.

Essa desconexão geralmente é chamada de "overfitting" Quando isso acontecer, tente aplicar uma técnica de regularização chamada "dropout". A técnica de dropout dispara neurônios aleatórios em cada iteração de treinamento.

O dropout é uma das técnicas de regularização mais antigas em aprendizado profundo. A cada iteração de treinamento, ele descarta neurônios aleatórios da rede com uma probabilidade p (normalmente de 25% a 50%). Na prática, as saídas dos neurônios são definidas como 0. O resultado é que esses neurônios não vão participar do cálculo da perda desta vez e não vão receber atualizações de peso. Neurônios diferentes são descartados em cada iteração de treinamento.

Ao testar o desempenho da sua rede, é claro que você coloca todos os neurônios de volta (taxa de dropout=0). O Keras faz isso automaticamente, então você só precisa adicionar uma tf.keras.layers.Dropout camada. Ele terá o comportamento correto no treinamento e na avaliação automaticamente.

Por que isso funciona? A teoria é que as redes neurais têm tanta liberdade entre as suas numerosas camadas que é totalmente possível que uma camada evolua um mau comportamento e que a próxima camada compense isso. Esse não é um uso ideal dos neurônios. Com o dropout, há uma alta probabilidade de que o neurônio "fixe" o problema não existe em uma determinada rodada de treinamento. O mau comportamento da camada ofensiva se torna óbvio e os pesos evoluem em direção a um melhor comportamento.

MÁXIMO:

É possível adicionar dropout após cada camada densa intermediária na rede. Não adicione dropouts após a camada softmax. Você estaria descartando suas probabilidades previstas. É possível adicionar uma taxa de desistência de 25% com: tf.keras.layers.Dropout(0.25)

Funcionou?

O ruído reaparece, como o dropout funciona. A perda de validação parece não estar mais aumentando, mas é maior no geral do que sem dropout. E a acurácia da validação diminuiu um pouco. Este é um resultado bastante decepcionante.

Parece que o dropout não era a solução correta, ou talvez houvesse "overfitting" é um conceito mais complexo e algumas de suas causas não são favoráveis a uma "dropout" corrigir?

O que é "overfitting"? O overfitting acontece quando uma rede neural aprende "mal", de uma maneira que funciona para os exemplos de treinamento, mas não tão bem com dados do mundo real. Existem técnicas de regularização, como dropout, que forçam o aprendizado de uma maneira melhor, mas o overfitting também tem raízes mais profundas.

O overfitting básico acontece quando uma rede neural tem muitos graus de liberdade para o problema em questão. Imagine que temos tantos neurônios que a rede pode armazenar todas as nossas imagens de treinamento neles e reconhecê-las por correspondência de padrões. Ele falharia completamente nos dados reais. Uma rede neural precisa ser um pouco restrita para que seja forçada a generalizar o que aprende durante o treinamento.

Se você tiver poucos dados de treinamento, até mesmo uma rede pequena poderá aprender de forma automática e você verá um "overfitting". De modo geral, você sempre precisa de muitos dados para treinar redes neurais.

Por fim, se você fez tudo conforme o livro, experimentou com diferentes tamanhos de rede para garantir que seus graus de liberdade sejam restritos, aplicados dropout e treinados em muitos dados, você ainda pode ficar preso em um nível de desempenho que parece não ser capaz de melhorar. Isso significa que a rede neural, na forma atual, não é capaz de extrair mais informações dos dados, como neste caso.

Lembra como estamos usando nossas imagens, simplificadas em um único vetor? Foi uma má ideia. Os dígitos escritos à mão são feitos de formas, e descartamos as informações de forma quando achatamos os pixels. No entanto, existe um tipo de rede neural que pode aproveitar as informações de forma: as redes convolucionais. Vamos testá-las.

Se você não souber o que fazer, veja a solução neste momento:

keras_03_mnist_dense_lrdecay_dropout.ipynb

10. [INFO] redes convolucionais

Resumindo

Se todos os termos em negrito no próximo parágrafo já forem conhecidos, siga para o próximo exercício. Se você está começando a trabalhar com redes neurais convolucionais, continue lendo.

Ilustração: filtrar uma imagem com dois filtros sucessivos feitos de 4 x 4 x 3=48 pesos aprendidos cada.

As redes neurais convolucionais aplicam uma série de filtros que podem ser aprendidos à imagem de entrada. Uma camada convolucional é definida pelo tamanho do filtro (ou kernel), pelo número de filtros aplicados e pelo stride. A entrada e a saída de uma camada convolucional têm três dimensões (largura, altura, número de canais), começando com a imagem de entrada (largura, altura, canais RGB). Ao empilhar camadas convolucionais, a largura e a altura da saída podem ser ajustadas usando um salto maior que 1 ou com uma operação max-pooling. A profundidade da saída (número de canais) é ajustada usando mais ou menos filtros.

É assim que uma rede neural convolucional simples aparece no Keras:

model = tf.keras.Sequential([
    tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1)),
    tf.keras.layers.Conv2D(kernel_size=3, filters=12, activation='relu'),
    tf.keras.layers.Conv2D(kernel_size=6, filters=24, strides=2, activation='relu'),
    tf.keras.layers.Conv2D(kernel_size=6, filters=32, strides=2, activation='relu'),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(10, activation='softmax')
])

Em uma camada de uma rede convolucional, um "neurônio" faz uma soma ponderada dos pixels logo acima dela, em uma pequena região da imagem. Ela adiciona um viés e alimenta a soma por meio de uma função de ativação, assim como um neurônio em uma camada densa regular faria. Essa operação é então repetida em toda a imagem usando os mesmos pesos. Lembre-se de que, nas camadas densas, cada neurônio tinha os próprios pesos. Aqui, um único "patch" de pesos desliza pela imagem em ambas as direções (uma "convolução"). A saída tem tantos valores quanto pixels na imagem, mas é necessário um pouco de padding nas bordas. Trata-se de uma operação de filtragem. Na ilustração acima, ele usa um filtro de pesos 4x4x3=48.

No entanto, 48 pesos não serão suficientes. Para adicionar mais graus de liberdade, repetimos a mesma operação com um novo conjunto de pesos. Isso produz um novo conjunto de saídas de filtro. Vamos chamá-lo de "canal" por analogia com os canais R, G e B na imagem de entrada.

Os dois (ou mais) conjuntos de pesos podem ser somados como um tensor com a adição de uma nova dimensão. Isso nos dá o formato genérico do tensor de pesos para uma camada convolucional. Como o número de canais de entrada e saída são parâmetros, podemos começar a empilhar e encadear camadas convolucionais.

Ilustração: uma rede neural convolucional transforma "cubos" de dados em outros "cubos" de dados.

Convoluções tracejadas, pooling máximo

Ao realizar as convoluções com um passo de 2 ou 3, também podemos reduzir o cubo de dados resultante em suas dimensões horizontais. Há duas maneiras comuns de fazer isso:

• Convolução em desvio: um filtro deslizante como acima, mas com um passo >1
• Pool máximo: uma janela deslizante que aplica a operação MAX (normalmente em patches 2x2, repetidos a cada 2 pixels)

Ilustração: deslizar a janela de computação em 3 pixels resulta em menos valores de saída. Convoluções em excesso ou pooling máximo (máximo em uma janela 2x2 deslizando em um salto de 2) são uma maneira de reduzir o cubo de dados nas dimensões horizontais.

Max-pooling" pode nos ajudar a entender intuitivamente como as redes convolucionais funcionam: se você presumir que, durante o treinamento, os blocos de pesos evoluem para filtros que reconhecem formas básicas (linhas horizontais e verticais, curvas, etc.), então uma maneira de absorver informações úteis é manter nas camadas as saídas em que uma forma foi reconhecida com a intensidade máxima. Na prática, em uma camada de pool máximo, as saídas são processadas em grupos de 2x2, e apenas o valor máximo é mantido.

A camada final

Após a última camada convolucional, os dados estão na forma de um "cubo". Há duas maneiras de alimentá-lo pela camada densa final.

A primeira é nivelar o cubo de dados em um vetor e, em seguida, alimentar a camada softmax. Às vezes, é possível até adicionar uma camada densa antes da camada softmax. Isso costuma ser caro em termos de número de pesos. Uma camada densa no final de uma rede convolucional pode conter mais da metade dos pesos de toda a rede neural.

Em vez de usar uma camada densa cara, também podemos dividir os dados recebidos em "cubo" em tantas partes quanto tivermos classes, calcular a média de seus valores e alimentá-los por meio de uma função de ativação softmax. Essa maneira de criar o cabeçalho de classificação não custa peso. No Keras, há uma camada para isso: tf.keras.layers.GlobalAveragePooling2D().

Redes neurais convolucionais detectam a localização das coisas. Quando um filtro responde fortemente a algum recurso, isso é feito em um local específico (x, y). Dependendo do que você quer fazer, uma rede neural pode ser treinada para usar ou descartar esses dados de local. O uso de pool de média global descarta explicitamente todos os dados de local. Isso pode ser bom para um classificador de flores, mas pode não funcionar bem para outras tarefas, como contar flores em uma imagem. Use com cuidado.

Vá para a próxima seção e crie uma rede convolucional para o problema em questão.

11. Uma rede convolucional

Vamos criar uma rede convolucional para reconhecimento de dígitos manuscritos. Usaremos três camadas convolucionais na parte de cima (nossa camada tradicional de leitura de softmax) na parte de baixo e as conectaremos a uma camada totalmente conectada:

Observe que a segunda e a terceira camadas convolucionais têm um salto de dois, o que explica por que elas reduzem o número de valores de saída de 28x28 para 14x14 e depois 7x7.

Vamos escrever o código Keras.

É necessária atenção especial antes da primeira camada convolucional. Na realidade, espera-se um "cubo" 3D de dados, mas nosso conjunto de dados foi configurado até agora para camadas densas e todos os pixels das imagens estão achatados em um vetor. Precisamos remodelá-las para imagens de 28 x 28 x 1 (um canal para imagens em escala de cinza):

tf.keras.layers.Reshape(input_shape=(28*28,), target_shape=(28, 28, 1))

Você pode usar essa linha em vez da camada tf.keras.layers.Input que tinha até agora.

No Keras, a sintaxe de uma camada convolucional ativada por "relu" é:

tf.keras.layers.Conv2D(kernel_size=3, filters=12, padding='same', activation='relu')

O parâmetro de padding em camadas convolucionais pode ter dois valores:

• "same": preencha com zeros para produzir saídas com a mesma largura/altura que a entrada
• "valid": sem padding, use apenas pixels reais.

Usamos padding aqui, então defina o padding como "same".

Para uma convolução truncada, você escreveria:

tf.keras.layers.Conv2D(kernel_size=6, filters=24, padding='same', activation='relu', strides=2)

Para nivelar um cubo de dados em um vetor para que ele possa ser consumido por uma camada densa:

tf.keras.layers.Flatten()

E para a camada densa, a sintaxe não mudou:

tf.keras.layers.Dense(200, activation='relu')

MÁXIMO:

Modifique seu modelo para transformá-lo em um modelo convolucional. Você pode usar os valores do desenho acima para dimensioná-lo. É possível manter o declínio da taxa de aprendizado como antes, mas remova o dropout neste momento.

Aumente também o fator de zoom para 16 no PlotTraining. Esse valor aumenta em torno de 0 nas perdas e em torno de 1 nas imprecisões para ajudar você a entender o que está acontecendo: PlotTraining(sample_rate=10, zoom=16)

Seu modelo quebrou a barreira de precisão dos 99%? Quase... mas observe a curva de perda de validação. Isso soa como um alerta?

Observe também as previsões. Pela primeira vez, você verá que a maioria dos 10.000 dígitos de teste agora são reconhecidos corretamente. Apenas cerca de 4,5 linhas de detecções incorretas permanecem (cerca de 110 dígitos de 10.000)

Se você não souber o que fazer, veja a solução neste momento:

keras_04_mnist_convolutional.ipynb

12. Desistência de novo

O treinamento anterior mostra sinais claros de overfitting (e ainda está abaixo de 99% de precisão). Devemos tentar dropout novamente?

MÁXIMO:

Adicione uma camada de dropout entre as duas camadas densas na rede. Use uma taxa de dropout de 40% (=0,4):

tf.keras.layers.Dropout(0.4)

A aplicação de dropouts a camadas convolucionais é possível, mas funciona de maneira um pouco diferente e geralmente não é tão eficaz, porque há muito menos pesos nas camadas convolucionais e, portanto, menos chances de uma má coadaptação. Não vamos explorar isso.

Como foi desta vez?

Parece que o dropout funcionou desta vez. A perda de validação não está mais aumentando, e a precisão final deve estar muito acima de 99%. Parabéns!

Na primeira vez que tentamos aplicar dropout, pensamos que tínhamos um problema de overfitting quando, na verdade, o problema estava na arquitetura da rede neural. Não poderíamos ir mais longe sem as camadas convolucionais, e não há nada que o dropout possa fazer a respeito.

Desta vez, parece que o overfitting foi a causa do problema e o dropout realmente ajudou. Lembre-se de que há muitas coisas que podem causar uma desconexão entre as curvas de perda de treinamento e de validação, com a perda de validação subindo. O overfitting (muitos graus de liberdade, mal usado pela rede) é apenas um deles. Se o conjunto de dados for muito pequeno ou se a arquitetura da rede neural não for adequada, você verá um comportamento semelhante nas curvas de perda, mas o dropout não ajudará.

13. Normalização em lote

Por fim, vamos adicionar a normalização em lote.

O que é normalização em lote?

Em poucas palavras, a norma em lote tenta resolver o problema de como as saídas dos neurônios são distribuídas em relação à função de ativação do neurônio. Em um minilote de dados de treinamento, a saída de um neurônio, antes da ativação, poderia ter as seguintes distribuições:

Muito à esquerda, após a ativação da sigmoide, esse neurônio quase sempre gera 0.

Muito estreito, esse neurônio nunca gera um 0 ou 1 claro.

Isso não é tão ruim. O neurônio terá uma gama razoável de comportamentos nesse minilote.

Para corrigir isso, a norma em lote normaliza as saídas de neurônios em um lote de dados de treinamento, ou seja, subtrai a média e divide pelo desvio padrão. No entanto, fazer isso seria muito cruel. Com uma distribuição perfeitamente centrada e normalmente ampla em todos os lugares, todos os neurônios teriam o mesmo comportamento. O truque é introduzir dois outros parâmetros que podem ser aprendidos por neurônio, α e ε, e calcular:

α normalizado_out + vertical

Depois, aplique a função de ativação (sigmoide, relu, ...). Dessa forma, a rede decide, por meio de machine learning, quanta centralização e redimensionamento aplicar a cada neurônio. Como exercício, o leitor deve verificar se há valores de α e α que podem remover a normalização, se essa for a coisa certa a fazer.

Na prática, α e α nem sempre são necessários. No Keras, elas são chamadas de "escala". e "centralizar" e é possível usar seletivamente um ou outro, por exemplo:

tf.keras.layers.BatchNormalization(scale=False, center=True)

O problema da norma de lote é que, no momento da previsão, você não tem lotes de treinamento para calcular as estatísticas das saídas dos neurônios. Mas você ainda precisa desses valores. Essa parte é meio complicada. Durante o treinamento, um "comum" o desvio padrão e a média da saída de neurônios são calculados em uma coluna e o número de lotes, na prática, usando uma média exponencial em execução. Essas estatísticas são usadas no momento da inferência.

A boa notícia é que no Keras é possível usar uma camada tf.keras.layers.BatchNormalization e toda essa contabilização acontece automaticamente.

Essa é a teoria. Na prática, lembre-se de algumas regras:

Norma em lote "conforme o manual":

1. A normalização em lote ocorre entre a saída de uma camada e a função de ativação dela.
2. Se você usar center=True na norma de lote, não precisará de vieses na camada. O deslocamento de norma de lote desempenha o papel de um viés.
3. Se você usar uma função de ativação que é invariante em escala (ou seja, não muda a forma se você aumentar o zoom), defina scale=False. O Relu não varia de escalonamento. A sigmoide não é.

Essa é a teoria, mas a única maneira de descobrir se quebrar essas regras é ruim é tentar.

Vamos dar uma olhada no manual por enquanto e adicionar uma camada de norma em lote em cada camada de rede neural, exceto na última. Não a adicione ao último "softmax" camada Isso não seria útil.

# Modify each layer: remove the activation from the layer itself.
# Set use_bias=False since batch norm will play the role of biases.
tf.keras.layers.Conv2D(..., use_bias=False),
# Batch norm goes between the layer and its activation.
# The scale factor can be turned off for Relu activation.
tf.keras.layers.BatchNormalization(scale=False, center=True),
# Finish with the activation.
tf.keras.layers.Activation('relu'),

Como está a precisão agora?

Com alguns ajustes (BATCH_SIZE=64, parâmetro de redução da taxa de aprendizado 0,666, taxa de dropout na camada densa 0,3) e um pouco de sorte, você pode chegar a 99,5%. Os ajustes na taxa de aprendizado e nas desistências foram feitos seguindo as "práticas recomendadas" para usar a norma em lote:

• A norma em lote ajuda as redes neurais a convergir e geralmente permite o treinamento mais rápido.
• A norma em lote é um regularizador. Em geral, é possível diminuir a quantidade de dropout usada ou até mesmo não usá-los.

O notebook da solução tem uma execução de treinamento de 99,5%:

keras_05_mnist_batch_norm.ipynb

14. Treine na nuvem em um hardware avançado: AI Platform

Você vai encontrar uma versão do código pronta para a nuvem na pasta mlengine no GitHub, além de instruções para executar esse código na AI Platform do Google Cloud. Antes de executar esta parte, é preciso criar uma conta do Google Cloud e ativar o faturamento. Os recursos necessários para concluir o laboratório devem ser menores que alguns dólares (considerando-se 1h de tempo de treinamento em uma GPU). Para preparar sua conta:

1. Crie um projeto do Google Cloud Platform ( http://cloud.google.com/console).
2. Ative o faturamento.
3. Instale as ferramentas de linha de comando do GCP ( SDK do GCP aqui).
4. Crie um bucket do Google Cloud Storage (coloque na região us-central1). Ele vai ser usado para organizar o código de treinamento e armazenar o modelo treinado.
5. Ative as APIs necessárias e solicite as cotas. Execute o comando de treinamento uma vez para receber mensagens de erro informando o que você precisa ativar.

15. Parabéns!

Você criou sua primeira rede neural e a treinou com 99% de precisão. As técnicas aprendidas ao longo do caminho não são específicas do conjunto de dados do MNIST. Na verdade, elas são amplamente utilizadas no trabalho com redes neurais. Como presente de despedida, aqui estão as "notas do aperto" para o laboratório, na versão em desenho animado. Você pode usá-lo para lembrar o que aprendeu:

Próximas etapas

• Depois das redes totalmente conectadas e convolucionais, você deve dar uma olhada nas redes neurais recorrentes.
• Para executar o treinamento ou a inferência na nuvem em uma infraestrutura distribuída, o Google Cloud oferece o AI Platform.
• Finalmente, adoramos feedback. Avise nossa equipe se você encontrar algo errado no laboratório ou achar que ele precisa ser melhorado. O feedback é resolvido por problemas do GitHub [link do feedback].

Autor: Martin GörnerTwitter: @martin_gorner

Todas as imagens de desenhos animados neste laboratório têm direitos autorais: fotos de banco de fotos alexpokusay / 123RF