Instituto de Fı́sica “Gleb Wataghin” - IFGW

Universidade Estadual de Campinas - UNICAMP

Campinas (São Paulo)

Aplicação do Mathematica no desenvolvimento de

redes neurais

Rickson Coelho Mesquita

Professor: Alberto Saa

 1

Sumário
1 Introdução 2

2 Perceptron para duas classes de padrões 4

3 Algoritmos de treinamento 6
3.1 Treinamento para classes linearmente separáveis . . . . . . . . . . . . . . . 7
3.2 Classes não separáveis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

4 Resultados obtidos 10
4.1 Problema 1: exemplo de uma classe separável . . . . . . . . . . . . . . . . 10
4.2 Problema 2: Treinamento de uma rede neural para implementação da porta
lógica AND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.3 Problema 3: Implementação da função 2cos(πk/8) a partir de sen(πk/8) . 13

5 Conclusões 17
 2

1 Introdução
De forma básica e direta, uma rede neural é um paradigma computacional inspirado
no paralelismo do cérebro, com o objetivo de permitir que máquinas computacionais
usem e imitem a lógica funcional desenvolvida facilmente por seres humanos através da
unidade principal do sistema nervoso, os neurônios. Isso é possı́vel através da utilização
de elementos de computação não-linear (chamados neurônios) organizados em redes, de
maneira análoga à que se acredita que as células nervosas estejam interconectadas no
cérebro. Essas redes são utilizadas como base para o desenvolvimento adaptativo dos
coeficientes das funções de decisão através de apresentações sucessivas de conjuntos de
padrões de treinamento.
O interesse em redes neurais data do inı́cio da década de 1940, através dos trabalhos de
McCulloch e Pitts [1]. Juntos, eles propuseram um modelo que explica o funcionamento de
neurônios como dispositivos de limiarização binária e algoritmos estocásticos envolvendo
mudanças repentinas de 0-1 e 1-0 em seus estados. O trabalho subseqüente de Hebb
baseou-se em modelos matemáticos que tentavam capturar o conceito de aprendizado por
reforço ou associação, de forma que o aprendizado em sistema nervosos complexos poderia
ser reduzido a um processo puramente local, em que a intensidade das conexões sinápticas
é alterada apenas em função dos erros detectáveis localmente [2].
No final da década de 1950, Rosenblatt deu prosseguimento às idéias de McCulloch.
Empregando o princı́pio de aprendizado de Hebb, ele criou uma genuı́na rede de múltiplos
neurônios chamada de perceptron [3, 4]. A razão para o grande interesse nessa rede foi o
desenvolvimento de provas matemáticas, mostrando que os perceptrons, quando treinados
com conjuntos de treinamento linearmente separáveis, convergiriam para uma solução em
um número finito de passos iterativos. A solução tomaria a forma de coeficientes de
hiperplanos capazes de separar corretamente as classes representadas pelos padrões no
conjunto de treinamento.
Mas as expectativas que seguiram a descoberta do que parecia ser um modelo teórico
 3

bem fundamentado de aprendizado foram logo frustradas. O perceptron básico e algumas

de suas generalizações naquele tempo eram simplesmente inadequados para a maioria das
tarefas de reconhecimento de padrões de importância prática. Tentativas subseqüentes
de estender o poder dessas redes, considerando múltiplas camadas desses dispositivos,
sentiam a ausência de algoritmos efetivos de treinamento. Em meados da década de 1960,
Minsky e Papert apresentaram uma análise desencorajadora da limitação das máquinas
do tipo perceptron [5], o que levou Simon a descartar essa área de estudo sob o tı́tulo de
“Nascimento e morte de um mito” alguns anos mais tarde [6].
Essa visão foi mantida até meados da década de 1980, quando Rumelhart, Hinton
e Willians mudaram consideravelmente a situação ao desenvolver novos algoritmos de
treinamento para perceptrons multicamadas. A regra generalizada delta para aprendizado
por retropropagação, como ficou conhecido o método proposto por estes autores, é uma
opção de treinamento efetivo para máquinas de múltiplas camadas [7]. Embora não se
possa mostrar que esse algoritmo de treinamento convirja para uma solução no sentido da
prova análoga para o perceptron de uma camada, a regra generalizada delta tem sido usada
com sucesso em vários problemas de interesse prático, estabelecendo essas máquinas do
tipo perceptron com múltiplas camadas como um dos principais modelos de redes neurais
atualmente em uso [8].
Baseado nisso, esse projeto tem como objetivo introduzir os aspectos básicos na im-
plementações de redes neurais de múltiplas camadas. Começaremos introduzindo o per-
ceptron mais simples como um modelo básico de um neurônio e a partir daı́, discutiremos
alguns aspectos do treinamento de perceptrons sob as condições de separação de classes,
bem como de não separação. Por fim, implementaremos esses algoritmos de treinamento
de padrões no software Mathematica. Embora simples, esses tópicos servem como funda-
mento para o desenvolvimento da regra generalizada delta para o treinamento de redes
neurais multicamadas, que não discutiremos aqui.
 4

2 Perceptron para duas classes de padrões

Como já mencionado, McCulloch e Pitts propuseram um modelo que explica o funci-
onamento de neurônios como um dispositivo binário: a sua saı́da poderia ser pulso (1) ou
não pulso (0), e as suas várias entradas tinham ganho arbitrário e poderiam ser excita-
tórias ou inibitórias (figura 1). Para determinar a saı́da do neurônio, calculava-se a soma
ponderada das entradas com os respectivos ganhos como fatores de ponderação, positivos
nos casos excitatórios e negativos nos casos inibitórios. Se este resultado fosse maior ou
igual a um certo limiar então a saı́da do neurônio era 1; caso contrário era 0. Assim,
foi possı́vel implementar várias funções booleanas usando ganhos iguais a 1/2 e limiares
iguais a 1.

Figura 1: Neurônio booleano de McCulloch (extraı́do de Kovács [9]).

Seguindo as idéias de McCulloch, Rosenblatt criou o perceptron. Na sua forma mais

básica, o perceptron pode ser considerado como o neurônio de McCulloch que aprende
uma função de decisão linear (ao invés de considerar sempre ganhos e limiares fixos) capaz
de diferenciar dois conjuntos de treinamento linearmente separáveis como os da figura 2.
A resposta desse dispositivo básico pode ser formulada como uma soma ponderada de sua
entrada,
n
X
d(~x) = wi xi + wn+1 (1)
i=1

que representa uma função de decisão linear (figura 3). Nesse caso, o vetor ~x representa
a entrada de padrões do neurônio (dados iniciais utilizados para treinar a rede neural),
enquanto os coeficientes wi (i = 1, 2, ..., n + 1) são conhecidos como pesos, e modificam a
 5

entrada antes de ser somada. Podemos reescrever a equação 1 como

d(~x) = w1 x1 + w2 x2 + ... + wn xn + wn+1 = 0 (2)

que representa a equação de um hiperplano no espaço n-dimensional de padrões. Geome-

tricamente, os primeiros n coeficientes estabelecem a orientação do hiperplano, enquanto
o último coeficiente wn+1 é proporcional à distância perpendicular à origem.

Figura 2: Para classes linearmente separáveis, é possı́vel separar duas regiões A e B através
de uma superfı́cie de decisão (extraı́do de Kovács [9]).

Figura 3: Diagrama de blocos do discriminador linear (extraı́do de Kovács [9]).

Quando d(~x) > 0, a saı́da do perceptron é +1, indicando que o padrão ~x foi reconhecido
como pertencendo à classe c1 . O contrário é verdadeiro quando d(~x) < 0. Quando
d(~x) = 0, ~x situa-se sobre a superfı́cie de decisão que separa as duas classes, fornecendo
uma condição indeterminada.
 6

Podemos ainda testar a função em relação à wn+1 , onde a saı́da do sistema (elemento
de limiarização) é dado por

 +1 se Pn w x > −w
i=1 i i n+1
O= (3)
 −1 se Pn w x < −w
i=1 i i n+1

Uma outra formulação encontrada na prática é aumentar os vetores de padrões, acrescentando-

se um elemento adicional (n+1), que é sempre igual a 1, não importa a classe. Assim, é
possı́vel criar um vetor de padrões aumentado ~y a partir do vetor de padrões ~x fazendo-se
yi = xi , i = 1,2,3,...,n, e acrescentando-se um elemento adicional yn+1 = 1, de forma que
a equação 1 torna-se:
n+1
X
d(~y ) = wi yi (4)
i=1
T
= w
~ ~y

onde w
~ = (w1 , w2 , ..., wn , wn+1 ) é chamado de vetor de pesos. Assim, se tivermos ao menos
um vetor padrão de entrada ~x, e conhecermos o vetor de pesos w,
~ é possı́vel calcular a
saı́da obtida pela rede neural. No entanto, geralmente não se conhece w,
~ de forma que
o problema básico reduz-se a encontrar essas variáveis. Para isso, costuma-se treinar a
rede neural, usando um dado conjunto de treinamento de vetores de padrões de cada uma
das classes, {x~k }. Introduzindo esses vetores, e conhecendo as respectivas saı́das {dk }, é
possı́vel encontrar o melhor vetor w
~ que representa esses dados de entrada. Diz-se que
a rede neural sofreu um processo de aprendizado após encontrar o vetor de pesos. A
aplicação desse grande algoritmo está no fato de, uma vez determinado o vetor de pesos,
ser possı́vel calcular a saı́da para qualquer que seja um vetor de entrada ~x.

3 Algoritmos de treinamento
Pode-se aplicar diferentes algoritmos para treinar o perceptron, dependendo do tipo de
rede neural que se quer construir. Apresentaremos duas formas diferentes de treinamento:
 7

uma que se aplica quando as classes podem ser linearmente separáveis e outra em que não
é possı́vel separá-las.

3.1 Treinamento para classes linearmente separáveis

Um algoritmo simples para a obtenção de um vetor de pesos para dois conjuntos de

treinamento linearmente separáveis é o seguinte: partindo de dois vetores de padrões
aumentados que pertençam a duas classes de padrões c1 e c2 , e de uma representação do
vetor inicial de pesos w~1 (escolhido arbitrariamente), podemos reformular esse vetor, de
~ T (k)~y (k) ≤ 0, então a (k+1)-ésima iteração é dada por
forma que se ~y (k) ∈ c1 e w

w(k
~ + 1) = w(k)
~ + c~y (k) (5)

~ T (k)~y (k) ≥ 0,
onde c é um incremento positivo de correção. Analogamente, se ~y (k) ∈ c2 e w
temos
w(k
~ + 1) = w(k)
~ − c~y (k) (6)

Em qualquer outra situação,

w(k
~ + 1) = w(k)
~ (7)

Esse método de treinamento baseia-se num conceito de recompensa-e-punição. A

“recompensa” para a máquina no caso de classificação correta é, na verdade, a ausência
de punição. Em outras palavras, se a máquina classificar um padrão corretamente, ela
é recompensada pelo fato de não haver mudanças em w.
~ A convergência do algoritmo
ocorre quando o conjunto completo de treinamento para as duas classes for passado pela
máquina sem erros. A regra de incremento fixo de correção converge em um número finito
de passos se os dois conjuntos de padrões de treinamento forem linearmente separáveis.

3.2 Classes não separáveis

Na prática, classes de padrões linearmente separáveis são (raras) exceções. Conseqüen-

temente, uma quantidade significativa de esforço foi feita no desenvolvimento de técnicas
 8

projetadas para trabalhar com classes não separáveis de padrões entre as décadas de 1960
e 1970. No entanto, com os avanços recentes no treinamento de redes neurais, muitos dos
métodos que tratam com o comportamento não separável tornaram-se apenas tópicos de
interesse histórico. Um dos primeiros métodos, entretanto, é diretamente relevante nessa
discussão: a regra delta original. Conhecida como a regra delta de Widrow-Hoff, ou de
mı́nimos quadrados para o treinamento de perceptrons, o método minima o erro entre a
resposta verdadeira e a desejada a cada passo do treinamento.
A idéia do treinamento é determinar qual o melhor vetor de pesos w
~ que corresponde
ao conjunto de valores de saı́da dk para um dado conjunto de vetores de entrada ~x, ambos
conhecidos. O conceito de melhor está associado à busca da minimização do erro cometido
ao se comparar a saı́da dada pela rede yk com o valor tomado como correto dk . Assim,
podemos procurar um conjunto de pesos que minimiza o erro quadrático médio para o
conjunto de vetores de entrada. Se o valor de saı́da obtido para o k-ésimo vetor padrão
de entrada é yk , então
k = dk − yk (8)

de forma que o erro quadrático médio é

n+1
1 X 2
ξ = h2k i =  (9)
n + 1 i=1 i

Substituindo a equação 8 na equação 9 temos que

ξ = hdk − w ~ T hx~k x~k T iw

~ · x~k i2 = hd2k i + w ~ − 2hdk x~k T iw
~ (10)

Para o caso de duas classes, a equação acima representa a equação de um parabolóide. As

coordenadas wi correspondentes ao ponto de mı́nimo são os melhores pesos, e conseqüen-
temente a solução do problema.
Para encontrar o ponto de mı́nimo, é necessário calcular o gradiente de ξ. No entanto,
ao invés de aplicar sucessivos vetores padrões e acumular o erro quadrático médio, vamos
aplicar apenas um vetor padrão de entrada x~k e usar o valor do erro k diretamente.
 9

Nesse caso podemos usar o valor local do erro ao quadrado como aproximação para o erro
quadrático médio para um padrão particular:
n
!2
X
ξ = h2k i ≈ 2k = ξk = dk − wi (xi )k (11)
i=1

Uma vez que ξk é uma função dos pesos, o gradiente dessa função é dado por
n
!
∂ξk X
= −2 dk − wi (xi )k (xi )k = −2k (xi )k (12)
∂wi i=1

Por fim, ajustamos o valor do peso wi por um pequeno valor na direção contrária à
do gradiente. Em outras palavras, atualizamos o valor do peso de acordo com a seguinte
“receita”:
wi (t + 1) = wi (t) + c(xi)k (13)

ou, em forma vetorial,

w(t
~ + 1) = w(t)
~ + c(~x)k (14)

onde c é chamado de parâmetro de taxa de aprendizado e geralmente é muito menor do

que 1.
Repetindo o processo acima para todo o conjunto de vetores padrão de entrada, es-
taremos caminhando em direção ao ponto de mı́nimo na superfı́cie do erro, embora não
necessariamente teremos o gradiente exato da superfı́cie devido às aproximações feitas.
Enquanto o vetor de pesos se move em direção ao ponto de mı́nimo, os valores de erro
diminuem. Deve-se manter a iteração até os erros serem reduzidos a um valor aceitável,
sendo que a definição de aceitável é determinada pelas exigências da aplicação.
 10

4 Resultados obtidos

4.1 Problema 1: exemplo de uma classe separável

Como primeiro exemplo de aplicação dos tópicos discutidos acima, vamos discutir os
dois conjuntos de treinamento apresentados na figura 4, cada qual consistindo de dois
padrões. O algoritmo de treinamento deveria terminar com sucesso, uma vez que os dois
conjuntos de treinamento são linearmente separáveis.

Figura 4: Problema 1 - ilustração do algoritmo de treinamento do perceptron para padrões

pertencentes a duas classes.

O algoritmo da seção 3.1 foi implementado no Mathematica (arquivo em anexo), para

o caso desse problema. A convergência foi atingida para 4 ≤ k ≤ 13, dependendo do vetor
de pesos inicial, que foi escolhido de forma arbitrária (utilizando o comando Random[ ] no
Mathematica). A solução para o vetor de pesos também variou de acordo com a escolha
inicial, porém o número de possibilidades foi restrito. As soluções encontradas, bem como
sua freqüência em 76 simulações, estão na figura 5.
 11

Figura 5: Soluções encontradas para o vetor de pesos do problema 1.

Figura 6: Fronteira de decisão mais provável para o treinamento do problema 1

A função de decisão correspondente ao vetor de pesos mais provável é d(~y ) = −3y1 +1.
Voltando ao espaço de padrões original leva a d(~x) = −3x1 + 1, que, quando igualada a
zero, se torna a equação da fronteira de decisão mostrada na figura 6.
 12

4.2 Problema 2: Treinamento de uma rede neural para imple-

mentação da porta lógica AND

Um outro exemplo análogo ao anterior e que pode ser feito a partir do treinamento de
redes neurais para classes separáveis é a implementação da porta lógica AND, cuja tabela
verdade é mostrada abaixo:

p q AND
T T T
T F F
F T F
F F F

Figura 7: Problema 2 - ilustração do algoritmo de treinamento do perceptron para o

problema AND.

Utilizamos o software Mathematica para a implementação do algoritmo (arquivo em

anexo) para encontrar o vetor de pesos. A convergência para a solução final dependeu
do vetor de pesos inicial, e variou entre 6 ≤ k ≤ 17 iterações. No entanto, todas as 40
~ = (−3, −2, 4). Assim, a equação da fronteira
simulações resultaram na mesma solução: w
 13

de decisão que separa as duas classes do problema é dada por d(~x) = −3x1 − 2x2 + 4 = 0,
como mostra a figura 8.

Figura 8: Fronteira de decisão encontrada para o treinamento do problema 2.

4.3 Problema 3: Implementação da função 2cos(πk/8) a partir

de sen(πk/8)

Por fim, realizamos uma simulação utilizando a regra delta apresentada na seção 3.2. A
idéia foi encontrar o vetor de pesos de minimiza o erro na utilização da função sen(πk/8)
para representar a função 2cos(πk/8). A comparação entre as funções utilizadas pode ser
vista na figura 9.
~ = (4.8, −5.2), variando a segunda casa decimal
A solução para o vetor de pesos foi w
devido à escolha (aleatória) do vetor de pesos inicial. Na implementação do algoritmo, o
parâmetro da taxa de aprendizado foi fixado em 0.2, resultando num número de iterações
da ordem de 760 (para um parâmetro de taxa de aprendizado maior, o número de iterações
seria menor).
Podemos acompanhar a evolução do aprendizado calculando o valor do erro para cada
 14

Figura 9: Problema 3 - (a) gráfico da função 2cos(πk/8); (b) gráfico da função de entrada
sen(πk/8) e; (c) comparação entre as duas funções citadas acima.

iteração (figura 10), mostrando que este diminui até o valor mı́nimo estipulado no inı́cio
do programa (5.10−4 ). Como o vetor de pesos foi calculado para cada valor de k, também
podemos acompanhar a evolução de w
~ em função do número de iterações (figura 11).
 15

Figura 10: Problema 3 - Valor do erro ao longo do número de iterações.

Figura 11: Problema 3 - Evolução do vetor de pesos ao longo das iterações.

Widrow e Stearns calcularam a equação exata para a superfı́cie de erro para esse
exemplo [10],

(w1 , w2 ) = 0, 51(w12 + w22 ) + w1 w2 cos(π/8) + 2w2 sen(π/8) + 2 (15)

cujo gráfico pode ser visto na figura 12. Se fizermos uma projeção em duas dimensões
 16

com o auxı́lio do comando ContourPlot no Mathematica, podemos acompanhar o movi-

mento do vetor peso ao longo da superfı́cie exata quando a rede aprende. A figura 13
indica a posição do vetor peso encontrado, comparada com a superfı́cie exata para o erro,
mostrando a solução está muito próxima do vetor de pesos w
~ = (w1 , w2 ) que minimiza o
erro.

Figura 12: Problema 3 - Superfı́cie de erro encontrada a partir da equação exata.

Figura 13: Problema 3 - Comparação do vetor de pesos encontrado com a superfı́cie exata.
 17

5 Conclusões
O presente trabalho procurou introduzir os aspectos básicos relacionados com o apren-
dizado de redes neurais. Discutimos diferentes tipos de treinamento de perceptrons,
classificando-os em relação à separação de classes. Implementamos os algoritmos pro-
postos no software Mathematica através da solução de três problemas propostos simples,
porém didáticos. Os resultados encontrados foram condizentes com o esperado, vendo que
para classes linearmente separáveis o algoritmo converge num número finito de passos;
para classes não-separáveis, pudemos encontrar a solução do vetor de pesos e compará-la
com a equação exata, mostrando uma grande concordância entre esses resultados.
Embora simples, vale ressaltar o fato de que esses tópicos servem como fundamento
para o desenvolvimento da regra generalizada delta para o treinamento de redes neurais
multicamadas, não discutida aqui, mas que é de fundamental importância para o desen-
volvimento de redes neurais multicamadas utilizadas atualmente.

Referências
[1] W. McCulloch e W. Pitts, Bulletin of Mathematical Biophysics 5 (1), 115-133 (1943).

[2] D. Hebb, The organization of behaviour, John Wiley & Sons, New York (1949).

[3] F. Rosenblatt, Mechanisation of thought processes: Proc. of Symposium 10 (1), 421-

456 (1959).

[4] F. Rosenblatt, Principles of neurodynamics: perceptrons and the theory of brain me-
chanisms, Spartan, Washington (1962).

[5] M. Minsky e S. Papert, Perceptrons: an introduction to computational geometry, the

MIT Press. Cambridge, Mass. (1969).
 18

[6] J.C. Simon, Patterns and Operators: the foundations of data representations,
McGraw-Hill, New York (1986).

[7] D.E. Rumelhart, G.E. Hinton e R.J. Williams, Parallel distributed processing: explo-
rations in the microstructures of cognition, vol 1: foundations, Rumelhart, D.E., et
al. eds., MIT Press, Cambridge, Mass., 318-362 (1986).

[8] R.C. Gonzalez e R.E. Woods, Digital Image Processing, 2nd. Edition, Prentice Hall,
New Jersey (2002).

[9] Z.L. Kovács, Redes Neurais Artificiais: fundamentos e aplicações, 3a. edição, Livraria
da Fı́sica Ed., São Paulo (1996).

[10] B. Widrow e S.D. Stearns, Adaptative Signal Processing, Prentice Hall, New Jersey
(1985).
Apêndice: Implementação dos algoritmos no
Mathematica