Introdução a PINNs

2 Redes neurais feedforward 2.2 Treinamento por retropropagação 2.4 Funções de ativação

Ajude a manter o site livre, gratuito e sem propagandas. Colabore!

2.3 Rede perceptron multicamadas

Uma rede perceptron multicamadas (MLP, do inglês, multilayer perceptron) é um modelo de rede neural feedforward formada por composições de camadas de perceptrons. A Figura 2.6 contém um esquema de uma MLP. Observemos que a rede é formada por uma camada de entrada, $n_{h}$ camadas escondidas e uma camada de saída. Cada camada é formada por um conjunto de neurônios, cada um com sua própria função de ativação. A saída da rede é calculada por composições das camadas, i.e. a saída da primeira camada é a entrada da segunda camada, e assim sucessivamente.

Refer to caption — Figura 2.6: Arquitetura de uma rede do tipo perceptron multicamadas (MLP).

Denotamos uma MLP de $n_{l}$ camadas por

\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \bm{y}=\mathcal{N}(\bm{x};\bm{\theta}),

(2.47)

onde $\bm{\theta}$ são os parâmetros do modelo, sendo $\bm{\theta}_{l}=\left(W^{(l)},\bm{b}^{(l)}\right)$ os parâmetros (pesos $W^{(l)}$ matriz de $n_{n}^{(l-1)}\times n_{n}^{(l)}$ números reais e biases $\bm{b}^{(l)}$ vetor de $n_{n}^{(l)}$ números reais) da camada $l=1,2,\ldots,n_{h}+1$ , onde $n_{h}$ denota o número de camadas escondidas. É assumido conhecidos a priori o número de entradas $n_{I}$ , o número de neurônios de cada camada escondida $n_{n}^{(l)}$ , o número de camadas escondidas $n_{h}$ e o número de saídas $n_{O}$ . Também, são conhecidos a priori as funções de ativação de cada camada $\bm{a}^{(l)}=\bm{\varphi}^{(l)}\left(\bm{z}^{(l)}\right)$ , onde $\bm{z}^{(l)}$ é a pré-ativação da camada $l$ , i.e.,

\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \bm{z}^{(l)}=W^{(l)}\bm{a}^{(l-1)}+\bm{b}^{(l)},

(2.48)

para $l=1,2,\ldots,n_{h}+1$ , denotando a entrada por $\bm{x}=:\bm{a}^{(0)}$ e a saída por $\bm{y}=:\bm{a}^{(n_{h}+1)}$ .

De forma mais precisa, o cálculo da inferência de uma entrada $\bm{x}$ na rede é feito por iteradas composições das camadas, i.e., a saída da rede é calculada pela iteração

\displaystyle\bm{a}^{(l)}=\bm{\varphi}^{(l)}\underbrace{\left(W^{(l)}\bm{a}^{(% l-1)}+\bm{b}^{(l)}\right)}_{\bm{z}^{(l)}},

(2.49)

para $l=1,2,\dotsc,n_{h}+1$ , lembrando que a entrada $\bm{x}=:\bm{a}^{(0)}$ é vetor de $n_{I}$ números reais e $\bm{y}=:\bm{a}^{(n_{h}+1)}$ é vetor de $n_{O}$ números reais.

Exemplo 2.3.1.(Modelo xor)

No E.2.1.5, vimos que não é possível criar um perceptron para emular a operação lógica xor. Por outro lado, esta operação é equivalente a seguinte combinação de operações lógicas

\displaystyle A\texttt{ xor }B=(A\texttt{ or }B)\texttt{ and }\texttt{not}(A% \texttt{ and }B).

(2.50)

Com isso, podemos criar uma MLP com duas entradas, uma camada escondida com dois neurônios e uma camada de saída com um neurônio, como ilustrado na Figura 2.7.

Seguindo esta arquitetura de rede, o Código 5 contém a implementação de uma MLP para emular a operação lógica xor. Verifique! No código, as entradas são representadas por $1$ (verdadeiro) e $-1$ (falso), e a saída da rede é interpretada como verdadeiro se for maior que zero e falso caso contrário. As funções de ativação são funções sinal, i.e. $\varphi(x)=\operatorname{sign}(x)$ . Na primeira camada escondia, o primeiro neurônio emula a operação lógica or e o segundo neurônio emula a operação lógica not and. A saída da rede é a operação lógica and entre as saídas dos dois neurônios da camada escondida.

Código 5: mlp_xor.py

⬇

1from torch import sign, tensor, no_grad

2from torch.nn import (

3 Module, Sequential,

4 Linear, Parameter

5 )

7# função sinal

8class Sign(Module):

9 def forward(self, x):

10 return sign(x)

12# modelo

13model = Sequential()

14model.add_module("layer_1", Linear(2, 2))

15model.add_module("fun_1", Sign())

16model.add_module("layer_2", Linear(2, 1))

17model.add_module("fun_2", Sign())

19# parâmetros

20with no_grad():

21 model.layer_1.weight = Parameter(tensor([[1., 1.],

22 [-1., -1.]]))

23 model.layer_1.bias = Parameter(tensor([1., 1.]))

24 model.layer_2.weight = Parameter(tensor([[1., 1.]]))

25 model.layer_2.bias = Parameter(tensor([-1.]))

27# dados de entrada

28X = tensor([[1., 1.],

29 [1., -1.],

30 [-1., 1.],

31 [-1., -1.]])

33# inferência (propagação)

34y_est = model(X)

35print('Saída:')

36print(y_est)

2.3.1 Treinamento por retropropagação

A ideia do treinamento por retropropagação que estudamos na Seção 2.3.1 para o perceptron, pode ser diretamente estendida para o treinamento de uma MLP. A diferença é que, agora, temos mais parâmetros a serem ajustados e, portanto, mais gradientes a serem calculados.

Vamos assumir uma MLP

\displaystyle\tilde{\bm{y}}=\mathcal{N}(\bm{x};\bm{\theta}),

(2.51)

Para o treinamento da rede, assumimos uma função de perda da forma

\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \varepsilon(\tilde{\bm{\theta}}):=\frac{1}{n_{s}}\sum_{s=1}^{n_{s}}\varepsilon% ^{(s)}\left(\bm{\theta},\tilde{\bm{y}}^{(s)}(\bm{\theta})\right)

(2.52)

onde $\varepsilon^{(s)}:\mathbb{R}^{n_{\theta}}\to\mathbb{R}$ , $\varepsilon^{(s)}=\varepsilon^{(s)}(\bm{\theta},\bm{\tilde{\bm{y}}})$ é a função de perda da $s$ -ésima amostra, i.e. uma função dos parâmetros do modelo $\bm{\theta}$ , onde $n_{\theta}$ é o número de parâmetros da rede.

O treinamento da rede consiste em resolver o problema de minimização

\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \operatorname*{arg\,min}_{\bm{\theta}}\varepsilon(\bm{\theta})

(2.53)

Aplicando um método baseado em gradiente, temos o seguinte algoritmo:

1.

$\bm{\theta}$ aproximações iniciais.
2.
Para $e\leftarrow 1,\dotsc,n_{e}$ :
1. (a)
  
  $\displaystyle\bm{\theta}\leftarrow\bm{\theta}-l_{r}\bm{d}\left(\nabla_{\bm{% \theta}}\varepsilon\right)$

onde, $n_{e}$ é o número de épocas, $l_{r}$ é a taxa de aprendizagem e $\bm{d}=\bm{d}\left(\nabla_{\bm{\theta}}\varepsilon\right)$ é o vetor direção da atualização dos parâmetros, com

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \nabla_{\bm{\theta}}\varepsilon:=\left(\frac{\partial\varepsilon}{\partial W},% \frac{\partial\varepsilon}{\partial\bm{b}}\right)$		(2.54)
	$\displaystyle\text{}\quad\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}% {rgb}{0,0,1}=\frac{1}{ns}\sum_{s=1}^{n_{s}}\left(\frac{\partial\varepsilon^{(s% )}}{\partial W},\frac{\partial\varepsilon^{(s)}}{\partial\bm{b}}\right)$		(2.55)

Observação 2.3.1.(Otimizadores)

O método de atualização dos parâmetros da rede pode ser feito por diferentes otimizadores baseados em gradiente. Em acada método há uma forma diferente de calcular o vetor direção $\bm{d}$ , que pode depender do gradiente atual e de gradientes anteriores. Na Seção 2.3.1, estudamos o método do gradiente descendente (GD) e o método do gradiente descendente estocástico (GDE), que são métodos de atualização dos parâmetros da rede com base no gradiente atual. Ambos os métodos podem ser aplicados para o treinamento de uma MLP e mais adiante, vamos estudar outras variantes de otimizadores baseados em gradiente.

O cálculo dos gradientes pode ser feito por retropropagação como uma aplicação da regra da cadeia. Para os pesos da última camada, temos⁸⁸8Com um certo abuso de linguagem devido à álgebra matricial envolvida.

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \frac{\partial\varepsilon^{(s)}}{\partial W^{(n_{h}+1)}}=\frac{\partial% \varepsilon^{(s)}}{\partial\bm{\tilde{y}}}\frac{\partial\bm{\tilde{y}}}{% \partial\bm{z}^{(n_{h}+1)}}\frac{\partial\bm{z}^{(n_{h}+1)}}{\partial W^{(n_{h% }+1)}}$		(2.56)
	$\displaystyle\text{}\quad=\frac{\partial\varepsilon^{(s)}}{\partial\bm{\tilde{% y}}}\left[\bm{\varphi}^{(n_{h}+1)}\right]^{\prime}\left(W^{(n_{h}+1)}\bm{a}^{(% n_{h})}+\bm{b}^{(n_{h}+1)}\right)\bm{a}^{(n_{h})}.$		(2.57)

Para os pesos da penúltima camada, temos

	$\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \frac{\partial\varepsilon^{(s)}}{\partial W^{(n_{h})}}=\frac{\partial% \varepsilon^{(s)}}{\partial\tilde{\bm{y}}}\frac{\partial\tilde{\bm{y}}}{% \partial\bm{z}^{(n_{h}+1)}}\frac{\partial\bm{z}^{(n_{h}+1)}}{\partial W^{(n_{h% })}},$		(2.58)
	$\displaystyle\text{}\quad=\frac{\partial\varepsilon^{(s)}}{\partial\bm{y}}% \left[\bm{\varphi}^{(n_{h}+1)}\right]^{\prime}\left(\bm{z}^{(n_{h}+1)}\right)% \frac{\partial\bm{z}^{(n_{h}+1)}}{\partial\bm{a}^{(n_{h})}}\frac{\partial\bm{a% }^{(n_{h})}}{\partial\bm{z}^{(n_{h})}}\frac{\partial\bm{z}^{(n_{h})}}{\partial W% ^{(n_{h})}}$		(2.59)
	$\displaystyle\text{}\quad=\frac{\partial\varepsilon^{(s)}}{\partial\bm{y}}% \left[\bm{\varphi}^{(n_{h}+1)}\right]^{\prime}\left(\bm{z}^{(n_{h}+1)}\right)W% ^{(n_{h}+1)}\left[\bm{\varphi}^{(n_{h})}\right]^{\prime}\left(\bm{z}^{(n_{h})}% \right)\bm{a}^{(n_{h}-1)}$		(2.60)

e assim, sucessivamente para as demais camadas da rede. Os gradientes em relação aos biases podem ser calculados de forma análoga (consulte o E.2.3.1).

Em todos os casos, notemos que o cálculo do gradiente da função de perda em relação aos parâmetros da rede é feito de forma retroativa, ou seja, a partir da saída da rede e voltando-se para os parâmetros da rede. Ainda, as derivadas envolvidas, usualmente, podem ser calculadas de forma analítica e armazenadas durante a etapa de propagação, evitando-se a repetição de cálculos. Por fim, o cálculo do gradiente da função de perda pode ser feito por um processo de acumulação, tendo em vista que a função de perda é uma soma de funções de perda das amostras.

Exemplo 2.3.2.(Modelo xor com treinamento)

No E.2.3.1, estudamos que é possível criar uma MLP para emular a operação lógica xor. No entanto, os parâmetros da rede foram escolhidos de forma manual. Aqui, vamos criar uma MLP para este mesmo problema, mas agora vamos treinar a rede para ajustar os parâmetros de forma automática.

Vamos assumir uma rede com duas entradas, uma camada escondida com dois neurônios e uma camada de saída com um neurônio. Para garantir a diferenciabilidade, vamos assumir que todas as funções de ativação são funções tangente hiperbólica, i.e. $\varphi(x)=\tanh(x)$ . A função de perda é a função erro quadrático médio

\displaystyle\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}% \varepsilon:=\frac{1}{n_{s}}\sum_{s=1}^{n_{s}}\left|\tilde{y}^{(s)}-y^{(s)}% \right|^{2},

(2.61)

onde $\tilde{y}^{(s)}=\mathcal{N}\left(\bm{x}^{(s)}\right)$ são os valores estimados e $\left\{\bm{x}^{(s)},y^{(s)}\right\}_{s=1}^{n_{s}}$ , $n_{s}=4$ , o conjunto de treinamento conforme na Tabela 2.4.

Tabela 2.4: Conjunto de treinamento para a operação lógica xor. Assumindo que

1

representa verdadeiro e

-1

representa falso.

$x_{1}$	$x_{2}$	$y$
$1$	$1$	$-1$
$1$	$-1$	$1$
$-1$	$1$	$1$
$-1$	$-1$	$-1$

O Código 6 contém a implementação do treinamento da MLP com otimizador GD. Verifique!

Código 6: mlp_xor_gd.py

⬇

1import torch

3# modelo

4model = torch.nn.Sequential()

5model.add_module('layer_1', torch.nn.Linear(2,2))

6model.add_module('fun_1', torch.nn.Tanh())

7model.add_module('layer_2', torch.nn.Linear(2,1))

8model.add_module('fun_2', torch.nn.Tanh())

11# treinamento

13# optimizador

14optim = torch.optim.SGD(model.parameters(), lr=0.1)

16# dados de treinamento

17X_train = torch.tensor([[1., 1.],

18 [1., -1.],

19 [-1., 1.],

20 [-1., -1.]])

21y_train = torch.tensor([-1., 1., 1., -1.]).reshape(-1,1)

23print("\nDados de treinamento")

24print("X_train =")

25print(X_train)

26print("y_train = ")

27print(y_train)

29# num max épocas

30nepochs = 500

32# tolerância

33tol = 5e-2

35for epoch in range(nepochs):

37 # propagação

38 y_est = model(X_train)

40 # função erro

41 loss = torch.mean((y_est - y_train)**2)

43 print(f'{epoch}: {loss.item():.4e}')

45 # critério de parada

46 if (loss.item() < tol):

47 break

49 # retropropagação

50 optim.zero_grad()

51 loss.backward()

52 optim.step()

55# verificação

56y = model(X_train)

57print(f'y_est = {y}')

2.3.2 Exercícios

E. 2.3.1.

Para uma MLP com $n_{l}=n_{h}+1$ camadas com função de perda da forma (2.52), calcule os gradientes:

a)

$\displaystyle\frac{\partial\varepsilon^{(s)}}{\partial W^{(1)}}$ .
b)

$\displaystyle\frac{\partial\varepsilon^{(s)}}{\partial\boldsymbol{b}^{(n_{h}+1% )}}$ .
c)

$\displaystyle\frac{\partial\varepsilon^{(s)}}{\partial\bm{b}^{(n_{h})}}$ .
d)

$\displaystyle\frac{\partial\varepsilon^{(s)}}{\partial\bm{b}^{(1)}}$ .

E. 2.3.2.

Faça uma nova versão do Código 6, substituindo as linhas

⬇

1# retropropagação

2optim.zero_grad()

3loss.backward()

4optim.step()

por uma implementação manual, em que os gradientes sejam calculados explicitamente e os parâmetros atualizados manualmente.

E. 2.3.3.

Faça uma nova versão do Código 6, substituindo o otimizador GD pelo otimizador GDE. Faça uma análise comparativa entre os dois métodos de treinamento, considerando o número de épocas e a taxa de aprendizagem.

E. 2.3.4.

No exercício anterior (E.2.3.3), você deve ter observado que ambos os otimizadores GD e GDE podem cair em mínimos locais, dependendo da inicialização dos parâmetros da rede. Modifique seus códigos de forma que eles busquem identificar quando estão presos em mínimos locais e, nesse caso, parem o treinamento.

E. 2.3.5.

No Exemplo 2.3.1, criamos uma MLP para emular a operação lógica xor com base na combinação de operações

\displaystyle A\texttt{ xor }B=(A\texttt{ or }B)\texttt{ and }\texttt{not}(A% \texttt{ and }B).

(2.62)

Esta não é a única forma de combinar as operações lógicas or, and e not para calcular a xor. De fato, observe que o Código 6 treina uma nova MLP a cada execução do código, com diferentes parâmetros iniciais e acaba convergindo para diferentes soluções. Faça a análise das redes treinadas e, através da análise dos parâmetros treinados, descubra que outras combinações de operações lógicas podem ser utilizadas para emular a operação lógica xor.

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Política de uso de dados