Deep Learning para Equações Diferenciais Parciais

2 Perceptron 2.1 Unidade de Processamento 3 Perceptron Multicamadas

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

2.2 Algoritmo de Treinamento

Na seção anterior, desenvolvemos dois modelos de neurônios para problemas diferentes, um de classificação e outro de regressão. Em cada caso, utilizamos algoritmos de treinamento diferentes. Agora, vamos estudar algoritmos de treinamentos mais gerais⁷⁷endnote: ⁷Aqui, vamos explorar apenas algoritmos de treinamento supervisionado., que podem ser aplicados a ambos os problemas.

Ao longo da seção, vamos considerar o modelo de neurônio

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\tilde{y}=% \mathcal{N}\left(\boldsymbol{x};(\boldsymbol{w},b)\right)=f\underbrace{(% \boldsymbol{w}\cdot\boldsymbol{x}+b)}_{z},

(2.23)

com dada função de ativação $f:\mathbb{R}\to\mathbb{R}$ , sendo os vetores de entrada $\boldsymbol{x}$ e dos pesos $\boldsymbol{w}$ de tamanho $n_{in}$ . A pré-ativação do neurônio é denotada por

z:=\boldsymbol{w}\cdot\boldsymbol{x}+b

(2.24)

Fornecido um conjunto de treinamento $\left\{\left(\boldsymbol{x}^{(s)},y^{(s)}\right)\right\}_{1}^{n_{s}}$ , com $n_{s}$ amostras, o objetivo é calcular os parâmetros $(\boldsymbol{w},b)$ que minimizam a função erro quadrático médio

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

onde $\tilde{y}^{(s)}=\mathcal{N}\left(\boldsymbol{x}^{(s)};(\boldsymbol{w},b)\right)$ é o valor estimado pelo modelo e $y^{(s)}$ é o valor esperado para a $s$ -ésima amostra. A função erro para a $s$ -ésima amostra é

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

(2.27)

Ou seja, o treinamento consiste em resolver o seguinte problema de otimização

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\min_{(% \boldsymbol{w},b)}\varepsilon(\boldsymbol{w},b)

(2.28)

Para resolver este problema de otimização, vamos empregar o Método do Gradiente Descendente.

2.2.1 Método do Gradiente Descendente

O Método do Gradiente Descendente (GD, em inglês, Gradiente Descent Method) é um método de declive. Aplicado ao nosso modelo de Perceptron consiste no seguinte algoritmo:

1.

$(\boldsymbol{w},b)$ aproximação inicial.
2.
Para $e\leftarrow 1,\dotsc,n_{e}$ :
1. (a)
  
  $\displaystyle(\boldsymbol{w},b)\leftarrow(\boldsymbol{w},b)-l_{r}\frac{% \partial\varepsilon}{\partial(\boldsymbol{w},b)}$

onde, $n_{e}$ é o número de épocas, $l_{r}$ é uma dada taxa de aprendizagem ( $l_{r}$ , do inglês, learning rate) e o gradiente é

\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\frac{% \partial\varepsilon}{\partial(\boldsymbol{w},b)}:=\left(\frac{\partial% \varepsilon}{\partial w_{1}},\dotsc,\frac{\partial\varepsilon}{\partial w_{n_{% in}}},\frac{\partial\varepsilon}{\partial b}\right)

(2.29)

O cálculo do gradiente para os pesos $\boldsymbol{w}$ pode ser feito como segue⁸⁸endnote: ⁸Aqui, há um abuso de linguagem ao não se observar as dimensões dos operandos matriciais.

$\displaystyle\frac{\partial\varepsilon}{\partial\boldsymbol{w}}$	$\displaystyle=\frac{\partial}{\partial\boldsymbol{w}}\left[\frac{1}{n_{s}}\sum% _{s=1}^{n_{s}}\varepsilon^{(s)}\right]$	(2.30)
	$\displaystyle=\frac{1}{ns}\sum_{s=1}^{ns}\frac{\partial\varepsilon^{(s)}}{% \partial\tilde{y}^{(s)}}\frac{\partial\tilde{y}^{(s)}}{\partial\boldsymbol{w}}$	(2.31)
$\displaystyle{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1% }\frac{\partial\varepsilon}{\partial\boldsymbol{w}}}$	$\displaystyle{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1% }=\frac{1}{ns}\sum_{s=1}^{ns}\frac{\partial\varepsilon^{(s)}}{\partial\tilde{y% }^{(s)}}\frac{\partial\tilde{y}^{(s)}}{\partial z^{(s)}}\frac{\partial z^{(s)}% }{\partial\boldsymbol{w}}}$	(2.32)

Observando que

	$\displaystyle\frac{\partial\varepsilon^{(s)}}{\partial\tilde{y}^{(s)}}=2\left(% \tilde{y}^{(s)}-y^{(s)}\right)$		(2.33)
	$\displaystyle\frac{\partial\tilde{y}^{(s)}}{\partial z^{(s)}}=f^{\prime}\left(% z^{(s)}\right)$		(2.34)
	$\displaystyle\frac{\partial z^{(s)}}{\partial\boldsymbol{w}}=\boldsymbol{x}^{(% s)}$		(2.35)

obtemos

\frac{\partial\varepsilon}{\partial\boldsymbol{w}}=\frac{1}{n_{s}}\sum_{s=1}^{% n_{s}}2\left(\tilde{y}^{(s)}-y^{(s)}\right)f^{\prime}\left(z^{(s)}\right)% \boldsymbol{x}^{(s)}

(2.36)

	$\displaystyle{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1% }\frac{\partial\varepsilon}{\partial b}}$	$\displaystyle{\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1% }=\frac{1}{ns}\sum_{s=1}^{ns}\frac{\partial\varepsilon^{(s)}}{\partial\tilde{y% }^{(s)}}\frac{\partial\tilde{y}^{(s)}}{\partial z^{(s)}}\frac{\partial z^{(s)}% }{\partial b}}$		(2.37)
	$\displaystyle\frac{\partial\varepsilon}{\partial b}$	$\displaystyle=\frac{1}{n_{s}}\sum_{s=1}^{n_{s}}2\left(\tilde{y}^{(s)}-y^{(s)}% \right)f^{\prime}\left(z^{(s)}\right)\cdot 1$		(2.38)

Aplicação: Problema de Classificação

Na Subseção 2.1.1, treinamos um perceptron para o problema de classificação do e-lógico. A função de ativação $f(x)=\operatorname{sign}(x)$ não é adequada para a aplicação do Método GD, pois $f^{\prime}(x)\equiv 0$ para $x\neq 0$ . Aqui, vamos usar

f(x)=\tanh(x).

(2.39)

Código 4: perceptron_gd.py

⬇

1import torch

3# modelo

5class Perceptron(torch.nn.Module):

6 def __init__(self):

7 super().__init__()

8 self.linear = torch.nn.Linear(2,1)

10 def forward(self, x):

11 z = self.linear(x)

12 y = torch.tanh(z)

13 return y

15model = Perceptron()

17# treinamento

19## optimizador

20optim = torch.optim.SGD(model.parameters(), lr=5e-1)

22## função erro

23loss_fun = torch.nn.MSELoss()

25## dados de treinamento

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

27 [1., -1.],

28 [-1., 1.],

29 [-1., -1.]])

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

32print("\nDados de treinamento")

33print("X_train =")

34print(X_train)

35print("y_train = ")

36print(y_train)

38## num max épocas

39nepochs = 1000

40tol = 1e-3

42for epoch in range(nepochs):

44 # forward

45 y_est = model(X_train)

47 # erro

48 loss = loss_fun(y_est, y_train)

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

52 # critério de parada

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

54 break

56 # backward

57 optim.zero_grad()

58 loss.backward()

59 optim.step()

62# verificação

63y = model(X_train)

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

2.2.2 Método do Gradiente Estocástico

O Método do Gradiente Estocástico (SGD, do inglês, Stochastic Gradient Descent Method) é um variação do Método GD. A ideia é atualizar os parâmetros do modelo com base no gradiente do erro de cada amostra (ou um subconjunto de amostras⁹⁹endnote: ⁹Nest caso, é conhecido como Batch SGD.). A estocasticidade é obtida da randomização com que as amostras são escolhidas a cada época. O algoritmos consiste no seguinte:

1.

w, b aproximações inicial.
2.
Para $e\leftarrow 1,\dotsc,n_{e}$ :
1. 1.1.
  
  Para $s\leftarrow\texttt{random}(1,\dotsc,n_{s})$ :
  
  $(\boldsymbol{w},b)\leftarrow(\boldsymbol{w},b)-l_{r}\frac{\partial\varepsilon^% {(s)}}{\partial(\boldsymbol{w},b)}$ (2.40)

Aplicação: Problema de Classificação

Código 5: perceptron_sgd.py

⬇

1import torch

2import numpy as np

4# modelo

6class Perceptron(torch.nn.Module):

7 def __init__(self):

8 super().__init__()

9 self.linear = torch.nn.Linear(2,1)

11 def forward(self, x):

12 z = self.linear(x)

13 y = torch.tanh(z)

14 return y

16model = Perceptron()

18# treinamento

20## optimizador

21optim = torch.optim.SGD(model.parameters(), lr=5e-1)

23## função erro

24loss_fun = torch.nn.MSELoss()

26## dados de treinamento

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

28 [1., -1.],

29 [-1., 1.],

30 [-1., -1.]])

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

33## num de amostras

34ns = y_train.size(0)

36print("\nDados de treinamento")

37print("X_train =")

38print(X_train)

39print("y_train = ")

40print(y_train)

42## num max épocas

43nepochs = 5000

44tol = 1e-3

46for epoch in range(nepochs):

48 # forward

49 y_est = model(X_train)

51 # erro

52 loss = loss_fun(y_est, y_train)

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

56 # critério de parada

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

58 break

60 # backward

61 for s in torch.randperm(ns):

62 loss_s = (y_est[s,:] - y_train[s,:])**2

63 optim.zero_grad()

64 loss_s.backward()

65 optim.step()

66 y_est = model(X_train)

69# verificação

70y = model(X_train)

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

2.2.3 Exercícios

E. 2.2.1.

Calcule a derivada da função de ativação

f(x)=\tanh(x).

(2.41)

$(\tanh x)^{\prime}=1-\tanh^{2}x$

E. 2.2.2.

Crie um perceptron para emular a operação lógica $\land$ (e-lógico). No treinamento, use como otimizador:

a)

Método GD.
b)

Método SGD.

E. 2.2.3.

Crie um perceptron para emular a operação lógica $\lor$ (ou-lógico). No treinamento, use como otimizador:

a)

Método GD.
b)

Método SGD.

E. 2.2.4.

Crie um perceptron que se ajuste ao seguinte conjunto de dados:

s	$x^{(s)}$	$y^{(s)}$
1	0.5	1.2
2	1.0	2.1
3	1.5	2.6
4	2.0	3.6

No treinamento, use como otimizador:

a)

Método GD.
b)

Método SGD.

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

Política de uso de dados

Deep Learning para Equações Diferenciais Parciais

2.2 Algoritmo de Treinamento

2.2.1 Método do Gradiente Descendente

Aplicação: Problema de Classificação

2.2.2 Método do Gradiente Estocástico

Aplicação: Problema de Classificação

2.2.3 Exercícios

E. 2.2.1.

E. 2.2.2.

E. 2.2.3.

E. 2.2.4.

Envie seu comentário