Uma Visão Geral Simples do Aprendizado Profundo do Perceptron Multicamadas (MLP)

Conteúdo

Este artigo foi publicado como parte do Data Science Blogathon.

Introdução

Compreender esta rede ajuda-nos a obter informações sobre as razões subjacentes nos modelos avançados de Deep Learning. O perceptrão multicamada é usado frequentemente em problemas de regressão simples. Porém, os MLP não são ideais para processar padrões com dados sequenciais e multidimensionais.

🙄 Um perceptrão multicamada esforça-se por memorizar padrões em dados sequenciais, devido a isto, requere uma “grande” quantidade de parametros para processar dados multidimensionais.

Para dados sequenciais, a RNN são os favoritos porque os seus padrões permitem que a rede descubra a dependência 🧠 dos dados históricos, o que é muito útil para previsões. Para dados, como imagens e vídeos, CNN sobressaem na extração de mapas de recursos para classificação, O desempenho é exibido como gráficos de dispersão e caixa, entre outras tarefas.
Em alguns casos, uma CNN na forma de Conv1D / 1D também é utilizado para redes com dados de entrada sequenciais. Porém, na maioria dos modelos de Aprendizagem profunda, MLP, CNN ou RNN são combinadas para tirar o máximo proveito de cada uma.

MLP, CNN e RNN não fazem tudo …
Grande parte do seu sucesso provém de identificar o seu objetivo e da boa escolha de alguns parâmetros, O que Função de perda, Otimizador, e Regularizador.

Também dispomos de dados externos ao ambiente de treino. O papel do regularizador é garantir que o modelo treinado se generalize para novos dados.

1eloyeyfrblghvzhu345pjw-5950207

Conjunto de dados MNIST

Suponhamos que o nosso objetivo é criar uma rede para identificar números com base em dígitos manuscritos. Por exemplo, quando a entrada da rede é uma imagem de um número 8, a previsão correspondente também deve ser 8.
🤷🏻‍♂️ Este es un trabajo básico de clasificación con redes neuronales.

Antes de analizar el modelo MLP, es esencial comprender el conjunto de datos del MNIST. Se utiliza para explicar y validar muchas teorías de aprendizado profundo porque las 70.000 imágenes que contiene son pequeñas pero suficientemente ricas en información;

mninst-digits-6507742

MNIST es una colección de dígitos que van del 0 al 9. Tiene un conjunto de Treinamento a partir de 60.000 imágenes y 10.000 pruebas clasificadas en categorías.

Usar el conjunto de datos MNIST en TensorFlow es simple.

importar entorpecido Como por exemplo
a partir de tensorflow.keras.datasets importar mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
a mnist.load_data () El método es conveniente, ya que no es necesario cargar las 70.000 imágenes y sus etiquetas.

Antes de entrar en el clasificador de Perceptrón Multicapa, es fundamental tener en cuenta que, si bien los datos del MNIST constan de tensores bidimensionales, devem ser remodelados, segundo o tipo de camada de entrada.

Muda-se a forma de uma imagem em escala de cinzentos de 3 × 3 para as camadas de entrada MLP, CNN e RNN:

inputs-nn-8592597

As etiquetas têm a forma de dígitos, do 0 al 9.

num_labels = len(np.unique(y_train))
imprimir("total de etiquetas:t{}".formato(num_labels))
imprimir("rótulos:ttt{0}".formato(np.unique(y_train)))

⚠️ Esta representação não é adequada para a camada de previsão que gera probabilidade por classe. O formato mais adequado é one-hot, um vetor de 10 dimensões como todos os valores 0, exceto o índice de classe. Por exemplo, se a etiqueta for 4, o vetor equivalente é [0,0,0,0, 1, 0,0,0,0,0].

En Deep Learning, os dados são armazenados em um tensor. O termo tensor aplica-se a um tensor escalar (tensor 0D), vetor (tensor 1D), matriz (tensor bidimensional) e tensor multidimensional.

#converter em one-hot
from tensorflow.keras.utils import to_categorical
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)

Nuestro modelo es un MLP, por lo que sus entradas deben ser un tensor 1D. Como tal, x_train y x_test deben transformarse en [60,000, 2828] e [10,000, 2828],

Em suma, el tamaño de -1 significa permitir que la biblioteca calcule la dimensión correta. En el caso de x_train, isto é 60.000.

image_size = x_train.shape[1] 
input_size = image_size * image_size

print("x_train:t{}".formato(x_train.forma))
imprimir("x_test:tt{}n".formato(x_test.forma))

x_train = np.reshape(x_train, [-1, input_size])
x_train = x_train.astype('float32') / 255

x_test = np.reshape(x_test, [-1, input_size])
x_test = x_test.astype('float32') / 255

imprimir("x_train:t{}".formato(x_train.forma))
imprimir("x_test:tt{}".formato(x_test.forma))
OUTPUT:
x_train:	(60000, 28, 28)
x_test:		(10000, 28, 28)

x_train:	(60000, 784)
x_test:		(10000, 784)

Construyendo el modelo

mlp-nn-3471040
Nuestro modelo consta de tres capas de perceptrón multicapa en una camada densa. El primero y el segundo son idénticos, seguidos de un Unidade linear retificada (retomar) e Sair função de despertar.

1oepahrm74rnnneolprmtaq-9887397

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Ativação, Cair fora

# Parameters
batch_size = 128 # É o tamanho da amostra de entradas a serem processadas em cada etapa de treinamento. 
hidden_units = 256
dropout = 0.45

# Nossa  MLP com ReLU e Dropout 
model = Sequential()

model.add(Denso(hidden_units, input_dim=input_size))
model.add(Ativação('relu'))
model.add(Cair fora(cair fora))

model.add(Denso(hidden_units))
model.add(Ativação('relu'))
model.add(Cair fora(cair fora))

model.add(Denso(num_labels))

Regularização

Una red neuronal tiende a memorizar sus datos de entrenamiento, especialmente si contiene capacidad más que suficiente. Neste caso, la red falla catastróficamente cuando se somete a los datos de prueba.

Este es el caso clásico en el que la red no logra generalizar (Sobreajuste / Ajuste insuficiente). Para evitar esta tendência, el modelo utiliza una capa reguladora. Sair.

1iwqzxhvlvadk6vajjsgxgg-5873176

La idea de Dropout es simple. Dada una tasa de descarte (en nuestro modelo, establecemos = 0,45), la capa elimina aleatoriamente esta fracción de unidades.

Por exemplo, si la primera capa tiene 256 unidades, después de que se aplica el abandono (0.45), só (1 – 0.45) * 255 = 140 unidades participarán en la siguiente capa

La deserción hace que las redes neuronales sean más robustas para los datos de entrada imprevistos, porque la red está entrenada para predecir corretamente, incluso si algunas unidades están ausentes.

⚠️ El abandono solo participa en “Toque” 🤷🏻 ♂️ durante el entrenamiento.

Activación

o Camada de saída tenho 10 unidades, seguidas de una función de activación softmax. As 10 unidades corresponden a las 10 posibles etiquetas, clases o categorías.

La activación de softmax se puede expresar matemáticamente, de acuerdo con la siguiente ecuación:

1ui7n5s48-qnf7bbgfdpioq-7950293

model.add(Ativação('softmax'))
model.summary()
OUTPUT:
Modelo: "sequencial"
_________________________________________________________________
Camada (modelo)                 Parâmetros de forma de saída #   
=================================================================
dense (Denso)                (Nenhum, 256)               200960    
_________________________________________________________________
activation (Ativação)      (Nenhum, 256)               0         
_________________________________________________________________
dropout (Cair fora)            (Nenhum, 256)               0         
_________________________________________________________________
dense_1 (Denso)              (Nenhum, 256)               65792     
_________________________________________________________________
activation_1 (Ativação)    (Nenhum, 256)               0         
_________________________________________________________________
dropout_1 (Cair fora)          (Nenhum, 256)               0         
_________________________________________________________________
denso_2 (Denso)              (Nenhum, 10)                2570      
_________________________________________________________________
activation_2 (Ativação)    (Nenhum, 10)                0         
========================================================== ===============
Params totais: 269,322
Parâmetros treináveis: 269,322
Params não treináveis: 0
_________________________________________________________________

Visualización de modelos

Melhoria

El propósito de la Optimización es minimizar la función de pérdida. La idea es que si la pérdida se reduce a un nivel aceptable, el modelo aprendió indiretamente la función que asigna las entradas a las salidas. Las métricas de rendimiento se utilizan para determinar si su modelo ha aprendido.

model.compile(perda ="categorical_crossentropy", otimizador ="Adão", metrics =['accuracy'])
    • Categorical_crossentropy, se utiliza para one-hot
    • La precisión es una buena métrica para las tareas de clasificación.
    • Adam es un algoritmo de otimização que se pode utilizar em vez do procedimento clássico de descida de gradiente estocástico

📌 Dado o nosso conjunto de treino, a escolha do Função de perda, o otimizador e o regularizador, podemos começar a treinar o nosso modelo.

model.fit(x_train, y_train, epochs=20, batch_size = batch_size)
OUTPUT:
Época 1/20
469/469 [================================] - 1s 3ms/passo - perda: 0.4230 - precisão: 0.8690
....
Época 20/20
469/469 [================================] - 2s 4ms / passo - perda: 0.0515 - precisão: 0.9835

Avaliação

Neste ponto, o nosso modelo de classificador de dígitos MNIST está completo. A sua avaliação de desempenho será o próximo passo para determinar se o modelo treinado apresentará uma solução subótima

_, acc = model.evaluate(x_test,
                        y_test,
                        batch_size = batch_size,
                        verbose = 0)
imprimir("nAcurácia: %.1f%%n" % (100.0 * acc))
OUTPUT:
Precisão: 98.4%

continuará…

Assine a nossa newsletter

Nós não enviaremos SPAM para você. Nós odiamos isso tanto quanto você.

Datapeaker