Tutorial de rede neural artificial com exemplos de RNA do TensorFlow

O que é Rede Neural Artificial?

An Rede neural artificial (ANN) é um sistema de computador inspirado em redes neurais biológicas para a criação de cérebros artificiais baseados na coleção de unidades conectadas chamadas neurônios artificiais. Ele foi projetado para analisar e processar informações como seres humanos. A Rede Neural Artificial possui recursos de autoaprendizagem para produzir melhores resultados à medida que mais dados estão disponíveis.

Uma Rede Neural Artificial (RNA) é composta por quatro objetos principais:

• Camadas: todo o aprendizado ocorre nas camadas. Existem 3 camadas 1) Entrada 2) Oculta e 3) Saída
• Recurso e rótulo: Dados de entrada na rede (recursos) e saída da rede (rótulos)
• Função de perda: Métrica usada para estimar o desempenho da fase de aprendizagem
• Optimizer: Melhore o aprendizado atualizando o conhecimento na rede

Uma rede neural pegará os dados de entrada e os colocará em um conjunto de camadas. A rede precisa avaliar seu desempenho com uma função de perda. A função perda dá à rede uma ideia do caminho que ela precisa percorrer antes de dominar o conhecimento. A rede precisa aprimorar seu conhecimento com a ajuda de um otimizador.

Se você der uma olhada na figura acima, entenderá o mecanismo subjacente.

O programa pega alguns valores de entrada e os coloca em duas camadas totalmente conectadas. Imagine que você tem um problema de matemática, a primeira coisa que você faz é ler o capítulo correspondente para resolver o problema. Você aplica seu novo conhecimento para resolver o problema. Há uma grande chance de você não pontuar muito bem. É o mesmo para uma rede. Na primeira vez que ele vê os dados e faz uma previsão, ele não corresponde perfeitamente aos dados reais.

Para aprimorar seu conhecimento, a rede utiliza um otimizador. Em nossa analogia, um otimizador pode ser considerado uma releitura do capítulo. Você ganha novos insights/lições lendo novamente. Da mesma forma, a rede utiliza o otimizador, atualiza seus conhecimentos e testa seus novos conhecimentos para verificar o quanto ainda precisa aprender. O programa repetirá esta etapa até cometer o menor erro possível.

Em nossa analogia com o problema matemático, significa que você lê o capítulo do livro muitas vezes até compreender completamente o conteúdo do curso. Mesmo depois de ler várias vezes, se continuar errando, significa que atingiu a capacidade de conhecimento com o material atual. Você precisa usar um livro diferente ou testar um método diferente para melhorar sua pontuação. Para uma rede neural, é o mesmo processo. Se o erro estiver longe de 100%, mas a curva for plana, significa com a arquitetura atual; não pode aprender mais nada. A rede precisa ser melhor otimizada para melhorar o conhecimento.

Rede neural Archiarquitetura

A Rede Neural Artificial ArchiA estrutura consiste nos seguintes componentes:

• Camadas
• Função de ativação
• Função de perda
• Optimizer

Camadas

Uma camada é onde todo o aprendizado ocorre. Dentro de uma camada, existe uma quantidade infinita de pesos (neurônios). Uma rede neural típica é frequentemente processada por camadas densamente conectadas (também chamadas de camadas totalmente conectadas). Isso significa que todas as entradas estão conectadas à saída.

Uma rede neural típica utiliza um vetor de entrada e um escalar que contém os rótulos. A configuração mais confortável é uma classificação binária com apenas duas classes: 0 e 1.

A rede recebe uma entrada, envia-a para todos os nós conectados e calcula o sinal com um ativação função.

A figura acima traça essa ideia. A primeira camada contém os valores de entrada para a segunda camada, chamada de camada oculta, que recebe a entrada ponderada da camada anterior

1. O primeiro nó são os valores de entrada
2. O neurônio é decomposto na parte de entrada e na função de ativação. A parte esquerda recebe todas as entradas da camada anterior. A parte direita é a soma das entradas de entrada para uma função de ativação.
3. Valor de saída calculado a partir das camadas ocultas e usado para fazer uma previsão. Para classificação, é igual ao número da turma. Para regressão, apenas um valor é previsto.

Função de ativação

A função de ativação de um nó define a saída dado um conjunto de entradas. Você precisa de uma função de ativação para permitir que a rede aprenda padrões não lineares. Uma função de ativação comum é uma Relu, unidade linear retificada. A função fornece zero para todos os valores negativos.

As outras funções de ativação são:

• Linear por partes
• Sigmóide
• Tanh
• Relu com vazamento

A decisão crítica a tomar ao construir uma rede neural é:

• Quantas camadas na rede neural
• Quantas unidades ocultas para cada camada

Redes neurais com muitas camadas e unidades ocultas podem aprender uma representação complexa dos dados, mas tornam a computação da rede muito cara.

Função de perda

Depois de definir as camadas ocultas e a função de ativação, você precisa especificar a função de perda e o otimizador.

Para classificação binária, é prática comum usar uma função binária de perda de entropia cruzada. Na regressão linear, você usa o erro quadrático médio.

A função de perda é uma métrica importante para estimar o desempenho do otimizador. Durante o treinamento, essa métrica será minimizada. Você precisa selecionar essa quantidade com cuidado, dependendo do tipo de problema com o qual está lidando.

Optimizer

A função de perda é uma medida do desempenho do modelo. O otimizador ajudará a melhorar os pesos da rede para diminuir a perda. Existem diferentes otimizadores disponíveis, mas o mais comum é o Stochastic Gradient Descent.

Os otimizadores convencionais são:

• Momentum otimização,
• Gradiente Acelerado Nesterov,
• AdaGrad,
• Otimização de Adam

Limitações da rede neural

A seguir estão as limitações da rede neural:

Overfitting

Um problema comum com redes neurais complexas são as dificuldades em generalizar dados invisíveis. Uma rede neural com muitos pesos pode identificar muito bem detalhes específicos no conjunto de trens, mas geralmente leva a um overfitting. Se os dados estiverem desequilibrados dentro dos grupos (isto é, não há dados suficientes disponíveis em alguns grupos), a rede aprenderá muito bem durante o treinamento, mas não terá a capacidade de generalizar tal padrão para dados nunca vistos antes.

Existe uma compensação no aprendizado de máquina entre otimização e generalização.

Otimizar um modelo requer encontrar os melhores parâmetros que minimizem a perda do conjunto de treinamento.

A generalização, entretanto, diz como o modelo se comporta para dados não vistos.

Para evitar que o modelo capture detalhes específicos ou padrões indesejados dos dados de treinamento, você pode usar técnicas diferentes. O melhor método é ter um conjunto de dados balanceado com quantidade suficiente de dados. A arte de reduzir o overfitting é chamada regularização. Vamos revisar algumas técnicas convencionais.

Tamanho da rede

Uma rede neural com muitas camadas e unidades ocultas é conhecida por ser altamente sofisticada. Uma maneira direta de reduzir a complexidade do modelo é reduzir seu tamanho. Não há práticas recomendadas para definir o número de camadas. Você precisa começar com uma pequena quantidade de camada e aumentar seu tamanho até encontrar o ajuste excessivo do modelo.

Regularização de Peso

Uma técnica padrão para evitar o overfitting é adicionar restrições aos pesos da rede. A restrição força o tamanho da rede a assumir apenas valores pequenos. A restrição é adicionada à função de perda do erro. Existem dois tipos de regularização:

L1: Lasso: O custo é proporcional ao valor absoluto dos coeficientes de peso

L2: Ridge: O custo é proporcional ao quadrado do valor dos coeficientes de peso

Cair fora

O abandono é uma técnica estranha, mas útil. Uma rede com dropout significa que alguns pesos serão definidos aleatoriamente como zero. Imagine que você tem uma matriz de pesos [0.1, 1.7, 0.7, -0.9]. Se a rede neural tiver uma desistência, ela se tornará [0.1, 0, 0, -0.9] com 0 distribuído aleatoriamente. O parâmetro que controla a desistência é a taxa de desistência. A taxa define quantos pesos serão zerados. Ter uma taxa entre 0.2 e 0.5 é comum.

Exemplo de rede neural no TensorFlow

Vamos ver um exemplo de rede neural artificial em ação sobre como uma rede neural funciona para um problema típico de classificação. Existem duas entradas, x1 e x2 com um valor aleatório. A saída é uma classe binária. O objetivo é classificar o rótulo com base nas duas características. Para realizar esta tarefa, a arquitetura da rede neural é definida da seguinte forma:

• Duas camadas ocultas
  • A primeira camada tem quatro neurônios totalmente conectados
  • A segunda camada tem dois neurônios totalmente conectados
• A função de ativação é um Relu
• Adicione uma regularização L2 com uma taxa de aprendizagem de 0.003

A rede otimizará o peso durante 180 épocas com um tamanho de lote de 10. No vídeo de exemplo da RNA abaixo, você pode ver como os pesos evoluem e como a rede melhora o mapeamento de classificação.

Em primeiro lugar, a rede atribui valores aleatórios a todos os pesos.

• Com os pesos aleatórios, ou seja, sem otimização, a perda de saída é de 0.453. A imagem abaixo representa a rede com cores diferentes.
• Em geral, a cor laranja representa valores negativos enquanto as cores azuis mostram os valores positivos.
• Os pontos de dados têm a mesma representação; os azuis são os rótulos positivos e os laranja os rótulos negativos.

Dentro da segunda camada oculta, as linhas são coloridas seguindo o sinal dos pesos. As linhas laranja atribuem pesos negativos e a azul atribui pesos positivos

Como você pode ver, no mapeamento de saída, a rede está cometendo muitos erros. Vamos ver como a rede se comporta após a otimização.

A imagem do exemplo de RNA abaixo mostra os resultados da rede otimizada. Primeiro de tudo, você percebe que a rede aprendeu com sucesso como classificar o ponto de dados. Você pode ver na foto anterior; o peso inicial foi de -0.43, enquanto após a otimização resulta em um peso de -0.95.

A ideia pode ser generalizada para redes com mais camadas e neurônios ocultos. Você pode brincar no link.

Como treinar uma rede neural com TensorFlow

Aqui está o processo passo a passo sobre como treinar uma rede neural com TensorFlow ANN usando o estimador da API DNNClassifier.

Usaremos o conjunto de dados MNIST para treinar sua primeira rede neural. Treinando uma rede neural com TensorFlow não é muito complicado. A etapa de pré-processamento é exatamente igual à dos tutoriais anteriores. Você procederá da seguinte forma:

• Etapa 1: importe os dados
• Etapa 2: transformar os dados
• Etapa 3: construir o tensor
• Etapa 4: construir o modelo
• Etapa 5: treinar e avaliar o modelo
• Etapa 6: Melhore o modelo

Etapa 1) Importe os dados

Primeiro de tudo, você precisa importar a biblioteca necessária. Você pode importar o conjunto de dados MNIST usando o scikit learn, conforme mostrado no exemplo da Rede Neural TensorFlow abaixo.

O conjunto de dados MNIST é o conjunto de dados comumente usado para testar novas técnicas ou algoritmos. Este conjunto de dados é uma coleção de imagens de 28×28 pixels com um dígito manuscrito de 0 a 9. Atualmente, o erro mais baixo no teste é de 0.27 por cento com um comitê de 7 redes neurais convolucionais.

import numpy as np
import tensorflow as tf
np.random.seed(1337)

Você pode baixar o scikit learn temporariamente neste endereço. Copie e cole o conjunto de dados em uma pasta conveniente. Para importar os dados para python, você pode usar fetch_mldata do scikit learn. Cole o caminho do arquivo dentro de fetch_mldata para buscar os dados.

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata(' /Users/Thomas/Dropbox/Learning/Upwork/tuto_TF/data/mldata/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)

Depois disso, você importa os dados e obtém o formato de ambos os conjuntos de dados.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )

Etapa 2) Transforme os dados

No tutorial anterior, você aprendeu que precisa transformar os dados para limitar o efeito de valores discrepantes. Neste tutorial sobre redes neurais, você transformará os dados usando o escalonador min-max. A fórmula é:

(X-min_x)/(max_x - min_x)

Scikit descobre que já tem uma função para isso: MinMaxScaler()

## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

Etapa 3) Construa o tensor

Agora você está familiarizado com a maneira de criar tensor no Tensorflow. Você pode converter o conjunto de trens em uma coluna numérica.

feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

Etapa 4) Construa o modelo

A arquitetura da rede neural contém 2 camadas ocultas com 300 unidades para a primeira camada e 100 unidades para a segunda. Usamos esses valores com base em nossa própria experiência. Você pode ajustar esses valores e ver como isso afeta a precisão da rede.

Para construir o modelo, você usa o estimador DNNClassifier. Você pode adicionar o número de camadas aos argumentos feature_columns. Você precisa definir o número de classes para 10, pois há dez classes no conjunto de treinamento. Você já está familiarizado com a sintaxe do objeto estimador. Os argumentos apresentam colunas, número de classes e model_dir são exatamente os mesmos do tutorial anterior. O novo argumento hidden_unit controla o número de camadas e quantos nós conectar à rede neural. No código abaixo, existem duas camadas ocultas, sendo a primeira conectando 300 nós e a segunda com 100 nós.

Para construir o estimador, use tf.estimator.DNNClassifier com os seguintes parâmetros:

• feature_columns: Defina as colunas a serem usadas na rede
• hidden_units: Defina o número de neurônios ocultos
• n_classes: Defina o número de classes a serem previstas
• model_dir: Defina o caminho do TensorBoard

estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100], 
    n_classes=10, 
    model_dir = '/train/DNN')

Etapa 5) Treine e avalie o modelo

Você pode usar o método numpy para treinar o modelo e avaliá-lo

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 

Saída:

{'accuracy': 0.9637143,
 'average_loss': 0.12014342,
 'loss': 1682.0079,
 'global_step': 1000}

A arquitetura atual leva a uma precisão no conjunto de avaliação de 96%.

Etapa 6) Melhorar o modelo

Você pode tentar melhorar o modelo adicionando parâmetros de regularização.

Usaremos um otimizador Adam com taxa de abandono de 0.3, L1 de X e L2 de y. Na Rede Neural TensorFlow, você pode controlar o otimizador usando o trem de objetos seguido pelo nome do otimizador. TensorFlow é uma API integrada para o otimizador Proximal AdaGrad.

Para adicionar regularização à rede neural profunda, você pode usar tf.train.ProximalAdagradOptimizer com o seguinte parâmetro

• Taxa de aprendizagem: taxa_de_aprendizagem
• Regularização L1: l1_regularization_strength
• Regularização L2: l2_regularization_strength

estimator_imp = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3, 
    n_classes = 10,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ),
    model_dir = '/train/DNN1')
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None) 

Saída:

{'accuracy': 0.95057142,
 'average_loss': 0.17318928,
 'loss': 2424.6499,
 'global_step': 2000}

Os valores escolhidos para reduzir o sobreajuste não melhoraram a precisão do modelo. Seu primeiro modelo teve precisão de 96% enquanto o modelo com regularizador L2 tem precisão de 95%. Você pode tentar valores diferentes e ver como isso afeta a precisão.

Resumo

Neste tutorial, você aprende como construir uma rede neural. Uma rede neural requer:

• Número de camadas ocultas
• Número de nó totalmente conectado
• Função de ativação
• Optimizer
• Número de aulas

No TensorFlow ANN, você pode treinar uma rede neural para problemas de classificação com:

• tf.estimator.DNNClassifier

O estimador requer especificar:

• feature_columns = feature_columns,
• unidades_ocultas=[300, 100]
• n_classes=10
• dir_modelo

Você pode melhorar o modelo usando diferentes otimizadores. Neste tutorial, você aprendeu como usar o otimizador Adam Grad com uma taxa de aprendizado e adicionar um controle para evitar overfitting.