Colabore! Saiba mais screen_rotation

Ao navegar por este site , você concorda com a Política de Uso de Dados.

| | | | |

3 Perceptron Multicamadas 3.3 Aplicação: Aproximação de Funções 4 Redes Informadas pela Física

3.4 Diferenciação Automática

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

Diferenciação automática é um conjunto de técnicas para a computação de derivadas numéricas em um programa de computador. Explora-se o fato de que um programa computacional executa uma sequência de operações aritméticas e funções elementares, podendo-se computar a derivada por aplicações da regra da cadeia.

PyTorch computa o gradiente (derivada) de uma função $f:\mathbb{R}^{n}\to\mathbb{R}$ a partir de seu grafo computacional. Os gradientes são computados por retropropagação. Por exemplo, para a computação do gradiente

\nabla_{\boldsymbol{x}}f(\boldsymbol{x_{0}})=\left.\frac{df}{d\boldsymbol{x}}% \right|_{\boldsymbol{x}=\boldsymbol{x_{0}}},

(3.19)

primeiramente, propaga-se a entrada $\boldsymbol{x_{0}}$ pela função computacional $f$ , obtendo-se $y=f(\boldsymbol{x_{0}})$ . Então, o gradiente é computado por retropropagação.

Exemplo 3.4.1.

Consideramos a função $f(x)=\operatorname{sen}(\pi x)$ e vamos computar

f^{\prime}(x_{0})=\left.\frac{df}{dx}\right|_{x=0}

(3.20)

por diferenciação automática.

Antes, observamos que, pela regra da cadeia, denotamos $u=\pi x$ e calculamos

$\displaystyle\frac{df}{dx}$	$\displaystyle={\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{% 0,0,1}\pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\frac{d}% {du}\operatorname{sen}(u)}\cdot{\color[rgb]{1,0,0}\definecolor[named]{% pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{0}% \pgfsys@color@rgb@fill{1}{0}{0}\frac{du}{dx}}$	(3.21)
	$\displaystyle={\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{% 0,0,1}\pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\cos(u)}% \cdot{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}% \pgfsys@color@rgb@stroke{1}{0}{0}\pgfsys@color@rgb@fill{1}{0}{0}\pi}$	(3.22)
	$\displaystyle=\pi\cos(\pi x)$	(3.23)

Refer to caption — Figura 3.6: Grafo computacional da diferenciação automática de $f(x)=\operatorname{sen}(\pi x)$ .

Agora, observamos que a computação de $f(x)$ pode ser representada pelo grafo de propagação mostrado na Figura 3.6. Para a computação do gradiente, adicionamos uma variável fictícia $z=y$ . Na retropropagação, computamos

	$\displaystyle\boldsymbol{a.}\leavevmode\nobreak\ \frac{dz}{dy}=1$		(3.24a)
	$\displaystyle\boldsymbol{b.}\leavevmode\nobreak\ \frac{dz}{du}={\color[rgb]{% 0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\pgfsys@color@rgb@stroke{% 0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\frac{dy}{du}}{\color[rgb]{1,0,0}% \definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{% 0}\pgfsys@color@rgb@fill{1}{0}{0}\frac{dz}{dy}}$
	$\displaystyle\qquad\;\,={\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}% {rgb}{0,0,1}\pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}% \frac{d}{du}\left[\operatorname{sen}(u)\right]}\cdot{\color[rgb]{1,0,0}% \definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{% 0}\pgfsys@color@rgb@fill{1}{0}{0}1}$
	$\displaystyle\qquad\;\,=\cos(u)$		(3.24b)
	$\displaystyle\boldsymbol{c.}\leavevmode\nobreak\ \frac{dz}{dx}={\color[rgb]{% 0,0,1}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,1}\pgfsys@color@rgb@stroke{% 0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}\frac{du}{dx}}{\color[rgb]{1,0,0}% \definecolor[named]{pgfstrokecolor}{rgb}{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{% 0}\pgfsys@color@rgb@fill{1}{0}{0}\frac{dz}{du}}$		(3.24c)
	$\displaystyle\qquad\;\,={\color[rgb]{0,0,1}\definecolor[named]{pgfstrokecolor}% {rgb}{0,0,1}\pgfsys@color@rgb@stroke{0}{0}{1}\pgfsys@color@rgb@fill{0}{0}{1}% \frac{d}{dx}[\pi x]}{\color[rgb]{1,0,0}\definecolor[named]{pgfstrokecolor}{rgb% }{1,0,0}\pgfsys@color@rgb@stroke{1}{0}{0}\pgfsys@color@rgb@fill{1}{0}{0}\cos(u)}$		(3.24d)
	$\displaystyle\qquad\;\,=\pi\cos(\pi x)=\frac{dy}{dx}.$		(3.24e)

Código 10: mlp_autograd_df1d

⬇

1import torch

3# input

4x = torch.linspace(-1., 1., steps=50).reshape(-1,1)

5# requires grad

6x.requires_grad = True

8# output

9y = torch.sin(torch.pi*x)

11# compute gradients

12y.backward(gradient=torch.ones_like(y))

14# dy/dx

15dydx = x.grad

A computação do gradiente também acaba por construir um novo grafo (consulte Figura 3.6). Este, por sua vez, pode ser usado para a computação da diferenciação automática de segunda ordem, i.e. para a derivação de segunda ordem.

Exemplo 3.4.2.

Consideramos a função $y=\operatorname{sen}(\pi x)$ . No exemplo anterior, computamos $dy/dx=\pi\cos(\pi x)$ por diferenciação automática. No Código 10, os gradientes foram computados com o comando

⬇

1y.backward(gradient=torch.ones_like(y))

2dudx = x.grad

Alternativamente, podemos usar

⬇

1dydx = torch.autograd.grad(

2 y, x,

3 grad_outputs=torch.ones_like(y),

4 retain_graph=True,

5 create_graph=True)[0]

Este comando computa $dy/dx$ , mas avisa o PyTorch que os grafos computacionais sejam mantidos e que um novo grafo seja gerado da retropropagação. Com isso, podemos computar o gradiente do gradiente, como no código abaixo.

Código 11: mlp_autograd_d2f1d

⬇

1import torch

3# input

4x = torch.linspace(-1., 1., steps=50).reshape(-1,1)

5# requires grad

6x.requires_grad = True

8# output

9y = torch.sin(torch.pi*x)

11# compute gradients

12dydx = torch.autograd.grad(

13 y, x,

14 grad_outputs=torch.ones_like(y),

15 retain_graph=True,

16 create_graph=True)[0]

18d2ydx2 = torch.autograd.grad(

19 dydx, x,

20 grad_outputs=torch.ones_like(dydx))[0]

3.4.1 Autograd MLP

Os conceitos de diferenciação automática (autograd) são diretamente estendidos para redes do tipo Perceptron Multicamadas (MLP, do inglês, Multilayer Perceptron). Uma MLP é uma composição de funções definidas por parâmetros (pesos e biases). Seu treinamento ocorre em duas etapas⁹⁹endnote: ⁹Para mais detalhes, consulte a Subseção 3.1.1.:

1.

Propagação (forward): os dados de entrada são propagados para todas as funções da rede, produzindo a saída estimada.
2.

Retropropagação (backward): a computação do gradiente do erro¹⁰¹⁰endnote: ¹⁰Medida da diferença entre o valor estimado e o valor esperado. em relação aos parâmetros da rede é realizado coletando as derivadas (gradientes) das funções da rede. Pela regra da cadeia, essa coleta é feita a partir da camada de saída em direção a camada de entrada da rede.

No seguinte exemplo, exploramos o fato de MLPs serem aproximadoras universais e avaliamos a derivada de uma MLP na aproximação de uma função.

Exemplo 3.4.3.

Vamos criar uma MLP

\tilde{y}=\mathcal{N}\left(x;\left(W^{(l)},\boldsymbol{b}^{(l)},f^{(l)}\right)% _{l=1}^{n}\right),

(3.25)

que aproxima a função

y=\operatorname{sen}(\pi x),\leavevmode\nobreak\ x\in[-1,1].

(3.26)

Em seguida, computamos, por diferenciação automática, o gradiente

\frac{d\tilde{y}}{dx}=\nabla_{x}\mathcal{N}(x)

(3.27)

e comparamos com o resultado esperado

\frac{dy}{dx}=\pi\cos(\pi x).

(3.28)

Código 12: mlp_autograd_apfun1d.py

⬇

1import torch

2from torch import nn

3from torch import autograd

5# modelo

7model = torch.nn.Sequential()

8model.add_module('layer_1', torch.nn.Linear(1,25))

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

10model.add_module('layer_2', torch.nn.Linear(25,25))

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

12model.add_module('layer_3', torch.nn.Linear(25,1))

14# treinamento

16## fun obj

17fun = lambda x: torch.sin(torch.pi*x)

18a = -1.

19b = 1.

21## optimizador

22optim = torch.optim.SGD(model.parameters(),

23 lr=1e-1, momentum=0.9)

25## num de amostras por época

26ns = 100

27## num max épocas

28nepochs = 5000

29## tolerância

30tol = 1e-5

32## amostras de validação

33X_val = torch.linspace(a, b, steps=100).reshape(-1,1)

34y_vest = fun(X_val)

36for epoch in range(nepochs):

38 # amostras

39 X_train = (a - b) * torch.rand((ns,1)) + b

40 y_train = fun(X_train)

42 # forward

43 y_est = model(X_train)

45 # erro

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

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

50 # backward

51 optim.zero_grad()

52 loss.backward()

53 optim.step()

55 # validação

56 y_val = model(X_val)

57 loss_val = torch.mean((y_val - y_vest)**2)

58 print(f"\tloss_val = {loss_val.item():.4e}")

60 # critério de parada

61 if (loss_val.item() < tol):

62 break

64# autograd MLP

65X_val.requires_grad = True

66# forward

67y_val = model(X_val)

68# gradient

69dydx = autograd.grad(

70 y_val, X_val,

71 grad_outputs=torch.ones_like(y_val))[0]

3.4.2 Exercícios

E. 3.4.1.

Por diferenciação automática, compute o gradiente (a derivada) das seguintes funções

a)

$\displaystyle f(x)=x^{2}-2x+1$ para valores $x\in[-2,2]$ .
b)

$\displaystyle g(x)=\cos^{2}(x)$ para valores $x\in[0,2\pi]$ .
c)

$\displaystyle h(x)=\ln(x-1)$ para valores $x\in(-1,2]$ .
d)

$\displaystyle u(t)=e^{-t^{2}}\operatorname{sen}(t)$ para valores $t\in[-\pi,\pi]$ .

Em cada caso, compare os valores computados com os valores esperados.

E. 3.4.2.

Em cada item do Exercício 3.4.1, faça um fluxograma dos grafos computacionais da propagação e da retropropagação na computação dos gradientes.

E. 3.4.3.

Em cada item do Exercício 3.4.1, compute a derivada de segunda ordem da função indicada. Compare os valores computados com os valores esperados.

E. 3.4.4.

Por diferenciação automática, compute os gradientes das seguintes funções:

a)

$\displaystyle f(x,y)=x^{2}+y^{2}$ para valores $(x,y)\in[-1,1]^{2}$ .
b)

$\displaystyle g(x,y)=e^{x}\operatorname{sen}(xy)$ para valores $(x,y)\in(-1,2)\times(0,\pi)$ .

Em cada caso, compare os valores computados com os valores esperados.

E. 3.4.5.

Para as funções de cada item do Exercício 3.4.6, compute:

a)

$\displaystyle\frac{\partial^{2}}{\partial x^{2}}$ .
b)

$\displaystyle\frac{\partial^{2}}{\partial x\partial y}$ .
c)

$\displaystyle\frac{\partial^{2}}{\partial y^{2}}$ .

Compare os valores computados com os valores esperados.

E. 3.4.6.

Em cada item do Exercício 3.4.6, compute o laplacino $\Delta=\left(\frac{\partial^{2}}{\partial x^{2}}+\frac{\partial^{2}}{\partial y% ^{2}}\right)$ da função indicada. Compare os valores computados com os valores esperados.

E. 3.4.7.

Seja a função $\boldsymbol{f}:\mathbb{R}^{2}\to\mathbb{R}^{2}$ definida por

\boldsymbol{f}(x,y)=\begin{bmatrix}xy^{2}-x^{2}y+6\\ x+x^{2}y^{3}-7\end{bmatrix}

(3.29)

no domínio $\mathcal{D}=[-1,2]\times[1,3]$ . Por diferenciação automática e para valores no domínio da função, compute:

a)

$\displaystyle\nabla f_{1}(x,y)$ .
b)

$\displaystyle\nabla f_{2}(x,y)$ .
c)

$\displaystyle\frac{\partial^{2}f_{1}}{\partial x^{2}}$ .
d)

$\displaystyle\frac{\partial^{2}f_{1}}{\partial x\partial y}$ .
e)

$\displaystyle\frac{\partial^{2}f_{1}}{\partial y^{2}}$ .
f)

$\displaystyle\frac{\partial^{2}f_{2}}{\partial x^{2}}$ .
g)

$\displaystyle\frac{\partial^{2}f_{2}}{\partial x\partial y}$ .
h)

$\displaystyle\frac{\partial^{2}f_{2}}{\partial y^{2}}$ .

Envie seu comentário

As informações preenchidas são enviadas por e-mail para o desenvolvedor do site e tratadas de forma privada. Consulte a Política de Uso de Dados para mais informações. Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

| | | |