onde:$$ y(x) : saida da função (pode ser +1 ou -1). sign: sinal + ou - x: vetor de entrada. i: indice da caracteristica max_int: número maximo de interações w: peso a ser achado. b: limite a ser achado (inclinação da reta)
$$¶
$$ Algoritmo: PREPARO 1.Inicializar pesos(w), bias(b) e taxa de aprendizado. w=0 b=0 0< alfa <=1 . TREINAMENTO 2.Enquanto ondição = falsa faça: Para cada par (S:T) faça .Ativar unidades de entrada x_i = s_i 3.Apresentar nova entrada que vai se somar a saida desejada. 4.Calcular saida atual, usando formula acima. y= 1 se y_in >teta 0 se -teta <= y_in <= teta -1 se y_in < teta 4.Atualizar o peso. Esta atualização é feita da seguinte forma: w_i (t+1)= w_i(t) + n[(d(t) - Y(t)]x_1(t) 5.Atualizar pesos e bias se um erro ocorreu para esta padrão Se y dif t w_i(novo)=w_i(velho) + taxa aprendizado *t * x_i b(novo) = b(velho) + taxa aprendizado * t senão w_i(n0v0) = W_i(velho) b(novo) = b(velho) 6. Se os pesos modificaram então acerto = falso senão acerto=verdadeiro Obs: . Quanto mais padrões de teinamento produzirem respostas corretas menor será o treinamento. . O threshold não sofre variações #$$In [3]:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# aplicativo para verificar se o ser vivo eh quadrupede ou bipede
# quadrupede = 1, bipede = -1
# cao = [-1,-1,1,1] | resposta = 1
# gato = [1,1,1,1] | resposta = 1
# cavalo = [1,1,-1,1] | resposta = 1
# homem = [-1,-1,-1,1] | resposta = -1
# pesos (sinapses- sinais transmitidos de uma célula para outra)
w = [0,0,0,0]
# entradas das caracteristicas por animal (vetor de treinamento)
x = [[-1,-1,1,1],
[1,1,1,1],
[1,1,-1,1],
[-1,-1,-1,1]]
# respostas esperadas (hipótese)
t = [1,1,1,-1]
# bias (ajuste fino) inclinação da reta
b = 0
#saida
y = 0
# numero maximo de ciclos
c = 10
# velocidade de aprendizagem
taxa_aprendizado = 1
#soma resultado do samatorio
soma = 0
#theshold
threshold = 1
# nome do animal
animal = ""
# resposta = acerto ou falha
resposta = ""
# dicionario de dados
d = {'-1,-1,1,1' : 'cao',
'1,1,1,1' : 'gato',
'1,1,-1,1' : 'cavalo',
'-1,-1,-1,1' : 'homem' }
# funcao para converter listas em strings
def listToString(list):
s = str(list).strip('[]')
s = s.replace(' ', '')
return s
# Resulatado do preparo
print("Resultado do preparo")
print("entrada do preparo - x=",x)
print("saida do preparo - d=",d)
print("")
print("Inicialização dos parâmetros:")
print("Pesos: w=",w)
print("Bias: b=",b)
print("Taxa de aprendizado: taxa_aprendizado=",taxa_aprendizado)
print("Número maximo de ciclos: c=",c)
print("hreshold: threshold=",threshold)
print("hipótese: t=",t)
print("")
print("Inicialização das variaveis intermediárias:")
print("acumula as somas: soma=",soma)
print("")
print("Inicialização das saidas:")
print("atingiu alvo: y=",y)
In [4]:
# inicio do algoritmo
for k in range(1,c):
acertos = 0
print("INTERACAO "+str(k)+"-------------------------")
for i in range(0,len(x)):
soma = 0
# pega o nome do animal no dicionário
if listToString(x[i]) in d:
#if d.has_key(listToString(x[i])):
animal = d[listToString(x[i])]
else:
animal = ""
# para calcular a saida do perceptron, cada entrada de x eh multiplicada
# pelo seu peso w correspondente
for j in range(0,len(x[i])):
soma += x[i][j] * w[j]
# a saida eh igual a adicao do bias com a soma anterior
y_in = b + soma
print("b=",b,"w=",w,"y=",y,"k=",k,"j=",j,"c=",c,"y_in=",y_in)
# funcao de saida eh determinada pelo threshold
if y_in > threshold:
y = 1
elif y_in >= -threshold and y_in <= threshold:
y = 0
else:
y = -1
# atualiza os pesos caso a saida nao corresponda ao valor esperado
if y == t[i]:
acertos+=1
resposta = "acerto"
else:
for j in range (0,len(w)):
w[j] = w[j] + (taxa_aprendizado * t[i] * x[i][j])
b = b + taxa_aprendizado * t[i]
resposta = "Falha - Peso atualizado"
print("w",w)
#imprime a resposta
if y == 1:
print(animal+" = quadrupede = "+resposta)
elif y == 0:
print(animal+" = padrao nao identificado = "+resposta)
elif y == -1:
print(animal+" = bipede = "+resposta)
if acertos == len(x):
print("--------------------------------------------------------------------------------------")
print("Funcionalidade aprendida com "+str(k)+" interacoes")
break;
print("")
print("Finalizado")
In [5]:
if acertos == len(x):
print("------------------------------Resultado do algoritmo----------------------------------")
print("Entrada:","x=",x)
print("Caracteristicas por ser vivo:")
print(d)
print("")
print("Parâmetros passados:")
print("Resultado esperado(t)=",t,"threshold=",threshold,"num max de ciclos=",c)
print("")
print("Calculado pelo algoritimo (útima interação)")
print("Peso w=",w,"Inclinação da reta b=",b)
print("")
print("Saida:")
print("útima interação: ","atingiu alvo y=",y,"animal=",animal,"resposta=",resposta,"threshold=",threshold)
print("")
print("Funcionalidade aprendida com "+str(k)+" interacões")
print("")
print("------------------------------ Finalizado ----------------------------------")
 |
 |
|
| Dados Classificados(Visualização da Saida) | Dados não classificados(Visualização da Entrada) |
| legenda: 0 - bípede x -quadrúpide |
mostrar as classes separadas por uma reta usando regressão linear
In [7]:
# import pylab as pl
from matplotlib import pylab as pl
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as md
import scipy.stats as ss
import scipy.signal as signal
import os
import codecs
import time
import datetime
#from numpy import loadtxt, genfromtxt, array, arange, subtract, linspace, concatenate, zeros_like, mean
#from matplotlib.pyplot import plot, scatter, boxplot, semilogx, semilogy, loglog, show, title, legend, figure
#from scipy import polyval, polyfit, sqrt, stats, randn
#from scipy.stats import linregress, describe, gaussian_kde, cumfreq
#from scipy.signal import gaussian, convolve, correlate
#from pylab import hist, movavg, datestr2num
# We'll also import seaborn, a Python graphing library
import warnings # current version of seaborn generates a bunch of warnings that we'll ignore
warnings.filterwarnings("ignore")
#import seaborn as sns
#import seaborn.apionly as sns
#sns.set(style="white", color_codes=True)
%matplotlib inline
#pylab.rcParams['figure.figsize'] = (8.0, 6.4)
In [38]:
#caminhos para arquivos
datapath = "/Users/walterdominguez/Documents/HOMEOffice/INTERNO/GESTÃO CONHECIMENTO/CURSOS/CURSOS 2016/ApredizadoMaquina/TrabalhoFinal/datasets/"
outputs = "/Users/walterdominguez/Documents/HOMEOffice/INTERNO/GESTÃO CONHECIMENTO/CURSOS/CURSOS 2016/ApredizadoMaquina/TrabalhoFinal/datasets/outputs/"
In [51]:
dataset8 = "servivo.csv"
In [63]:
servivo_b = np.genfromtxt(os.path.join(datapath,dataset8), usecols=(0,4), delimiter=',')
servivo_q = np.genfromtxt(os.path.join(datapath,dataset8), usecols=(0,8), delimiter=',', skip_header=69)
In [64]:
t1 = np.linspace(1897,2014,len(servivo_b[:,0]))
t2 = np.linspace(1960,2014,len(servivo_q[:,0]))
In [69]:
s_b = pd.Series(servivo_b[:,1], index=servivo_b[:,0], name='Bípede')
s_q = pd.Series(servivo_q[:,1], index=servivo_q[:,0])
df_b_q = pd.concat([s_b,s_q], axis=1, keys=['Bípede','Quadrúpede'])
df_b_q.tail()
Out[69]:
In [70]:
plt.figure(figsize=(14,10))
plt.scatter(servivo_b[:,0], servivo_b[:,1], c='b', marker='+')
plt.scatter(servivo_q[:,0], servivo_q[:,1], c='r', marker='.')
plt.title('Seres vivos não classificados')
plt.legend(['Bípede','Quadrúpide'])
plt.show()
In [71]:
(a,b) = pl.polyfit(t1,servivo_b[:,1],1)
xm_linear = pl.polyval([a,b],t1)
(a,b) = pl.polyfit(t2,servivo_q[:,1],1)
xf_linear = pl.polyval([a,b],t2)
In [72]:
plt.figure(figsize=(14,10))
plt.title('Classificação de seres vivos em bípede e quadrúpede')
plt.scatter(t1, servivo_b[:,1], c='b', marker='o')
plt.scatter(t2, servivo_q[:,1], c='g', marker='*')
plt.plot(t1, xm_linear,'b.-')
plt.plot(t2, xf_linear,'r.-')
plt.legend(['Linear Reg B','Linear Reg Q','Bípedes','Quadrúpede'], loc=0)
plt.show()
In [ ]:
In [ ]: