5ª atividade - Reproduzir exemplo do Adaline

Aluno: Antônio Victor Gonçalves da Silva Disciplina: Redes Neurais

Introdução
Nesse trabalho foi utilizado a regra delta de Widrow para treinar um neuronio
ADALINE, a fim de encontrar uma função que represente bem os valores
fornecidos na tabela ao lado. O código foi dividido nas secções abaixo e
comentando. Além disso, foi plotado os hiperplanos que representam essa função
encontrada e a convergencia dos pesos w1 e w2.

Definindo funções utilizadas

def u(x, w, i): #saída do somador

soma = 0
for j in range(len_amostra):
soma += x[i][j]*w[j]
return soma

def erro(i, yd, y):

return yd[i] - y

def atualiza_peso(w, a, e, x, i): #atualiza os pesos w1 e w2

for j in range(len_amostra):
w[j]+=a*e*x[i][j]
return w

Declarando as variáveis

#entradas
x = [(0.2,0.3), (0.1,0.4), (0.4,0.3), (0.11,0.9), (0.84,0.6), (0.1,0.2), (0.6,0.2),(0.2,0.

#saídas desejadas
yd = [0.13, 0.17, 0.25, 0.822, 1.065, 0.05, 0.4, 0.08, 1.13, 0.01]

#pesos
w = [8.44, 8.28]

#taxa de aprendizagem
a = 1

#quantidade de amostras
len_amostras = len(x)

#tamanho de cada amostra

len_amostra = len(x[0])

#vetor de erros
e = [0,0,0,0,0,0,0,0,0,0]
Verificação dos dados

#10 interações,como pedido na questão

for i in range(len_amostras):

saida = u(x,w,i)
e[i] = erro(i, yd, saida)
w = atualiza_peso(w, a, e[i], x, i)
print(f'{i + 1}ª iteração:\n')
print(f'y = {round(saida,3)} w0 = {round(w[0],3)} w1 = {round(w[1],3)}\n')

#A função round arredonda o número

1ª iteração:

y = 4.172 w0 = 7.632 w1 = 7.067

2ª iteração:

y = 3.59 w0 = 7.29 w1 = 5.699

3ª iteração:

y = 4.626 w0 = 5.539 w1 = 4.387

4ª iteração:

y = 4.557 w0 = 5.128 w1 = 1.025

5ª iteração:

y = 4.923 w0 = 1.888 w1 = -1.29

6ª iteração:

y = -0.069 w0 = 1.9 w1 = -1.266

7ª iteração:

y = 0.887 w0 = 1.608 w1 = -1.363

8ª iteração:

y = 0.049 w0 = 1.614 w1 = -1.357

9ª iteração:

y = 0.044 w0 = 2.374 w1 = -0.488

10ª iteração:

y = 0.237 w0 = 2.351 w1 = -0.488

Hiperplano inicial

#Importando bibliotecas necessárias para a plotagem

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D
import numpy as np

#Hiperplano com os valores inicias

x = np.linspace(-2,2,10)
y = np.linspace(-2,2,10)

x,y = np.meshgrid(x,y)

z = 8.44*x + 8.28*y

fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_surface(x,y,z)
plt.show()

Figura 1: Hiperplano plotado com os valores inciais

Processo de aprendizagem

a = 0.3 #mudando a taxa de aprendizagem

w_0 = []
w_1 = []
es = []
eq = [] #erro quadrático
for n in range(50):

for i in range(len_amostras):

saida = u(x,w,i)
e[i] = erro(i, yd, saida)
w = atualiza_peso(w, a, e[i], x, i)
w_0.append(w[0])
w_1.append(w[1])
es.append(e[i]**2)
eq.append(sum(es)/20)

print(f'y = {saida} w0 = {w[0]} w1 = {w[1]}\n')

y = 0.05481921873524153 w0 = 0.546847610790358 w1 = 0.816775464408366

Hiperplano final

x = np.linspace(-2,2,10)
y = np.linspace(-2,2,10)

x,y = np.meshgrid(x,y)

z = 0.546847610790358*x + 0.816775464408366*y

fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_surface(x,y,z)
plt.show()
 Figura 2: Hiperplano plotado com os valores finais

Gráfico de convergência dos pesos sinápticos

x = np.linspace(0,500,500)

plt.plot(x,w_0)
plt.plot(x, w_1, 'r')
plt.show()

Figura 3: Gráfico de convergência dos pesos

x = np.linspace(-10,10,20)
y = np.linspace(-10,10,20)
x,y = np.meshgrid(x,y)

entradas = [(0.2,0.3), (0.1,0.4), (0.4,0.3), (0.11,0.9), (0.84,0.6), (0.1,0.2), (0.6,0.2),

saidas = [0.13, 0.17, 0.25, 0.822, 1.065, 0.05, 0.4, 0.08, 1.13, 0.01]
erros = [0,0,0,0,0,0,0,0,0,0]
erro_quadratico = np.empty([20, 20])

for i in range(20):

for j in range(20):

w1 = x[i][j]
w2 = y[i][j]

for n in range(10):
soma = entradas[n][0] * w1 + entradas[n][1] * w2
erros[n] = soma - saidas[n]
e_2 = []

for k in range(len(erros)):
e_2.append(erros[k]**2)

w1 = w1 + erros[n] * entradas[n][0] * 0.3

w1 = w1 + erros[n] * entradas[n][1] * 0.3

erro_quadratico[i][j] = (sum(e_2)/20)

fig = plt.figure()
ax = fig.gca(projection='3d')
ax.plot_surface(x,y,erro_quadratico)
plt.show()

Figura 4: Hiperplano do erro

Conclusão
Observando os valores da secção “Verificação dos dados”, é possivel notar que os
valores obtidos para os pesos nas dez primeiras interações ficaram de acordo com a
tabela. Pela figura 3, temos que os valores dos pesos convergiram, portanto atingimos
o valor mínimo da função do erro, pela figura 4 constatamos que é um valor mínimo
global. Sendo assim, o hiperplano final representa uma função muito proxima da ideal,
que cumpre os valores fornecidos na tabela mostrada na indutrução.