Visão geral da implementação de redes neurais
As redes neurais artificiais são inspiradas em redes neurais biológicas. As redes neurais ajudam a resolver os problemas sem serem programadas com as regras e condições específicas do problema. São modelos genéricos com a maioria dos cálculos matemáticos complexos como BlackBox. Os diferentes tipos de redes neurais são como Rede Neural de Convolução, Rede Neural Recorrente, Rede Neural Feedforward, perceptron multicamada e muitos outros. Neste tópico, estamos ansiosos para aprender sobre a implementação de redes neurais.
A arquitetura das redes neurais
Existem 3 camadas principalmente em redes neurais.
- Camada de entrada
- Camadas ocultas
- Camada de saída
1. Camada de entrada: a camada de entrada contém os neurônios para a entrada de recursos. Há também um viés adicionado à camada de entrada, além dos recursos. Portanto, se houver n recursos, a camada de entrada contém n + 1 neurônios.
2. Camada oculta: as camadas ocultas são as camadas intermediárias entre as camadas de entrada e saída. Pode haver qualquer número de camadas ocultas. A rede com mais de uma camada oculta é chamada de redes neurais profundas. Os neurônios na camada oculta recebem entrada da camada de entrada e fornecem saída para a camada de saída.
3. Camada de Saída: A camada de saída contém o número de neurônios com base no número de classes de saída. Se for um problema de classificação de várias classes, ele contém o número de neurônios igual ao número de classes. Para classificação binária, contém um neurônio.
As entradas são multiplicadas por pesos e depois alimentadas na próxima camada oculta. A polarização também é fornecida como entrada, juntamente com as entradas ponderadas. A soma ponderada é passada por uma função não linear chamada função de ativação.
Exemplo de Implementação
Aqui está o exemplo de implementação mencionado abaixo
Instalação de bibliotecas
Existem muitas bibliotecas internas para a implementação de redes neurais artificiais em diferentes linguagens de programação. Aqui falaremos sobre duas das famosas bibliotecas tensorflow e Keras usando python como a linguagem de programação para a implementação de redes neurais. O Keras é uma API de nível superior criada no tensorflow ou theano como back-end. É muito mais fácil para implementação. Você pode escolher qualquer uma das bibliotecas para o seu modelo. Existem alguns outros também disponíveis, como PyTorch, theano, Caffe e muitos mais.
Para instalar o tensorflow / Keras usando pip, execute o seguinte comando:
pip install tensorflow
pip install Keras
Como alternativa, ele pode ser instalado usando o comando conda,
conda install -c conda-forge tensorflow
conda install -c conda-forge keras
Implementação
Aqui falaremos sobre Keras para a geração de modelos de aprendizado profundo. É uma biblioteca de aprendizado profundo Python de código aberto.
- Importe o conjunto de dados MNIST disponível. MNIST é o conjunto de dados de números manuscritos de dígitos em inglês.
from tensorflow.examples.tutorials.mnist import input_data
train_images = mnist.train.images.reshape(mnist.train.images.shape(0), image_rows, image_cols, 1)
test_images = mnist.test.images.reshape(mnist.test.images.shape(0), image_rows, image_cols, 1)
- Inicialize os parâmetros e hiperparâmetros necessários para o modelo.
- Em seguida, inicialize o modelo de aprendizado profundo.
model = Sequential()
- Adicione camada de convolução, camada de ativação e camada de pool máximo para cada camada de convolução que estamos adicionando entre a camada de entrada e saída (camadas ocultas). Aqui estamos adicionando duas camadas de convolução.
model.add(Convolution2D(num_filters, conv_kernel_size(0), conv_kernel_size(1), border_mode='valid', input_shape=imag_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=max_pool_size))
- Função de ativação diferente pode ser usada conforme o problema. Algumas funções comuns de ativação são a ativação relu, a ativação com vazamento tanh relu e muitas outras.
- Em seguida, vem uma camada totalmente conectada antes da camada densa. Eles compilam os dados extraídos pelas camadas anteriores para formar a saída final.
- A dimensão da camada de saída depende do número de classes. As funções de ativação usadas para a camada de saída são geralmente ativação sigmóide para classificação binária e ativação softmax para classificação multi-classe.
model.add(Dense(num_classes))
model.add(Activation('softmax'))
O código completo para a rede neural convolucional profunda para a classificação dos dados MNIST é como abaixo.
from tensorflow.examples.tutorials.mnist import input_data
from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D
# we use TF helper function to pull down the data from the MNIST site mnist_data = input_data.read_data_sets("MNIST_data/", one_hot=True)
img_rows = 28
img_cols = 28
# Reshape training and test images to 28x28x1
train_images = mnist_data.train.images.reshape(mnist_data.train.images.shape(0), img_rows, img_cols, 1)
test_images = mnist_data.test.images.reshape(mnist_data.test.images.shape(0), img_rows, img_cols, 1)
num_of_filters = 32 # No. of conv filters maxPoolSize = (2, 2) # shape of max_pool convKrnSize = (3, 3) # conv kernel shape imgShape = (28, 28, 1) num_of_classes = 10
dropProb = 0.5
model = Sequential()
# define layers in NN
# Define 1st convolution layer.
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1), border_mode='valid', input_shape=imgShape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
# 2nd Convolution Layer
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1))) model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
#Fully Connected Layer model.add(Flatten())
model.add(Dense(128)) #Fully connected layer in Keras model.add(Activation('relu'))
# Dropout some neurons to reduce overfitting model.add(Dropout(dropProb))
#Readout Layer model.add(Dense(num_of_classes))
model.add(Activation('softmax'))
# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=('accuracy'))
# Training settings batch_size = 128
num_of_epoch = 2
# fit the training data to the model.
model.fit(train_images, mnist_data.train.labels, batch_size=batch_size,
nb_epoch=num_of_epoch, verbose=1, validation_data=(test_images, mnist_data.test.labels))
# predict the test_data using the model
test_labels_predicted = model.predict_classes(test_images)
# To get the predicted labels of all test images for i in range(len(test_images)):
print ("Image () -> Label ()".format(i+1, test_labels_predicted(0)))
Treinamento
O treinamento do modelo é semelhante,
Conclusão - Implementação de redes neurais
As redes neurais fornecem uma maneira fácil para problemas de classificação ou regressão no aprendizado de máquina quando o espaço de recursos das amostras é muito grande, principalmente para imagens grandes ou outros sinais ou multimídia.
Artigos recomendados
Este é um guia para a implementação de redes neurais. Aqui discutimos a arquitetura e implementação de redes neurais com um modelo de treinamento e código de exemplo. Você também pode consultar o seguinte artigo para saber mais -
- Classificação da Rede Neural
- O que são redes neurais?
- Redes neurais convolucionais
- Algoritmos de redes neurais
- Gráficos 2D em Java