IA com Python - Redes Neurais

As redes neurais são dispositivos de computação paralela que são uma tentativa de fazer um modelo computacional do cérebro. O objetivo principal é desenvolver um sistema para realizar várias tarefas computacionais mais rapidamente do que os sistemas tradicionais. Essas tarefas incluem Reconhecimento e Classificação de Padrões, Aproximação, Otimização e Clustering de Dados.

O que são Redes Neurais Artificiais (RNA)

A rede neural artificial (RNA) é um sistema de computação eficiente cujo tema central é emprestado da analogia das redes neurais biológicas. As RNAs também são chamadas de Sistemas Neurais Artificiais, Sistemas de Processamento Distribuído Paralelo e Sistemas Conexionistas. A RNA adquire uma grande coleção de unidades que estão interconectadas em algum padrão para permitir a comunicação entre elas. Essas unidades, também chamadas denodes ou neurons, são processadores simples que operam em paralelo.

Cada neurônio está conectado com outro neurônio por meio de um connection link. Cada link de conexão está associado a um peso contendo as informações sobre o sinal de entrada. Esta é a informação mais útil para os neurônios resolverem um problema específico porque oweightgeralmente excita ou inibe o sinal que está sendo comunicado. Cada neurônio está tendo seu estado interno que é chamadoactivation signal. Os sinais de saída, que são produzidos após combinar os sinais de entrada e a regra de ativação, podem ser enviados para outras unidades.

Se você deseja estudar redes neurais em detalhes, siga o link - Rede Neural Artificial .

Instalando Pacotes Úteis

Para criar redes neurais em Python, podemos usar um pacote poderoso para redes neurais chamado NeuroLab. É uma biblioteca de algoritmos básicos de redes neurais com configurações de rede flexíveis e algoritmos de aprendizagem para Python. Você pode instalar este pacote com a ajuda do seguinte comando no prompt de comando -

pip install NeuroLab

Se você estiver usando o ambiente Anaconda, use o seguinte comando para instalar o NeuroLab -

conda install -c labfabulous neurolab

Construindo Redes Neurais

Nesta seção, vamos construir algumas redes neurais em Python usando o pacote NeuroLab.

Classificador baseado em Perceptron

Perceptrons são os blocos de construção da ANN. Se você quiser saber mais sobre o Perceptron, pode seguir o link - artificial_neural_network

A seguir está uma execução passo a passo do código Python para construir um classificador baseado em perceptron de rede neural simples -

Importe os pacotes necessários conforme mostrado -

import matplotlib.pyplot as plt
import neurolab as nl

Insira os valores de entrada. Observe que é um exemplo de aprendizagem supervisionada, portanto, você também terá que fornecer valores-alvo.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Crie a rede com 2 entradas e 1 neurônio -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Agora, treine a rede. Aqui, estamos usando a regra Delta para treinamento.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Agora, visualize a saída e plote o gráfico -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

Você pode ver o gráfico a seguir mostrando o progresso do treinamento usando a métrica de erro -

Redes Neurais de Camada Única

Neste exemplo, estamos criando uma rede neural de camada única que consiste em neurônios independentes que atuam nos dados de entrada para produzir a saída. Observe que estamos usando o arquivo de texto chamadoneural_simple.txt como nossa entrada.

Importe os pacotes úteis como mostrado -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Carregue o conjunto de dados da seguinte forma -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

A seguir estão os dados que vamos usar. Observe que, nesses dados, as duas primeiras colunas são os recursos e as duas últimas colunas são os rótulos.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Agora, separe essas quatro colunas em 2 colunas de dados e 2 rótulos -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Plote os dados de entrada usando os seguintes comandos -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Agora, defina os valores mínimo e máximo para cada dimensão, conforme mostrado aqui -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Em seguida, defina o número de neurônios na camada de saída da seguinte forma -

nn_output_layer = labels.shape[1]

Agora, defina uma rede neural de camada única -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Treine a rede neural com número de épocas e taxa de aprendizagem, conforme mostrado -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Agora, visualize e plote o progresso do treinamento usando os seguintes comandos -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Agora, use os pontos de dados de teste no classificador acima -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Você pode encontrar os resultados do teste conforme mostrado aqui -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Você pode ver os seguintes gráficos como a saída do código discutido até agora -

Redes Neurais Multi-Camadas

Neste exemplo, estamos criando uma rede neural multicamadas que consiste em mais de uma camada para extrair os padrões subjacentes nos dados de treinamento. Essa rede neural multicamadas funcionará como um regressor. Vamos gerar alguns pontos de dados com base na equação: y = 2x 2 +8.

Importe os pacotes necessários conforme mostrado -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Gere alguns pontos de dados com base na equação mencionada acima -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Agora, remodele este conjunto de dados da seguinte maneira -

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Visualize e plote o conjunto de dados de entrada usando os seguintes comandos -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Agora, construa a rede neural com duas camadas ocultas com neurolab com ten neurônios na primeira camada oculta, six na segunda camada oculta e one na camada de saída.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Agora use o algoritmo de treinamento de gradiente -

neural_net.trainf = nl.train.train_gd

Agora treine a rede com o objetivo de aprender sobre os dados gerados acima -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Agora, execute as redes neurais nos pontos de dados de treinamento -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Agora plote e tarefa de visualização -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Agora estaremos traçando a saída real versus a prevista -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

Como resultado dos comandos acima, você pode observar os gráficos conforme mostrado abaixo -