Aprendizado prático de máquina com Keras

Prepare-se para acelerar a construção de modelos ML práticos com Keras

Arkajyoti Mukherjee Segue 15 de jul · 9 min ler

O que este artigo é sobre?

Neste artigo, tentei explicar o que é keras e resumi todas as maneiras como construo um modelo em keras, explicando todas as dicas práticas e todas as nuances relacionadas a ele. Este artigo ensinará várias técnicas comuns de complexidade crescente usadas na construção de modelos.

  • Modelos sequenciais
  • API funcional (avançado)
  • Subclassificação do modelo (avançado)

Trabalharemos com um conjunto de dados muito famoso de dígitos manuscritos chamado MNIST e criaremos modelos CNN nesses três métodos diferentes. Também incluirei o carregamento básico e o uso de dados.

O que este artigo não é?

Este artigo não vai te ensinar a teoria ou a matemática por trás do aprendizado de máquina. Se você é novo em aprendizado de máquina ou apenas começou a aprendê-lo, fornecerei alguns recursos para ajudá-lo.

Agora com isso fora do caminho, vamos começar a aprender.

O que é o Keras?

Keras é um alto nível API rede neural, escrito em Python e capaz de correr em cima de TensorFlow , CNTK , ou Theano (Nós estaremos usando Keras com Tensorflow como backend).

Ignorando a definição formal, o keras é uma biblioteca de aprendizado de máquina fácil de usar que pode ser usada para fazer protótipos rápidos para construir modelos personalizados complexos para pesquisa e produção e qualquer coisa entre eles. Keras tem uma API muito modular e composable no sentido que os modelos de Keras são feitos conectando blocos de construção configuráveis juntos (você verá em um pouco, como é fácil).

Vamos sujar nossas mãos

Agora que você sabe um pouco sobre o que é o keras, vamos mergulhar direto na implementação prática dele.

Importar tf.keras

tf.keras é a implementação do TensorFlow da especificação da API Keras . Esta é uma API de alto nível para construir e treinar modelos que incluem suporte de primeira classe para a funcionalidade específica do TensorFlow.

Carregue os dados

 Forma original: (60000, 28, 28) (60000,) (10000, 28, 28) (10000,) 
Depois de remodelar e normalizar: (60000, 28, 28, 1) (10000, 28, 28, 1) (60000,) (10000,)

Traçar um exemplo de treinamento

Converter rótulos para categorical

 (60000, 28, 28, 1) (10000, 28, 28, 1) (60000, 10) (10000, 10) 

Agora que temos nossos dados carregados e todos preparados para lançar em um modelo de aprendizado de máquina, podemos escrever nosso primeiro modelo. Você fez bem meu amigo, tem uma foto de gato como recompensa.

motivação do gato: vamos aprender um pouco mais

Modelo sequencial

Em keras, os modelos podem ser divididos em gráficos de camadas com diferentes conexões entre eles. O tipo mais comum é uma pilha de camadas, daí o nome Sequential.

Vamos ver as diferentes maneiras de adicionar ativações, inicializadores e regularizações:

  • ativação : este parâmetro define a função de ativação para a camada. O padrão é sem ativação.
  • kernel_initializer e bias_initializer : Os esquemas de inicialização criam pesos para as camadas. O padrão é uniforme de Glorot.
  • kernel_regularizer e bias_regularizer : Aplique a regularização L1 e L2 aos pesos para controlar o overfitting do modelo. O padrão é sem regularização.

Construa um para MNIST

Vamos construir um modelo para classificar os dados MNIST. Aqui estaremos mostrando como definir as camadas Convolutional e MaxPool. Nós estaremos usando uma estrutura padrão para construir uma camada CNN: Conv seguida por camadas MaxPool. Em seguida, nivelamos as camadas com a camada Flatten e aplicamos Totalmente conectado com Densidade seguido por uma camada de classificação final, que classifica a previsão nas classes de saída 10 [0–9]. Você verá a estrutura mais claramente quando chamamos model.summary ().

 Modelo: "sequential_1" _________________________________________________________________ Camada (tipo) Forma de saída Param # ==================================== ============================= conv2d (Conv2D) (Nenhum, 26, 26, 32) 320 _________________________________________________________________ max_pooling2d (MaxPooling2D) (Nenhum , 13, 13, 32) 0 _________________________________________________________________ conv2d_1 (Conv2D) (Nenhum, 11, 11, 64) 18496 _________________________________________________________________ max_pool2d_1 (MaxPooling2 (Nenhum, 5, 5, 64) 0 _________________________________________________________________ conv2d_2 (Conv2D) (Nenhum, 3, 3, 64 ) 36928 _________________________________________________________________ achatar (Achatar) (Nenhuma, 576) 0 _________________________________________________________________ densa_9 (Densa) (Nenhuma, 64) 36928 _________________________________________________________________ densa_10 (Densa) (Nenhuma, 10) 650 =============== ================= ================================= Total params: 93,322 Parâmetros treináveis: 93,322 Parâmetros não treináveis: 0 _________________________________________________________________ 

Compile o modelo

Agora que o nosso modelo é construído, temos que configurar o modelo chamando o método compile. São necessários três parâmetros importantes:

  • otimizador : Em termos simples, é a função que determina como sua função de perda deve diminuir.
  • perda : Esta é a função de perda que calcula a que distância sua previsão está dos rótulos reais. Essa é a perda que o otimizador minimiza.
  • métricas : é usado para monitorar o processo de treinamento. Podemos obter informações sobre a perda ou a precisão diminuindo ou aumentando.

Treine o modelo

Temos tudo preparado para treinar, vamos treinar nosso primeiro modelo de keras. Nós treinamos um modelo chamando o método de ajuste no modelo. Esse modelo leva alguns argumentos importantes além dos dados e rótulos de treinamento:

  • épocas : Uma época é uma iteração de todos os dados de entrada. A iteração pode ser feita em tamanhos de lote menores.
  • batch_size : O modelo divide os dados em lotes menores de dados e é alimentado na etapa de treinamento. Cada lote é igual em tamanho, exceto o último, que pode ser menor.
  • validation_data : isso também é conhecido como validação cruzada definida em muitas literaturas de aprendizado de máquina. Isso mede o desempenho do modelo após cada iteração de treinamento.
 Treinar em 60000 amostras, validar em 10000 amostras 
Época 1/5
60000/60000 [==============================] - 9s 150us / sample - loss: 0.1473 - acc: 0.9552 - val_loss : 0,0674 - val_acc: 0,9783
Época 2/5
60000/60000 [==============================] - 7s 117us / sample - perda: 0,0483 - acc: 0,9850 - val_loss : 0,0668 - val_acc: 0,9772
Época 3/5
60000/60000 [==============================] - 7s 116us / amostra - perda: 0,0330 - acc: 0,9899 - val_loss : 0,0397 - val_acc: 0,9882
Época 4/5
60000/60000 [==============================] - 7s 118us / amostra - perda: 0,0266 - acc: 0,9913 - val_loss : 0,0292 - val_acc: 0,9910
Época 5/5
60000/60000 [==============================] - 7s 117us / amostra - perda: 0,0204 - acc: 0,9936 - val_loss : 0.0284 - val_acc: 0.9920
<tensorflow.python.keras.callbacks.History em 0x7f6020679828>

[ Nota : Para o propósito do tutorial, nós tomamos dados de validação e dados de teste como os mesmos, mas na prática, você deve deixar de lado alguns dados não vistos pelo modelo como dados de teste.]

Testando o desempenho

Para testar o desempenho do nosso modelo, podemos usar as previsões ou avaliar o modelo diretamente e obter a perda e precisão, usando funções de previsão e avaliação no modelo, respectivamente.

 Forma de previsão: (10000, 10) Avaliação do modelo: 
10000/10000 [==============================] - 1s 65us / amostra - perda: 0,0334 - acc: 0,9891
[0,033432122451053876, 0,9891]

Vamos verificar quais são as nossas previsões para o primeiro exemplo de teste e também torná-lo um método útil para que possamos chamá-lo para modelos posteriores com índices diferentes.

Parabéns você fez seu primeiro modelo de keras, treinou e fez avaliações. Você merece outra foto de gato por motivação porque alguma coisa adiantada está chegando.

motivação do gato: vamos gooooooooo!

API funcional

Modelos sequenciais são frequentemente usados na prática, mas em muitos casos especiais, você gostaria de definir alguns modelos arbitrários que uma simples pilha de camadas não pode definir. Podemos recorrer ao Keras Functional API em modelos complexos como:

  • Modelos com múltiplas entradas
  • Modelos multi-saída
  • Modelos com camadas compartilhadas, ou seja, a mesma camada são chamados várias vezes
  • Modelos com fluxo de dados não sequencial (por exemplo: conexões residuais como em ResNets)

Construir um modelo com a API Funcional segue um conjunto de regras:

  1. Uma instância de camada é chamada e retorna um tensor como sua saída.
  2. Para realmente criar um modelo, temos que passar um tensor de entrada e saída para uma instância de tf.keras.Model.
  3. O treinamento do modelo acontece como o de um modelo sequencial.

Chega de conversa, agora vamos construir um.

O treinamento e a avaliação para o modelo permanecem os mesmos, então eu vou dar o código aqui. Neste, apenas não usamos um conjunto de validação, em vez disso, usamos um conjunto de testes para avaliar o modelo em dados não vistos após o treinamento.

 10000/10000 [==============================] - 1s 71us / amostra - perda: 0,0368 - acc: 0,9914 
[0,03678753161538142, 0,9914]

Agora você sabe como fazer conexões estranhas e complexas em seu modelo como quiser, mas e se você tivesse que definir seu próprio passe para frente. Nós temos uma solução para isso, mas primeiro, você deve apreciar esta imagem de gato pelo seu trabalho duro.

Gato de química fazendo trocadilhos de química ruim

Subclassificação Modelo

Construímos nosso modelo, definimos nosso próprio fluxo de dados, mas ainda não temos controle total sobre o encaminhamento futuro do modelo. Podemos construir um modelo totalmente personalizável subclassificando a instância tf.keras.Model.

Existem alguns passos envolvidos, preste muita atenção:

  1. Nós temos que criar uma instância de classe de tf.keras.Model e definir todas as camadas como atributos da classe no método __init__ (que basicamente pode ser comparado com um construtor para pessoas não familiarizadas com classes python).
  2. Em seguida, temos que definir nosso encaminhamento personalizado no método de chamada .
  3. Também podemos substituir o método compute_output_shape se quisermos usar nosso modelo de subclasse como parte de um modelo de estilo funcional ( método opcional )

Vamos colocar a teoria em ação e criar um modelo de subclasse para o reconhecimento de dados MNIST:

Vamos treinar, avaliar e testar nosso modelo.

Parabéns agora você conhece as ferramentas para fazer quase todos os tipos de modelos que estão por aí. Vamos aprender mais uma coisa realmente útil antes de tirar uma conclusão, logo após uma pausa para o gato.

quando você codifica e seu gato te motiva

Retornos de chamada personalizados

Um retorno de chamada é um objeto passado para um modelo para personalizar e estender seu comportamento durante o treinamento. Você pode escrever seu próprio retorno de chamada personalizado ou usar os tf.keras.callbacks internos que incluem:

Os parâmetros de retorno de chamada do método de ajuste esperam uma matriz de retornos de chamada; lá, passaremos os retornos de chamada. Neste exemplo, usaremos os dois mais comuns LearningRateScheduler e EarlyStopping.

Vamos treinar, avaliar e testar nosso modelo como antes.

Conclusão

Espero que você tenha achado este artigo útil e um pouco divertido por causa dos gatos. Se você conhece um pouco de aprendizado de máquina de antemão, isso pode ser útil para usar, já que este artigo é exclusivamente orientado para a prática e esperamos que agora você deva sair e fazer alguns projetos realmente incríveis.

Aqui está o link para o código inteiro:

Se você tiver alguma dúvida sobre este artigo ou se eu tiver cometido algum erro fique à vontade para postar nos comentários. Aqui está um gato chique para ler o artigo inteiro.

Você pode me encontrar no Twitter aqui .
Se você é mais uma pessoa do LinkedIn, me pegue aqui .
Ou se o Github é sua coisa, eu também estou .

Não hesite em contactar-me se você tiver um problema com o Machine Learning, Tensorflow ou apenas me acertar com um gato gif, se é sua coisa. Eu não sou especialista, mas vou tentar o meu melhor para ajudá-lo.

Adios
?