Inteligência Artificial
Aula 14 – Redes Neurais
Edirlei Soares de Lima
<edirlei@iprj.uerj.br>
Formas de Aprendizado
•
Aprendizado Supervisionado
–
–
–
–
Árvores de Decisão.
K-Nearest Neighbor (KNN).
Support Vector Machines (SVM).
Redes Neurais.
•
•
Aprendizado Não Supervisionado
Aprendizado Por Reforço
Introdução
•
•
Redes Neurais podem ser consideradas um paradigma
diferente de computação.
Inspirado na arquitetura paralela do cérebro humano.
–
–
–
Elementos de processamento simples.
Grande grau de interconexões.
Interação adaptativa entre os
elementos.
Introdução
•
•
•
No cérebro, o comportamento inteligente é uma propriedade
emergente de um grande número de unidades simples (ao
contrário do que acontece com regras e algoritmos
simbólicos).
Neurônios ligam e desligam em alguns milissegundos,
enquanto o hardware atual faz o mesmo em nano segundos.
–
Entretanto, o cérebro realiza tarefas cognitivas complexas (visão,
reconhecimento de voz) em décimos de segundo.
O cérebro deve estar utilizando um paralelismo massivo.
Introdução
•
•
O cérebro humano tem sido
extensamente estudado, mas ainda
não somos capazes de entender
completamente o seu funcionando.
O cérebro é muito complexo, até
mesmo o comportamento de um
simples neurônio é bem complexo.
Neurônio
•
Estrutura de um Neurônio:
–
–
–
–
Corpo celular
Dendritos
Axônio
Terminais sinápticos
Funcionamento de um Neurônio
•
Através dos dentritos, o neurônio recebe sinais de outros
neurônios a ele conectados por meio das sinapses.
•
•
Os sinais são acumulados no corpo do neurônio.
Quando a soma dos sinais passa de um certo limiar (~ 50mV)
um sinal é propagado no axônio.
•
As sinapses tem um peso que pode ser:
–
excitatório: incrementam a soma dos sinais.
–
inibidor: decrementam.
Introdução
•
Características do Cérebro Humano:
11
–
–
–
–
–
10 neurônios.
Cada neurônio tem em media 104 conexões.
Milhares de operações por segundo.
Neurônios morrem frequentemente e nunca são substituídos.
Reconhecimento de faces em aproximadamente 0.1 segundos.
Introdução
•
•
O cérebro humano é bom em:
–
–
–
Reconhecer padrões,
Associação,
Tolerar ruídos...
O computador é bom em:
–
–
–
Cálculos,
Precisão,
Lógica.
Introdução
•
Formas mais básicas de aprendizado em
Redes Neurais:
–
–
Perceptron: Algoritmo para aprendizagem de redes
neurais simples (uma camada) desenvolvido nos anos 50.
Backpropagation: Algoritmo mais complexo para
aprendizagem de redes neurais de múltiplas camadas
desenvolvido nos anos 80.
Aprendizagem de Perceptron
•
Usa-se um conjunto de exemplos de treinamento que dão a
saída desejada para uma unidade, dado um conjunto de
entradas.
•
•
O objetivo é aprender pesos sinápticos de tal forma que a
unidade de saída produza a saída correta pra cada exemplo.
O algoritmo faz atualizações iterativamente até chegar aos
pesos corretos.
Perceptron
•
Unidade de Threshold Linear
W1
X1
W2
X2
.
.
.
n
n
1
if
wi xi 0
wi xi
i=0
i=0
Wn
−
1 otherwise
Xn
Rede de Perceptrons
Valores de Saída
Camada de Saída
Pesos Ajustaveis
Camada de Entrada
Sinais de entrada
Aprendizado de Perceptrons
•
Para que um perceptron possa aprender uma função deve-se
mudar o valor dos pesos ajustáveis por uma quantidade
proporcional a diferença entre a saída desejada e atual saída
do sistema.
Saída desejada: t
wi = wi + wi
x1
x2
...
...
xn
o
t
wi =(t −o)xi
x1
x2
xn
•
•
•
t = saída desejada.
o = atual saída do perceptron.
= Learning rate.
Aprendizado de Perceptrons
•
Regra de aprendizado:
wi = wi + wi
wi =(t −o)xi
•
•
Se a saída do perceptron não estiver correta (t != o):
– Os pesos wi são alterados de forma que a saída do perceptron para os novos pesos seja
próxima de t.
O algoritmo vai convergir para a correta classificação se:
–
O conjunto de treinamento é linearmente separável.
– é suficientemente pequeno.
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.3
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
-
0.1
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
1
0
1
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.3
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
-
0.1
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.3)+(0*-0.1) = 0
(0*0.3)+(1*-0.1) = -0.1
(1*0.3)+(0*-0.1) = 0.3
(1*0.3)+(1*-0.1) = 0.2
0
0
1
1
0
-1
0
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.2
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
-
0.1
wi = wi + wi
wi =(t −o)xi
A B
Somatório
Saída
Erro
0
0
0
1
1
0
1
0
1
(0*0.2)+(0*-0.1) = 0
(0*0.2)+(1*-0.1) = -0.1
(1*0.2)+(0*-0.1) = 0.2
(1*0.2)+(1*-0.1) = 0.1
0
0
1
0
0
-1
1
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.1
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
-
0.1
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.1)+(0*-0.1) = 0
(0*0.1)+(1*-0.1) = -0.1
(1*0.1)+(0*-0.1) = 0.1
(1*0.1)+(1*-0.1) = 0
0
0
0
0
0
0
1
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.2
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
0.0
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.2)+(0*-0.0) = 0
(0*0.2)+(1*-0.0) = 0
(1*0.2)+(0*-0.0) = 0.2
(1*0.2)+(1*-0.0) = 0.2
0
0
1
1
0
-1
0
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.1
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
0.0
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.1)+(0*0.0) = 0
(0*0.1)+(1*0.0) = 0
(1*0.1)+(0*0.0) = 0.1
(1*0.1)+(1*0.0) = 0.1
0
0
0
0
0
0
1
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.2
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
0.1
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.2)+(0*0.1) = 0
(0*0.2)+(1*0.1) = 0.1
(1*0.2)+(0*0.1) = 0.2
(1*0.2)+(1*0.1) = 0.3
0
0
1
1
0
-1
0
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.1
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
0.2
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.1)+(0*0.2) = 0
(0*0.1)+(1*0.2) = 0.2
(1*0.1)+(0*0.2) = 0.1
(1*0.1)+(1*0.2) = 0.3
0
1
0
1
-1
0
0
Treinando um Neurônio
Operador And
Threshold = 0.2
Learning Rate = 0.1
A B Saída
A
B
0
.1
0
0
1
1
0
1
0
1
0
0
0
1
T=0.2
0.1
wi = wi + wi
wi =(t −o)xi
A
0
0
1
1
B
Somatório
Saída
Erro
0
0
1
0
1
(0*0.1)+(0*0.1) = 0
(0*0.1)+(1*0.1) = 0.1
(1*0.1)+(0*0.1) = 0.1
(1*0.1)+(1*0.1) = 0.2
0
0
0
1
0
0
0
Limitações
•
•
Um único Perceptron consegue resolver
somente funções linearmente
separáveis.
Em funções não linearmente separáveis
o perceptron não consegue gerar um
hiperplano para separar os dados.
Redes Multicamadas
•
•
Perceptrons expressam somente superfícies de
decisão linear.
Entretanto, é possível combinar vários perceptrons
lineares para gerar superfícies de decisão mais
complexas.
•
Dessa forma podemos, por exemplo, gerar uma
superfícies de classificação para o operador XOR.
Operador XOR
Operador XOR
A B Saída
0
0
1
1
0
1
0
1
0
1
1
0
-
0.5
h1
OR
1
X1
1
1
o
1
1
-
0.5
-
1
X2
h2
AND
-1.5
Redes Multicamadas
Camada de Saída
Camadas Ocultas
Camada de Entrada
Redes Multicamadas
•
•
Adicionar uma camada oculta a
rede permite que a rede possa
gerar uma função de convex
hull.
Duas camadas ocultas permite a
rede gerar um função com
diferentes convex hulls.
Redes Multicamadas
•
Unidades lineares são capazes gerar funções
lineares, dessa forma função de uma rede
multicamada também será linear.
•
•
Entretanto, existem muitas funções que não podem
ser modeladas por funções lineares.
Por esse motivo é necessário utilizar uma outra
função de ativação.
Redes Multicamadas
•
Funções de ativação mais comuns:
–
Sigmoidal:
n
y = f h = w0 1+ wi xi ; p =
1
−h p
i=1
1+e
–
Radial (Gausiana):
h2
−2
2
n
1
2
y = f h = (xi wi ) ; = w0 =
e
2
i=1
Redes Multicamadas
•
Unidade Sigmoid
W1
X1
X2
W2
.
.
.
n
1
net = wi xi
o = (net) =
−h p
Wn
i=0
1+ e
Xn
Função Sigmoidal
1
−(neti (t)− )/
fi (neti (t)) = 1+ e
1
= 0.1
0
1
-1
Função Sigmoidal
1
−(neti (t)− )/
fi (neti (t)) = 1+ e
1
=1
0
1
-1
Backpropagation
•
•
Aprende os pesos para uma rede multicamadas,
dada uma rede com um número fixo de unidades e
interconexões.
O algoritmo backpropagation emprega a descida do
gradiente para minimizar o erro quadrático entre a
saída da rede e os valores alvos para estas saídas.
Descida do Gradiente
•
•
A descida do gradiente busca
determinar um vetor de pesos que
minimiza o erro.
Começando com um vetor inicial de
pesos arbitrário e modificando-o
repetidamente em pequenos passos.
•
A cada passo, o vetor de pesos é alterado na direção que produz
a maior queda ao longo da superfície de erro.
Backpropagation
•
•
Aprende os pesos para uma rede multicamadas, dada uma
rede com um número fixo de unidades e interconexões.
“O algoritmo backpropagation emprega a descida do gradiente
para minimizar o erro quadrático entre a saída da rede e os
valores alvos para estas saídas.
Valor de saida da rede
0.119 0.059 0.253 0.246
Valor da saida buscada
0
0
1
0
Erro (E) = (Valor da saida buscada) – (Valor de saida da rede)
Backpropagation
Backpropagation
Inicializa cada peso wi com um pequeno valor randômico.
Enquanto condição de parada não for atingida faça
{
Para cada exemplo de treinamento faça
{
Entre com os dados do exemplo na rede e calcule a saída da rede (ok)
Para cada unidade de saída k faça
{
k ok (1− ok )(tk − ok )
}
Para cada unidade oculta h faça
{
h oh (1−oh ) wh,kk
k outputs
}
Para cada peso wj da rede faça
{
wi, j wi, j + wi, j
where wi, j = j xi, j
}
}
}
Backpropagation
•
•
•
•
O backpropagation não é um algoritmo ótimo e não garante
sempre a melhor resposta.
O algoritmo de descida do gradiente pode ficar preso em um
erro mínimo local.
É possível refazer o treinamento variando os valores iniciais
dos pesos.
Backpropagation é o algoritmo de aprendizagem mais
comum, porém existem muitos outros.
Leitura Complementar
•
•
Mitchell, T. Machine Learning, McGraw–Hill
Science/Engineering/Math, 1997.
Duda, R., Hart, P., Stork, D., Pattern Classification,
John Wiley & Sons, 2000