Redes Neurais para Inferência Estatística -FEA/USP Jun/2002 Renato Vicente

(1)

Criado por Renato Vicente 1 27/01/06

Redes Neurais para Inferência Estatística

- F E A / U S P J u n / 2 0 0 2 Renato Vicente^∗

Programa

1. Introdução: Redes Neurais, Matlab e Netlab 2. Algoritmos de Otimização

3. Estimação de Densidades de Probabilidade 4. Redes Neurais com uma Camada

5. Redes Neurais Multicamada 6. Amostragem

7. Técnicas Bayesianas Opcionalmente:

8. Radial Basis Functions

9. Redução Dimensional e Visualização de dados 10. Processos Gaussianos

Referências Básicas:

• Using Matlab, The MathWorks Inc. (2000);

• Bishop, C.M., Neural Networks for Pattern Recognition, Oxford University Press, Oxford, 1995;

• Nabney, I.T., Netlab: Algorithms for Pattern Recognition, Springer, London, 2002.

∗ rvicente@usp.br

(2)

Introdução: Redes Neurais, Matlab e Netlab

Redes Neurais

Rede Neural é um nome fantasia para modelos de inferência multidimensionais e não- lineares. O grande apelo destes modelos está em sua capacidade de “aprender”, generalizar ou extrair regras automaticamente de conjuntos de dados complexos.

No caso mais simples, temos um conjunto de pares entrada-saída D={(x^{( )}ⁿ,t^{( )}ⁿ )}^p_n₌1 e queremos modelar a função tˆ= =y y( ,x w) que produz melhores estimativas para pares fora do conjunto D , dados vetores x. Este problema é denominado r e g r e s s ã o . A Rede Neural consiste simplesmente de uma escolha particular para a família de funções

( , )

y x w parametrizada por w, denominados p e s o s s i n á p t i c o s .

A importância das Redes Neurais neste contexto está no fato delas representarem um esquema bastante genérico para a representação de famílias de funções não-lineares com várias variáveis de entrada e saída e controladas por um certo número de parâmetros ajustáveis.

Há uma série de famílias, ou arquiteturas, clássicas para Redes Neurais que são representadas graficamente.

P e r c e p t r o n L i n e a r P e r c e p t r o n N ã o - l i n e a r

R e d e M u l t i c a m a d a

1 0

1 1

n N

l j j

l j

y g u g w x w

= =

  

= 

∑



∑

+ 

0 1

N j j j

y g w x w

=

 

=  + 



∑



1 x

0 1

N j j j

y w x w

=

∑

+

1 x

(3)

É possível¹ mostrar que Redes Neurais Multicamada com um número N suficientemente grande de unidades na mamada interna (ou escondida) podem representar qualquer função com erro menor que ε(N). Uma maneira simples e direta para percebermos este fato é ilustrada abaixo:

Na figura uma função arbitrária g(z) é representada por uma soma de funções degrau (z z_i)

Θ − sobre uma partição da reta P={ , ,...,z z₀ ₁ z_N}. A medida que refinamos a partição fazendo z_i₊1− <z_i δ( )N , reduzimos o erro ε(N).

Quando as saídas consistem de classes discretas t∈{1,..., }c o problema de inferência é denominado c l a s s i f i c a ç ã o .

1 Hornik, K. (1991). Approximation capabilities of multilayer feedforward networks. Neural Networks 4 (2), 251-257.

( )x Θ

0 x= 0

1

0 1

0

( ) ( ) { } ( )

N

i i i

i

g z g z g₊ g z z

=

≈ +

∑

− Θ −

(4)

Matlab

Matlab (M a t r i x L a b o r a t o r y ) é uma linguagem para computação científica com estrutura otimizada para a realização de operações com matrizes. O ambiente Matlab é composto por uma série de funções pré-definidas para cálculo, leitura e escrita de arquivos e visualização. Este conjunto de funções pode ser facilmente extendido por t o o l b o x e s dedicadas. Há t o o l b o x e s para finanças, tratamento de sinais, econometria e redes neurais.

Para ilustrar a forma como matrizes podem ser tratadas pelo Matlab utilizamos o quadrado mágico de Dührer que é utilizado como exemplo no G e t S t a r t que acompanha o software. Na linha de comando do Matlab entramos:

> A = [16 3 2 13; 5 10 11 8; 9 6 7 12; 4 15 14 1]

A =

16 3 2 13 5 10 11 8 9 6 7 12 4 15 14 1

Após este comando a matriz A fica armazenada no W o r k s p a c e do Matlab conforme ilustrado abaixo.

(5)

As propriedades do quadadro mágico podem ser analisadas utilizando funções do Matlab.

Por exemplo, a função abaixo soma cada uma das linhas da matriz A.

> sum (A)

ans =

34 34 34 34

Na ausência de definição de variável de saída o Matlab aloca o resultado no W o r k s p a c e sob o nome a n s. Assim ao entrarmos

> ans

ans =

34 34 34 34

Se quisermos somar as colunas ao invés das linhas temos que transpor a matriz A, isso feito simplesmente pelo comando

>A'

ans =

16 5 9 4 3 10 6 15 2 11 7 14 13 8 12 1

Assim podemos realizar a soma das colunas entrando

>sum(A')'

ans = 34 34 34 34

Novamente o resultado é 34. Podemos também calcular a soma da diagonal, ou traço, de duas formas:

> diag (A)

ans = 16 10 7 1

(6)

> sum (diag(A))

ans = 34

Ou

> trace(A)

ans = 34

Curiosamente continuamos obtendo 34. Somemos agora a antidiagonal da matriz A, para isso podemos utilizar a função f l i p l r para enviarmos cada coluna da esquerda para a direita da matriz A.

> fliplr (A)

ans =

13 2 3 16 8 11 10 5 12 7 6 9 1 14 15 4

E a seguir

> sum(diag(fliplr(A)))

ans = 34

As somas são sempre iguais a 34 pois quando dividimos números inteiros de 1 a 16 em quatro grupos com somas iguais temos:

> t=1:1:16

t =

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

> sum(t)/4

ans = 34

Aqui utilizamos ":" para gerarmos números de 1 a 16 em passos de 1.

(7)

O Matlab possui uma função específica para a criação de quadrados mágicos de qualquer dimensão, esta função é

> B=magic(4)

B =

16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1

É possível reordenar as colunas de B para reobtermos A utilizando o comando

> B(:,[1 3 2 4])

ans =

16 3 2 13 5 10 11 8 9 6 7 12 4 15 14 1

Netlab

O Netlab é uma t o o l b o x para Redes Neurais para Matlab disponibilizada gratuitamente no site do Neural Computing Research Group da Univerisdade de Aston (www.ncrg.aston.ac.uk). Esta t o o l b o x toran a implementação de modelos baseados em Redes Neurais muito simples. Os códigos produzidos em Matlab podem então ser convertidos em executáveis utilizando o M a t l a b C o m p i l e r . Como um primeiro contato com o Netlab escreveremos sua versão para o clássico "H e l l o W o r l d ".

Começamos por gerar de um conjunto de dados fictícios para treinamento de nossa Rede Neural. Para isso vamos supor que a função que queremos inferir é

( ) (2 )

f x =sin πx . No entanto, só temos acesso a uma versão corrompida por ruído gaussiando desta função assim, nosso conjunto de dados é "gerado" da seguinte forma:

sin(2 )

~ (0,1)

n n n

n

t x

N

π σε

ε

= +

,

onde N(0,1) é uma distribuição normal com média nula e variância unitária.

No Matlab teremos

1 x=[0:1/19:1]';

2 ndata=size(x,1);

3 t=sin(2*pi*x) + 0.15*randn(ndata,1);

(8)

Aqui utilizamos alguns recursos novos. Utilizamos ao final de cada linha ";" , esta instrução faz com que o Matlab omita resultados intermediários dos cálculos sendo executados. A primeira instrução gera um vetor coluna x com 20 dimensões contendo números de 0 a 1 em intervalos de 1/19. Na linha 2 utilizamos a função s i z e ( x , 1 ) para obtermos o tamnho em número de linhas do vetor coluna x, assim, se entrarmos:

> size(x)

ans = 20 1

Ou seja, o vetor x possui 20 linhas e 1 coluna, s i z e ( x , 1 ) nos dá o número de linhas, enquanto s i z e ( x , 2 ) nos dá o número de colunas. Na linha 3 utilizamos a função

r a n d n ( l i n h a s , c o l s ) para gerarmos um vetor de números aleatórios independentes com

distribuição gaussiana com média nula e variância unitária. De forma genérica esta instrução pode ser empregada pra gerar matrizes aleatórias de qualquer tamanho.

>ran dn(5,5) ans =

1.3808 0.3908 -1.3745 -1.3454 -0.7826 1.3198 0.0203 -0.8393 1.4819 -0.7673 -0.9094 -0.4060 -0.2086 0.0327 -0.1072 -2.3056 -1.5349 0.7559 1.8705 -0.9771 1.7887 0.2214 0.3757 -1.2090 -0.9640

No Matlab, podemos visualizar o vetor t e a função original utilizando:

> plot(x,sin(2*pi*x),x,t,'k+');

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

-1.5 -1 -0.5 0 0.5 1 1.5

Gerado nosso conjunto fictício de dados, podemos definir uma arquitetura de rede para utilizarmos na inferência. Assumiremos aqui que uma Rede Neural Multicamada com 3

(9)

unidades na camada escondida seja adequada. No Netlab podemos definir uma arquitetura de rede em uma única linha de comando.

4 net=mlp (1, 3, 1, 'linear') net =

type: 'mlp' nin: 1 nhidden: 3 nout: 1 nwts: 10 actfn: 'linear'

w1: [-1.6823 -0.5927 0.1820]

b1: [ -0.1300 -0.1185 -0.0827]

w2: [3x1 double]

b2: 0.2541

A função m l p do Netlab cria uma estrutura que especifica completamente a arquitetura e os parâmetros iniciais da Rede Neural. Assim a rede possui n i n = 1 entrada, n h i d d e n = 3 unidades na camada interna, n o u t = 1 saída e n w t s = 1 0 parâmetros entre pesos sinápticos e limiares. Os parâmetros são iniciados em valores aleatórios. Graficamente teremos:

Cada unidade possui uma entrada extra denotada por uma seta que regula o l i m i a r d e

d i s p a r o de cada um dos neurônios. Cada neurônio da camada escondida gerado pela

função m l p implementa uma f u n ç ã o d e t r a n s f e r ê n c i a s i g m o i d a l do tipo tanh( _j _j)

j

b+

∑

w x ^. Já o neurônio da camada de saída implementa a função de transferência especificada na função m l p , no caso, uma função linear. Assim, a arquitetura da Rede Neural que utilizaremos representa a seguinte família de funções:

3

2 2 1 1

1

( , , ) _ltanh( _l _l )

l

y x b w b w x

=

= +

∑

+

w b .

O terceiro passo consiste no treinamento desta rede utilizando os dados fictícios contidos no conjunto de treinamento. Para isso o Netlab utiliza a infra-estrutura de algoritmos de otimização do Matlab. Primeiro é necessário armazenar as configurações padrão dos otimizadores do Matlab:

(10)

5 options=foptions;

A seguir personalizamos algumas destas opções:

6 options(1) = 0;

Este comando evita que os algoritmos de otimização exibam na tela a evolução passo a passo da função custo sendo minimizada.

7 options(14) =100;

Esta instrução limita em 100 passos os ciclos de otimização. Agora podemos treinar nossa rede utilizando a função n e t o p t do Netlab:

8 [net, options] = netopt(net, options, x, t, 'scg');

Warning: Maximum number of iterations has been exceeded

A função n e t o p t otimiza os parâmetros da rede definida pela estrutura n e t , utilizando as opções de otimizador defindas em o p t i o n s e utilizando os dados de entrada contidos no vetor x e de saída contidos no vetor t. O último argumento em n e t o p t especifica o tipo de algoritmo a ser utilizado na otimização, no exemplo, 's c g ' significa s c a l e d g r a d i e n t. A função retorna uma mensagem de aviso indicando que a otimização foi terminada devido ao limite de 100 passos de otimização.

Neste momento já obtivemos no W o r k s p a c e do Matlab uma estrutura n e t com parâmetros otimizados assim:

> net.w1

ans =

-5.2017 0.8701 1.5318

> net.w2

ans = 2.6033 1.0716 3.4209

> net.b1

ans =

2.4785 -0.6179 -0.3766

> net.b2 ans = -0.7588

(11)

O quarto passo consiste em utilizarmos a rede recém treinada. Para isso utilizamos a função m l p f w d do Netlab, assim se quisermos saber qual seria a saída para a entrada

x = 0 . 5 6 5 , calculamos:

>mlpfwd(net,0.565)

ans = -0.4632

Para analisarmos visualmente a qualidade de nosso modelo para os dados representamso em um gráfico previsões para várias entradas e o valor "real":

9 plotvals=[0:0.01:1]';

10 y=mlpfwd(net,plotvals);

11 plot(plotvals, y, 'ob',plotvals,sin(2*pi*plotvals));

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1

-1 -0.5 0 0.5 1 1.5

Na figura acima as previsões aparecem como circunferências e o valor "real" como uma linha cheia. A qualidade da previsão irá depender da Rede Neural empregada e do nível de ruído dos dados.

(12)

Toda a seção de Matlab, utilizada neste problema pode ser armazenada na forma de um arquivo .m como o exibido a seguir:

Exercícios

(1) Escreva uma rotina ou função em Matlab que calcule o erro quadrático de predição da Rede Neural Multicamada utilizada no exemplo acima no conjunto p l o t v a l .

( ) ( _j) ( ; , )_j 2 j

E ^x =

∑

f x − y x ^{w b}  ^.

(2) Treine Redes Multicamada com número de unidades na camada interna indo de

n h i d d e n = 1 a n h i d d e n = 30 e construa um gráfico do erro de predição acima contra o

número de unidades na camada escondida. Qual é a melhor escolha de arquitetura ?

(13)

Algoritmos de Otimização

Aprendizado em Redes Neurais: Um Problema de Otimização

Como já dissemos, o problema de regressão utilizando Redes Neurais consiste em encontrar a função tˆ=y( , )x w que produz melhores estimativas para a regra implícita em um conjunto de exemplo de pares entrada-saída D={(x^{( )}ⁿ ,t^{( )}ⁿ )}_n^p₌1.

É importante ressaltar que a tarefa central de uma regressão não é a memorização do conjunto de exemplos D, mas sim a antecipação de pares novos (ou fora da amostra) que poderiam ser gerados pelo mesmo processo que gerou D.

A descrição completa do processo gerador do conjunto D é fornecida por uma densidade de probabilidade conjunta p x t sobre D. Esta densidade de probabilidade pode ser ( , ) decomposta da seguinte forma:

( , ) ( ) ( )

p x t = p t x p x (1.1)

A densidade (p t x é conhecida como densidade condicional e representa a probabilidade ) de uma saída t dada uma entrada com valor específico x. Já a densidade p(x) representa a densidade incondicional de x que pode ser calculada a partir da densidade conjunta por integração (també conhecida como marginalização):

( ) ( , )

p ^x =

∫

p ^{t x} d^t^(1.2)

Uma maneira pictórica de representarmos um modelo para o processo de geração do conjunto de dados D é exibida na figura a seguir:

No modelo acima há dois processos estocásticos: o de geração das entradas x descrito pela densidade p(x) e o de geração de saídas com ruído descrito pela densidade condicional

( ) p t x .

Processo estocástico de geração de entradas

x

Processo determinístico de geração de saídas

y(x)

ruído

Saídas corrompidas

por ruído

t

(14)

O aprendizado consiste em estimarmos a densidade condicional de probabilidade p t x( ) que melhor se ajuste ao conjunto D, possibilitando assim a predição de saídas possíveis para entradas x fora do conjunto D utilizado no treinamento.

Ao modelarmos os dados utilizando Redes Neurais supomos uma arquitetura de rede, o que equivale à escolha de uma família de funções ( ; )y x w parametrizada por w. Por conseqüência a densidade condicional (p t x w; ) também é parametrizada por w. Para encontrarmos qual é o vetor w que melhor ajusta os dados em D, podemos maximizar a função de verossimilhança definida por:

1

( ) ( , ; )

( ; ) ( )

p

n n

n p

n n n

n

L p

p p

=

∏

w x t w

t x w x

(1.3)

Alternativamente, e com uma série de vantagens práticas podemos definir uma função erro que deve ser minimizada no aprendizado:

1 1

( ) ln ( )

ln ( ; ) ln ( )

p p

n n n

n n

E L

p p

= =

= −

∑

−

∑

w w

t x w x (1.4)

O segundo somatório não depende do vetor de parâmetros w, podendo ser ignorado na minimização do erro E(w):

1

( ) ln ( ; )

p

n n

n

E p

=

= −

∑

w t x w (1.5)

O aprendizado em uma Rede Neural consiste simplemente em uma tarefa de otimização:

minimizar E(w) dado o modelo o conjunto de treinamento D e a densidade condicional ( ; )

p t x w .

Erro quadrático

Suponhamos que o processo real de produção de saídas t consista de uma perturbação estocástica ε sobre uma função determinística h(x) assim:

( )

t=h x +ε (1.6)

Suponhamos agora que a perturbação estocástica (ruído) seja distribuída de forma normal:

(15)

2 2 2

( ) 1 exp

2 2

p ε ε

πσ σ

 

= − 

  (1.7)

Se modelarmos a função real com uma Rede Neural cuja arquitetura implemente a família y x w( ; ) a densidade condicional será :

( )

²

2 2

( ; )

( ) 1 exp

2 2

t y

p t πσ σ

 − 

= − 

 

 

x x w . (1.8)

O erro será então :

( )

1

2 2

1

( ) ln ( ; )

1 ( ; ) ln ln(2 )

2 2

p

n n

n p

n n

E p t

t y Np σ Np π

σ

=

= −

= − + +

∑

w x w

x w

(1.9)

Ao omitirmos as constantes e o fator de escala em frente ao somatório teremos a seguinte medida de erro de aprendizado:

( )

²

1

( ) 1 ( ; )

2

p

n n

n

E t y

=

∑

−

w x w , (1.10)

que é a distância Euclidiana clássica utilizada em regressões usuais.

Erro r-Minkowski

Se supusermos que o ruído ε é distribuído segundo uma generalização de uma gaussiana:

( )

1

( ) exp

2 (1/ )

r r

p r

r

ε = β −β ε

Γ (1.11)

O erro de treinamento tomará a seguinte forma:

( )

1

( ) 1 ( ; )

2

p n n r

n

E t y

=

∑

−

w x w . (1.12)

A figura abaixo representa densidades para vários valores de r.

(16)

A escolha de diferentes valores para o parâmetro r regula a sensibilidade do modelo a valores com erros grandes, como pode ser visto na figura abaixo:

Conforme r aumenta maior é a penalização para desvios grandes que passam, por serem pouco prováveis, a ser considerados incompatíveis com os dados.

Exercícios

(1) Generalize para o caso de saídas t multidimensionais.

(17)

Otimização

Há várias técnicas para otimização de funções multidimensionais e não-lineares como a função erro que devemos minimizar. Genericamente um algoritmo iterativo de otimização no espaço de parâmetros w consiste em uma busca onde a cada passo são determinados uma direção e um tamanho de passo:

t₊1= t+αt t

w w d (1.13)

Quanto mais informação sobre a geometria da superfície definida pela função erro E(w) for utilizada mais eficiente será o algoritmo. Uma boa idéia de como um algoritmo de otimização pode utilizar a geometria da função erro pode ser obtida utilizando uma aproximação quadrática para a superfície. Consideremos a seguinte expansão em torno de um ponto w^ˆ :

ˆ ˆ ˆ 1 ˆ ˆ

( ) ( ) ( ) ( ) ( ) ( )

E w ≅E w + w−w ⋅∇E w +2 w−w H w⋅ −w (1.14) A matriz H é conhecida como Hessiano sendo definida como:

2

ˆ jk

j k

H E

w w

= ∂

∂ ∂ w

(1.15) Suponha que wˆ =w^* seja um extremo de E, então:

* 1 * *

( ) ( ) ( ) ( )

E w ≅E w +2 w−w ⋅H w−w (1.16)

Podemos calcular os autovetores do Hessiano H :

k =λk k

Hu u , (1.17)

onde

j⋅ k =δjk

u u . (1.18)

Podemos expandir o vetor w – w^* na base dos autovetores de H para escrevermos:

*

k k k

α

− =

∑

w w u (1.19)

Substituindo (1.19) em (1.16) e utilizando (1.17) e (1.18) :

* 1 2

( ) ( )

2 k ^k ^k

E ^w ≅E ^w +

∑

λ α ^{. (1.20)}

Assim, os autovetores da Hessiana indicam direções ortogonais que diagonalizam a matriz H. De (1.20) pode-se concluir que para que w^* defina um mínimo é necessário que todos os autovalores sejam positivos, além disso a velocidade de convergência do erro é maior em direções com autovalor maior.

Otimização em Netlab

(18)

Discutiremos quatro técnicas implementadas pelo Netlab:

1. Gradient Descent 2. Gradiente Conjugado

3. Gradiente Conjugado Escalado 4. Quase-Newton

Para exemplificarmos como Netlab pode ser usado para otimizar funções utilizaremos um de seus programas de demonstração denominado demopt1. O programa demopt1 demonstra a otimização da seguinte função:

2 2 2

1 2 2 1 1

( , ) 100( ) (1 )

y x x = x −x + −x , (1.21)

conhecida como função de Rosenbrock utilizando quatro técnicas diferentes.

No Matlab podemos visualizar a superfície definida pela função acima com um único comando:

> ezsurfc ('100*(x1-x2^2)^2+(1-x1)^2',[-2, 2],[-2,2] )

(19)

Alternativamente, podemos utilizar a seguinte sintaxe menos direta:

1 x1=-2:0.01:2;

2 x2=-2:0.01:2;

3 [sx1, sx2] =meshgrid (x1,x2);

As instruções acima geram matrizes que contém o produto cartesiano dos vetores x1 e x2, assim se digitarmos

> [sx1(10,23) sx2(10,23)]

ans =

-1.7800 -1.9100

Veremos um par específico de valores.

A função de Rosenbrock pode ser calculada de duas formas:

> Y= 100*(sx1-sx2.^2).^2 +(1-sx1).^2;

> size(Y) ans = 401 401

onde utilizamos ".^ " com um ponto antes da operação para elevarmos cada componente das matrizes X1 e X2, sem "." teríamos calculado um produto matricial. Note que a resposta é uma discretização da superfície com 401 por 401 pontos.

Para exemplificar o cálculo com e sem ".":

>A=[0 1; 1 0]

A = 0 1 1 0

Um produto matricial será:

> A^2 ans = 1 0 0 1

ou

> A*A ans = 1 0 0 1

(20)

Componente a componente teremos

> A.^2 ans = 0 1 1 0

Uma outra forma de avaliarmos a função de Rosenbrock é utilizarmos diretamente a função do Netlab chamada rosen:

> Y1=rosen([sx1(:),sx2(:)]);

Esta operação retorna um vetor com 401 x 401 valores:

> size(Y1) ans =

160801 1

Este vetor pode então ser convertido em uma matrz com as dimensões apropriadas utilizando:

> Y1=reshape(Y1,length(x1),length(x2));

Esta instrução converte um vetor em uma matriz com o número de linhas igual ao número de dimensões do vetor x1 (length(x1)) e o número de colunas igual ao número de dimensões do vetor x2 (length(x2)). A matriz é preenchida coluna a coluna conforme o exemplo a seguir:

>A=[1 2 3 4 5 6 7 8 9 10 11 12];

>A=reshape(A,4,3) A =

1 5 9 2 6 10 3 7 11 4 8 12

Para plotarmos a superfície podemos utilizar a seguinte instrução :

>surf(x1,x2,Y)

Podemos também plotar curvas de nível da superfície:

> l=-1:6;

>v=2.^l;

>contour(x1,x2,Y,v)

(21)

Os mínimos da função são (-1,1) e (1,-1).

As funções de otimização do Netlab utilizam a seguinte sintaxe:

> [x, options, errlog, pointlog] = nome ('function', x, options, 'grad');

São quatro as funções de otimização: quasinew (Quase-Newton), conjgrad (gradiente conjugado), scg (gradiente conjugado escalado) e graddesc (Gradient Descent). Os argumentos das funções são, respectivamente: a função que se quer otimizar 'function', o ponto inicial x, o vetor de opções de otimização options e o gradiente da função que se quer otimizar 'grad'.

As saídas destas funções são, respectivamente: o resultado da otimização x, o vetor de opcções de otimização atualizado após o processo options, os valores de erro após cada ciclo errlog e a trajetória percorrida no espaço dos parâmetros pointlog.

O vetor options contém parâmetros para operação da rotina de otimização e parâmetros específicos para cada algoritmo:

options(1) : 1 para mostrar na tela os valores de erro, 0 para exibir apenas mensagens de aviso e -1 para não exibir nada;

options(2): Valor da precisão absoluta requerida para encerrar o processo de otimização.

Se x_t₊1−x_t <options(2) então esta condição é satisfeita.

options(3): Valor da precisão requerida na função otimizada. Se

( _t 1) ( )_t (3)

function x₊ − function x <options então a condição é satisfeita. Se esta e a condição acima forem satisfeitas a otimização é encerrada.

(22)

options (7): 1 se uma busca em linha é utilizada para minimização na direção do gradiente, 0 (default) se cada passo é dado na direção do negativo do gradiente com um learning rate definido por options(18).

options(9): 1 para que a função verifique o gradiente informado 'grad' contra a função 'function'.

options(10): registra o número total de avaliações de 'function'.

options(11): registra o número total de avaliações de 'grad'.

options(14): número máximo de iterações.

options(18): learning rate. (default=0.01).

Gradient Descent

O método de gradient descent consiste na escolha do negativo do gradiente da função erro como direção para cada passo de otimização, o tamnho de cada passo é definido por uma learning rate η assim:

1 ( )

t₊ = t − ∇η E t

w w w (1.22)

Os pontos fixos do algoritmo em (1.22) coincidem com os extremos da função erro, no entanto nada garante que ocorra convergência para estes pontos fixos. Analisemos a convergência do gradient descent em torno de um ponto fixo w^* .

O gradiente da função erro em torno de um ponto fixo pode ser aproximado (utilizando uma série de Taylor) por :

* *

( ) ( ) ( )

E E

∇ w ≅ ∇∇ w w−w , (1.23)

onde H = ∇∇E é o Hessiano da função erro.

Sejam λ_j os autovalores do Hessiano e u_j seus autovetores assim:

j j j

Hu =λu (1.24)

Expandindo w-w^* na base destes autovetores teremos:

j j j j

E α λ u

∇ ≅

∑

^e ^(1.25)

* *

1 1

( _t ) ( _t ) ( _t _t) _j

j

α α

+ − − − =

∑

+ −

w w w w u (1.26)

Utilizando (1.22) podemos escrever uma dinâmica para as componentes do caminho traçado no espaço dos parâmetros na direção de cada autovetor do Hessiano:

(23)

A dinâmica ao redor do ponto fixo será :

, 1 (1 ) ,

j t j j t

α ₊ = −ηλ α (1.28)

Considerando learning rate η fixa, para n passos teremos:

, (1 )ⁿ ,

j t n j j t

α ₊ = −ηλ α (1.29)

De (1.29) fica patente que uma condição necessária para que haja convergência de todas as componentes para o ponto fixo α =_j 0 quando n→ ∞ é

1−ηλ_j <1. (1.30)

Esta condição obriga que a learning rate η respeite :

max

η 2

<λ , (1.31)

onde λ_max é o maior autovalor do Hessiano. Note que quanto maior o produto da learning rate pelo autovalor, menor é o fator multiplicador em (1.29) e, por conseqüência, mais rápida é a convergência. Quando o Hessiano possuir um espectro de autovalores amplo (o que ocorre freqüentemente) as várias direções apresentarão tempos de convergência bem diferentes. O processo total de convergência é dominado pela direção com convergência mais lenta, ou seja, a direção com menor autovalor. A convergência será então dominada por:

min max

(1 2λ )

− λ . (1.32)

Se na vizinhança de um ponto fixo o Hessiano apresentar autovalores muito diferentes , ou seja, a superfície de erro apresentar curvas de nível elipsoidais bastante alongadas, a convergência do algoritmo será muito lenta.

Em geral gradient descent é bastante ineficiente sendo de pouco interesse prático. Apesar disso este algoritmo recebeu bastante atenção do meio acadêmico devido à facilidade de análise utilizando técnicas exatas. Várias formas de melhorar seu desempenho foram propostas entre elas: adição de um termo de "momento", redução do número de passos necessários para convergência pela utilização de um esquema para minimização unidimensional e implementação de learning rates variando com o tempo.

O termo de momento é como segue:

1 ( ) ( 1)

t₊ = t− ∇η E t +µ t − t₋

w w w w w , (1.33)

com 0≤ ≤µ 1.

Este termo tem o mesmo sinal da última variação, assim, se uma componente foi reduzida ela continuará sendo reduzida. Em geral isto será uma vantagem em trechos da superfície de erro em forma de vale, com pouca curvatura na direção do mínimo e muita curvatura em uma outra direção qualquer como ilustrado a seguir.

(24)

>ezsurfc ('10*x1^2+x2',[-1, 1],[0,10] )

O gradiente da função acima é ∇ =E (10 ,1)x1 , assim, se iniciarmos a otimização fora do eixo x1 =0 teremos fortes oscilações em decorrência da grande curvatura de uma das direções:

O termo de momento neste caso adicionará uma certa inércia à direção (0,1) aumentando a taxa de convergência.

Uma outra forma de reduzirmos o número de passos necessários para convergência é a redução do número de dimensões do problema apenas à direção do gradiente pela

(25)

Nesta variante a cada passo encontramos a amplitude do deslocamento na direção do gradiente , assim:

*

1 ( )

t₊ = t − ∇λ E t

w w w , (1.34)

onde λ^* é definido como o mínimo de:

( ) ( _t ( _t))

E λ =E w − ∇λ E w . (1.35)

De forma equivalente, escolhemos λ de forma a termos:

1

( ) ( _t ) ( _t) 0

dE E E

d λ

λ = −∇ w⁺ ⋅∇ w = , (1.36)

ou seja, gradientes sucessivos ortogonais. A minimização unidimensional em (1.35) pode ser realizada utilizando uma busca linear. Utilizando esta forma é possível aumentar consideravelmente a velocidade de convergência do gradient descent. O incoveniente deste algoritmo está na condição (1.36) que força movimentos em zig-zag no espaço de parâmetros.

Neste ponto, vale a pena discutirmos um pouco algoritmos de busca linear. O Netlab utiliza um algoritmo proposto por Brent¹ bastante eficiente e robusto que não utiliza o gradiente unidimensional da função na otimização . O algoritmo de Brent consiste em:

1. Encontrar 3 pontos a<b<c, tais que E(b)<E(a) e E(b)<E(a) . 2. Ajustar uma parábola passando pelos pontos a,b e c.

3. Minimizando a parábola para encontrar d.

4. Repetindo o processo para pontos d e escolhendo entre a,b,c os dois com menor erro.

Em Netlab uma busca linear é implementada pela função a seguir:

> [x, options] = linemin(f, pt, dir, fpt, options);

Onde f é a função a ser minimizada, pt é o ponto inicial, dir é a direção que define a linha de busca, fpt é o valor da função no ponto de início e options é o vetor de opções de otimização. O ponto de mínimo é dado por pt+x.*dir.

Como exemplo apresentamos a seguir otimização da função de Rosenbrock empregando Gradient Descent seguirá os seguintes passos:

1 options = foptions;

Para importar configurações padrão para o otimizador.

1 Brent, R. 1973, Algorithms for Minimization without Derivatives. Englewood Cliffs, NJ: Prentice-Hall.

(26)

2 options(1) = -1;

3 options(3) = 1e-8;

4 options(7)=1;

5 options(14) = 100;

Nada é exibido na tela , a precisão requerida para as variações na função otimizada é de 10^-

8 , a otimização empregará a variante com busca linear e o número total de iterações é fixado em 100. O vetor options inicia o processo na seguinte configuração:

>options(1) ans = -1

>options(2) ans =

1.0000e-004

>options(3) ans =

1.0000e-008

>options(9) ans = 0

>options(10) ans =

0

>options(11) ans =

0

>options(14) ans =

100

Assim a otimização deve encerrar quando as precisões fixadas forem atingidas ou quando o número de iterações chegar a 100. Para vermos todas as outras opções disponíveis basta utilizarmos o comando:

> help graddesc

GRADDESC Gradient descent optimization.

Description

[X, OPTIONS, FLOG, POINTLOG] = GRADDESC(F, X, OPTIONS, GRADF) uses batch gradient descent to find a local minimum of the function F(X)

whose gradient is given by GRADF(X). A log of the function values after each cycle is (optionally) returned in ERRLOG, and a log of the points visited is (optionally) returned in POINTLOG.

Note that X is a row vector and F returns a scalar value. The point at which F has a local minimum is returned as X. The function value at that point is returned in OPTIONS(8).

(27)

arguments to be passed to F() and GRADF().

The optional parameters have the following interpretations.

OPTIONS(1) is set to 1 to display error values; also logs error values in the return argument ERRLOG, and the points visited in the return argument POINTSLOG. If OPTIONS(1) is set to 0, then only warning messages are displayed. If OPTIONS(1) is -1, then nothing is displayed.

OPTIONS(2) is the absolute precision required for the value of X at the solution. If the absolute difference between the values of X between two successive steps is less than OPTIONS(2), then this condition is satisfied.

OPTIONS(3) is a measure of the precision required of the objective function at the solution. If the absolute difference between the objective function values between two successive steps is less than OPTIONS(3), then this condition is satisfied. Both this and the previous condition must be satisfied for termination.

OPTIONS(7) determines the line minimisation method used. If it is set to 1 then a line minimiser is used (in the direction of the

negative gradient). If it is 0 (the default), then each parameter update is a fixed multiple (the learning rate) of the negative gradient added to a fixed multiple (the momentum) of the previous parameter update.

OPTIONS(9) should be set to 1 to check the user defined gradient function GRADF with GRADCHEK. This is carried out at the initial parameter vector X.

OPTIONS(10) returns the total number of function evaluations (including those in any line searches).

OPTIONS(11) returns the total number of gradient evaluations.

OPTIONS(14) is the maximum number of iterations; default 100.

OPTIONS(15) is the precision in parameter space of the line search;

default FOPTIONS(2).

OPTIONS(17) is the momentum; default 0.5. It should be scaled by the inverse of the number of data points.

OPTIONS(18) is the learning rate; default 0.01. It should be scaled by the inverse of the number of data points.

(

∇^E⁽w^t+¹⁾+^Hd^t+¹

)

⋅ ≅d^t ⁰, (2.4) onde H é o Hessiano e por construção teremos que:

1 0

t⋅H t₊ ≅

d d . (2.5)

As direções acima são mutuamente conjugadas . Vetores mutuamente conjugados formam uma base ortogonal com métrica definida pelo Hessiano H. Suponhamos agora que iniciamos o processo de otimização no ponto w¹ do espaço dos parâmetros.

Suponhamos que w^* seja o mínimo da função erro E. A correção necessária para atingirmos o mínimo da função erro pode ser expandida em uma base de vetores mutuamente conjugados:

* 1

1 N

i i i

α

=

− =

∑

w w d , (2.6)

onde N é a dimensão do espaço de parâmetros. Se definirmos

1 1

1 j

j i i

i

− α

=

= +

∑

w w d , (2.7)

teremos a correção no componente j do vetor de parâmetros, alternativamente

1

j₊ = j+αj j

w w d (2.8)

(31)

otimização de uma componente por vez. Desta forma se calcularmos exatamente as direções conjugadas em cada passo precisaremo de exatos N passos para otimização. Para superfícies quadráticas apenas precisamos calcular a Hessiana (segundas derivadas) uma única vez. As direções conjugadas são obtidas simplesmente resolvendo um problema de autovalores para H pois :

k⋅H j =λj k⋅ j =λ δj jk

d d d d , (2.9)

Para superfícies genéricas o problema se torna mais complicado pois a Hessiana muda conforme a posição no espaço dos parâmetros e seria necessário recalcular a Hessiana e resolver o problema de autovalores acima para cada ponto. Para entendermos como podemos utilizar gradientes conjugados de forma prática, começamos por analisar o caso mais simples de uma superfície quadrática.

Suponhamos que a superfície de erro que queremos minimizar tenha a seguinte forma:

( ) 1

E w = ⋅ +ω w 2w⋅Hw. (2.10)

O gradiente desta função erro no ponto w será:

( )

E ω H

∇ w = + w. (2.11)

O ponto de mínimo será:

* 0

ω +Hw = . (2.12)

Agora, utilizando (2.6) teremos:

(2.13)

(

^* ¹

)

1 N

i i i

H H α

=

 

⋅ − = ⋅ 

∑



j j

d w w d d , (2.14)

onde d^j são direções conjugadas.

Utilizando (2.12):

1 1 N

j j i j i j j j

i

H H H

ω α α

=

− ⋅ − ⋅^d ^d ^w =

∑

^d ⋅ ^d = ^d ⋅ ^d ^{. (2.15)}

Assim encontramos a correção necessária em cada uma das direções conjugadas:

(

¹

)

j j

H H

α ⋅ ω+

= − ⋅

d w

d d . (2.16)

Utilizando (2.7) teremos

1

1 1

1 0

j

j j j i j i j

i

H H ⁻ α H H

=

⋅ = ⋅ +

∑

⋅ = ⋅

d w d w d d d w

!"#"$ e (2.17)

( )

⁽ ⁾

j j j j

j

j j j j

H E

H H

α ⋅ ω+ ⋅∇

= − = −

⋅ ⋅

d w d w

d d d d . (2.18)

Calculadas as correções em cada uma das direções conjugadas temos que encontrar uma forma de encontrarmos as próprias direções que seja mais eficiente do que o cálculo de Hessianas e a solução de problemas de autovalor. Uma maneira prática consiste em

(32)

adotarmos como primeira direção o negativo do gradiente no ponto de início

1= −∇E( 1)

d w . A seguir construímos cada uma das direções iterativamente:

1 ( 1)

j₊ = −∇E j₊ +βj j

d w d (2.19)

Empregando a condição para direções conjugadas teremos:

1 ( 1) 0

j₊ ⋅H j = −∇E j₊ ⋅H j+βj j⋅H j =

d d w d d d e (2.20)

( _j 1) _j

j

j j

E H

β −∇ H⁺ ⋅

= ⋅

w d

d d

Se assumirmos uma aproximação quadrática em torno de cada ponto do espaço poderemos empregar (2.20) como algoritmo para qualquer superfície. Nesta aproximação podemos escrever:

1 1

( _j ) ( _j) _j _j _j _j

E ₊ E H ₊ H α H

∇ w − ∇ w = w − w = d (2.21)

e por conseqüência:

1 1

1

( ) ( ) ( )

( ) ( )

j j j

j

j j j

E E E

E E

β ⁺ ⁺

+

 

−∇ ⋅ ∇ − ∇ 

= ⋅ ∇ − ∇ 

w w w

d w w (2.22)

conhecida como equação de Hesteness-Stiefel¹. Com algum trabalho de álgebra é possível mostrar que :

( _j) _k 0,

E j k

∇ w ⋅d = ≠ Empregando (2.19) teremos também que

( ) ( ) ( )

j⋅∇E j = −∇E j ⋅∇E j

d w w w . (2.23)

Substituindo em (2.22) encontramos a equação de Polak-Ribiere ²:

(2.24)

1 1

( ) ( ) ( )

( ) ( )

j j j

j

j j

E E E

E E

β = −∇ ⁺ ⋅ ∇ ⁺ − ∇ 

∇ ⋅∇

w w w

w w . (2.25)

Note que não é necessário calcular o Hessiano para avaliarmos as direções conjugadas, no entanto precisamos desta avaliação para calcularmos o tamanho do passo αj (vide expressão (2.18) ). Para evitarmos o cálculo do Hessiano, muito caro para um número muito grande de dimensões, podemos utilizar uma busca linear na direção conjugada do momento. Assim chegamos a uma descrição completa do algoritmo de gradientes conjugados:

1. Escolha um ponto inicial no espaço dos parâmetros w1;

2. Calcule o gradiente no ponto inicial e faça a primeira direção de otimização ser

1= −∇E( 1) d w ;

3. Para descobrir a amplitude do passo na direção d¹, utilize uma busca linear encontrando α1 =arg min (E w_j +αd1);

(33)

4. Calcule w2 =w1+α1 1d ;

5. Pare se os critérios de convergência foram satisfeitos 6. Calcule ∇E(w2);

7. A nova direção é dada por d2 = −∇E(w2)+β1 1d , com β1 definido pela relação de Polak-Ribiere.

8. Vá para o passo 3 para o novo d.

Utilizemos agora a implementação em Netlab do algoritmo de gradiente conjugado para otimizarmos novamente a função de Rosenbrock. Começamos por verificar as opções de otimização disponíveis para a função conjgrad:

> help conjgrad

CONJGRAD Conjugate gradients optimization.

Description

[X, OPTIONS, FLOG, POINTLOG] = CONJGRAD(F, X, OPTIONS, GRADF) uses a conjugate gradients algorithm to find the minimum of the function

F(X) whose gradient is given by GRADF(X). Here X is a row vector and F returns a scalar value. The point at which F has a local minimum is returned as X. The function value at that point is returned in OPTIONS(8). A log of the function values after each cycle is (optionally) returned in FLOG, and a log of the points visited is (optionally) returned in POINTLOG.

CONJGRAD(F, X, OPTIONS, GRADF, P1, P2, ...) allows additional arguments to be passed to F() and GRADF().

The optional parameters have the following interpretations.

OPTIONS(1) is set to 1 to display error values; also logs error values in the return argument ERRLOG, and the points visited in the return argument POINTSLOG. If OPTIONS(1) is set to 0, then only warning messages are displayed. If OPTIONS(1) is -1, then nothing is displayed.

OPTIONS(2) is a measure of the absolute precision required for the value of X at the solution. If the absolute difference between the values of X between two successive steps is less than OPTIONS(2), then this condition is satisfied.

OPTIONS(3) is a measure of the precision required of the objective function at the solution. If the absolute difference between the objective function values between two successive steps is less than OPTIONS(3), then this condition is satisfied. Both this and the previous condition must be satisfied for termination.

OPTIONS(9) is set to 1 to check the user defined gradient function.

OPTIONS(10) returns the total number of function evaluations (including those in any line searches).

(34)

OPTIONS(11) returns the total number of gradient evaluations.

OPTIONS(14) is the maximum number of iterations; default 100.

OPTIONS(15) is the precision in parameter space of the line search;

default 1E-4.