Rede Neural Perceptron Adaline
Como criar uma rede neural do zero e aprender os conceitos importantes
A rede Adaline (Adaptive Linear Element) proposta por Widrow e Hoff (1960) tem a mesma estrutura do Perceptron, diferenciando apenas no algoritmo de treinamento.
Características da Adaline
* Rede adaptativa
* Inclusão de um algoritmo pioneiro para treinamento de redes de múltiplas camadas, o algoritmo de treinamento da Regra Delta
* O algoritmo da Regra Delta é baseado no método dos mínimos quadrados.
* Método de aprendizado mais suave
A figura acima ilustra uma rede Adaline com n sinais de entrada (x1…xn) e uma única saída (y). Na Adaline é proposto a inclusão de um bloco de sinal de erro com o intuito de modificar os valores dos pesos antes de se submeter a função de ativação (g). Note também que ilustra apenas um único neurônio.
De modo semelhante ao Perceptron o processamento se dá pelas seguinte expressões:
Onde xi são os sinais de entrada, wi são os pesos sinápticos associados, θ é o bias (limiar de ativação), g(.) é a função de ativação (degrau ou degrau bipolar) e u é o potencial de ativação. O bloco associador demonstrado no diagrama acima tem uma função auxiliar no processo de treinamento da rede.
erro = d-u
Erro é igual ao valor esperado menos o valor do potencial de ativação produzido pela rede.
Regra Delta
O algoritmo de treinamento do Adaline é baseado no método dos mínimos quadrados, conhecido como Regra Delta.
Devido a incapacidade do algoritmo de treinamento do Perceptron em gerar pesos que classifiquem dados não linearmente separáveis, Widrow e Hoff projetaram a regra Delta em 1960.
O algoritmo utiliza o método do gradiente descendente com a intenção de diminuir o valor da função de erro possibilitando assim a convergência para um mínimo da função de erro
- Objetivo: Realizar iterações locais para obter o ponto mínimo da função de erro e, assim, fixar os valores dos pesos quando o mínimo foi encontrado
- Funcionamento: Através de um ponto arbitrário (vetor de pesos iniciado aleatoriamente), o algoritmo percorre, a cada iteração a superfície da função de erro em direção ao ponto de mínimo.
Então, temos:
Dessa forma o processo de treinamento da rede Adaline procura mover continuamente o vetor de pesos buscando minimizar o erro quadrático em relação as amostras de dados disponíveis para aprendizado.
A fim de ilustrar o processo visando o alcance da fronteira da separabilidade entre classes apresentamos abaixo duas situações que mostram sua convergência rumo a estabilização considerando apenas duas entradas {x1 e x2}
No Perceptron o hiperplano de separação das classes pode ter “infinitas disposições” pois a configuração final vetor de pesos (w) é dependente dos valores iniciais aleatoriamente atribuídos.
Na Adaline, a inclinação do hiperplano é ajustada por intermédio do método dos mínimos erros quadrados (LMS — least mean square), ou seja, independentemente dos valores inicialmente atribuídos ao vetor de pesos ocorrerá a busca pelo ótimo.
Construindo uma Rede Adaline
Um exemplo de rede Adaline para separar duas classes de flores Iris (Setosa e Versicolor) os dados para treinamento consistem em apenas 5 colunas (comprimento da pétala, largura da pétala, comprimento da sépala e largura da sépala, a última coluna é a classe da flor) e 35 amostras (linhas).
import matplotlib.pyplot as plt #Para visualizacao dos dados e do erro
import numpy as np #Biblioteca de manipulacao de arrays Numpy
from matplotlib.colors import ListedColormap #Lista de cores para plotagens
import pandas as pd
### Carregar iris dataset
df = pd.read_csv('iris.csv')
df.head()
print(df)
X = df.iloc[0:100,[0,1,2,3]].values
y = df.iloc[0:100,4].values
#print(X)
#print("Y:", y)
### Assumindo que Setosa(0) seja -1 e Versicolor = 1
### Plotar o grafico
### vermelhos ----> Classe2 (-1)
### azuis ----> Classe1 (1)
cm_bright = ListedColormap(['#FF0000', '#0000FF'])
plt.figure(figsize=(7,5))
plt.scatter(X[:,0], X[:,1], c=y.ravel(), cmap=cm_bright)
plt.scatter(None, None, color = 'r', label='Setosa')
plt.scatter(None, None, color = 'b', label='Versicolor')
plt.legend()
plt.title('Visualizacao do Dataset')
plt.show()
###Construindo Adaline
class Adaline(object):
def __init__(self, eta = 0.001, epoch = 100):
self.eta = eta
self.epoch = epoch
def fit(self, X, y):
np.random.seed(16)
self.weight_ = np.random.uniform(-1, 1, X.shape[1] + 1)
self.error_ = []
cost = 0
for _ in range(self.epoch):
output = self.activation_function(X)
error = y - output
self.weight_[0] += self.eta * sum(error)
self.weight_[1:] += self.eta * X.T.dot(error)
cost = 1./2 * sum((error**2))
self.error_.append(cost)
return self
def net_input(self, X):
"""Calculo da entrada z"""
return np.dot(X, self.weight_[1:]) + self.weight_[0]
def activation_function(self, X):
"""Calculo da saida da funcao g(z)"""
return self.net_input(X)
def predict(self, X):
"""Retornar valores binaros 0 ou 1"""
return np.where(self.activation_function(X) >= 0.0, 1, -1)
###Plotando erros apos 100 epocas
names = ['Taxa de Aprendizado = 0.001', 'Taxa de Aprendizado = 0.0001']
classifiers = [Adaline(), Adaline(eta = 0.0001)]
step = 1
plt.figure(figsize=(14,5))
for name, classifier in zip(names, classifiers):
ax = plt.subplot(1, 2, step)
clf = classifier.fit(X, y)
ax.plot(range(len(clf.error_)), clf.error_)
ax.set_ylabel('Error')
ax.set_xlabel('Epoch')
ax.set_title(name)
step += 1
plt.show()
### Plotando as fronteiras de decisao com Adaline
clf = Adaline(eta = 0.0001)
clf.fit(X, y)
A = [6.1,3.0,4.6,1.4] # Classe 1
B = [4.8,3.0,1.4,0.1] #Classe -1
print (clf.predict(A))
print (clf.predict(B))
Ao plotarmos os dados no plano podemos ver as classes bem distantes, o que o caracteriza como um problema linearmente separável. O gráfico do erro/época está considerando uma taxa de aprendizado 0.001, o erro é então diminuído a cada época até que encontre o mínimo da função. Por fim, a separação realizada pelo Adaline, que segundo o treinamento realizado é a melhor separação (erro mínimo).
Procurei deixar bem ilustrativo, imprimindo gráficos com o hiperplano de separação das classes.
Enfim, espero que seja útil para aprender alguns conceitos importantes na construção de suas próprias redes.
(Revisado em Fev/24)
