Introdução a PINNs

2 Redes neurais feedforward 2.5 Aproximação de funções 3 Redes informadas pela física

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

2.6 Diferenciação automática

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

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

(2.79)

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

Exemplo 2.6.1.

Seja $f(x)=\operatorname{sen}(\pi x)$ e vamos computar

\displaystyle f^{\prime}(0)=\frac{df}{dx}\Big{|}_{x=0}

(2.80)

por diferenciação automática.

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

A Figura 2.14 mostra o grafo computacional da função $f(x)=\operatorname{sen}(\pi x)$ . A entrada $x$ é propagada formando o grafo de propagação. Ao grafo de propagação, folhas são adicionadas contendo as derivadas de cada operação. Para a computação do gradiente, adicionamos uma variável fictícia $z=y$ e, então, o gradiente $dy/dx=dz/dx$ é computado por retropropagação. A retropropagação é feita da seguinte forma

	$\displaystyle\frac{dy}{dx}\Big{\|}_{x=x_{0}}={\color[rgb]{% 0.05859375,0.46484375,0.71875}\definecolor[named]{pgfstrokecolor}{rgb}{% 0.05859375,0.46484375,0.71875}\frac{dz}{dx}}\Big{\|}_{x=x_{0}}$		(2.81)
	$\displaystyle\text{}\quad={\color[rgb]{0.05859375,0.46484375,0.71875}% \definecolor[named]{pgfstrokecolor}{rgb}{0.05859375,0.46484375,0.71875}\frac{% dz}{du}}\Big{\|}_{x=x_{0}}\frac{du}{dx}\Big{\|}_{x=x_{0}}$		(2.82)
	$\displaystyle\text{}\quad={\color[rgb]{0.05859375,0.46484375,0.71875}% \definecolor[named]{pgfstrokecolor}{rgb}{0.05859375,0.46484375,0.71875}\frac{% dz}{dy}}\Big{\|}_{x=x_{0}}\frac{dy}{du}\Big{\|}_{x=x_{0}}\frac{du}{dx}\Big{\|}_{x% =x_{0}}$		(2.83)
	$\displaystyle\text{}\quad=1\cdot\pi\cdot\cos(\pi x_{0})=\pi\cos(\pi x_{0}).$		(2.84)

O Código 13 contém uma implementação PyTorch da diferenciação automática da função $f(x)=\operatorname{sen}(\pi x)$ para $x\in(0,1/4,1/2,3/4,1)$ . Observe que para a computação do gradiente, a entrada $x$ deve ser marcada com o atributo requires_grad=True. O comando y.backward() computa o gradiente de $y$ em relação a $x$ . O argumento gradient=ones_like(y) é usado para especificar o vetor de gradientes iniciais para a retropropagação. Este é o $dz/dy$ neste exemplo aqui. O gradiente $dy/dx$ é armazenado no atributo x.grad. Ainda, a Figura 2.15 mostra a comparação entre as diferenciações analítica ( $f^{\prime}$ ) e automática (autograd). Observemos que os resultados são idênticos, com diferenças da ordem de $10^{-7}$ , que é a precisão numérica do PyTorch¹⁴¹⁴14Por padrão, o PyTorch usa pontos flutuantes de $32$ -bits, com precisão aproximada de $10^{-}7$ ..

Código 13: ex_autograd.py

⬇

1from torch import tensor, sin, pi, ones_like

3# entrada

4x = tensor([0.,0.25,0.5,0.75,1.])

5x = x.reshape(-1, 1)

6x.requires_grad_(True)

8# propagação

9y = sin(pi * x)

11# retropropagação (cálculo do gradiente)

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

14# print gradiente

15print('dydx =', x.grad)

dydx = tensor([[ 3.1416e+00],

[ 2.2214e+00],

[-1.3732e-07],

[-2.2214e+00],

[-3.1416e+00]])

O grafo computacional da retropopagação pode ser recuperado no PyTorch com o seguinte código (Código LABEL:cod:ex_mlp_autograd_graph).

Código 14: ex_autograd.py (continuação)

⬇

1def print_backward_graph(node, depth=0, seen=None):

2 seen = set() if seen is None else seen

3 if node is None or node in seen:

4 return

5 seen.add(node)

6 print(" " * depth + type(node).__name__)

7 for parent, _ in node.next_functions:

8 print_backward_graph(parent, depth + 1, seen)

10print_backward_graph(y.grad_fn)

SinBackward0

MulBackward0

AccumulateGrad

Observemos que a computação do gradiente de primeira ordem também acaba por construir um novo grafo. 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 2.6.2.

Vamos computar a segunda derivada da função $f(x)=\operatorname{sen}(\pi x)$ por diferenciação automática. O primeiro passo é propagar a entrada $x$ pela função $f$ , obtendo-se $y=f(x)$ . Em seguida, computamos o gradiente de primeira ordem $dy/dx$ por retropropagação. O gradiente de segunda ordem $d^{2}y/dx^{2}$ é computado propagando-se o gradiente de primeira ordem $dy/dx$ pelo grafo computacional da retropropagação, obtendo-se $d^{2}y/dx^{2}$ .

O Código 15 contém uma implementação PyTorch da diferenciação automática de segunda ordem dessa função para $x\in(0,1/4,1/2,3/4,1)$ . A Figura 2.16 mostra a comparação entre as diferenciações analítica ( $f^{\prime}$ , $f^{\prime\prime}$ ) e automática (dydx, d2ydx2). Observemos que os resultados são idênticos, com diferenças na ordem da precisão computacional do PyTorch, que é da ordem de $10^{-7}$ . Verifique!

Código 15: ex_autograd_d2f1d.py

⬇

1from torch import tensor, sin, pi, ones_like

2from torch.autograd import grad

4# entrada

5x = tensor([0.,0.25,0.5,0.75,1.])

6x = x.reshape(-1, 1)

7x.requires_grad_(True)

9# propagação

10y = sin(pi * x)

12# retropropagação y (gradiente de primeira ordem)

13dydx = grad(y, x, grad_outputs=ones_like(y),

14 create_graph=True)[0]

16# propagação dydx (gradiente de segunda ordem)

17d2ydx2 = grad(dydx, x, grad_outputs=ones_like(dydx),

18 create_graph=True)[0]

20# print gradiente

21print('d2ydx2 =', d2ydx2)

d2ydx2 = tensor([[-0.0000e+00],

[-6.9789e+00],

[-9.8696e+00],

[-6.9789e+00],

[ 8.6283e-07]], grad_fn=<MulBackward0>)

2.6.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¹⁵¹⁵15Para mais detalhes, consulte a Subseção LABEL:cap_rede_feedforward_sec_modelo:ssec:treinamento.:

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¹⁶¹⁶16Medida 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 as aproximações das derivadas de primeira e segunda ordem de uma MLP na aproximação de uma função.

Exemplo 2.6.3.

Na Subseção 2.5.2, criamos uma MLP para aproximar a função $f(x)=\operatorname{sen}(\pi x)$ para $x\in[-1,1]$ . Aqui, vamos computar as derivadas de primeira e segunda ordem da MLP por diferenciação automática e comparar com as derivadas analíticas da função $f(x)=\operatorname{sen}(\pi x)$ , que são

	$\displaystyle f^{\prime}(x)=\pi\cos(\pi x),$		(2.85)
	$\displaystyle f^{\prime\prime}(x)=-\pi^{2}\operatorname{sen}(\pi x).$		(2.86)

Antes de computarmos os gradientes da MLP, voltemos ao Código 11 para adicionarmos uma linha de código ao final do treinamento da MLP, que armazena o modelo treinado em um arquivo. A linha de código é

⬇

1torch.save(model, 'modelo.pt')

Armazenado o modelo treinado, podemos carregá-lo em outro código para computarmos os gradientes de primeira e segunda ordem da MLP. O Código 16 contém uma implementação PyTorch da diferenciação automática da MLP para alguns valores de $x\in[-1,1]$ . A Figura 2.17 mostra a comparação entre os gradientes analíticos e automáticos de primeira e segunda ordem da MLP. Observemos que as aproximações das derivadas são boas, mas dependem da qualidade da aproximação da função pela MLP e as diferenças aumentam com a ordem da derivada. Verifique!

Código 16: mlp_autograd_apfun1d.py

⬇

1import torch

3# modelo treinado

4model = torch.load('model.pt',

5 weights_only=False).to('cpu')

7# autograd MLP

8X = torch.tensor([-1.,-0.5,0.,0.5,1.]).reshape(-1,1)

9X.requires_grad = True

11Y = model(X)

13# gradiente de primeira ordem

14DYDX = torch.autograd.grad(

15 Y, X,

16 grad_outputs=torch.ones_like(Y),

17 create_graph=True)[0]

19# gradiente de segunda ordem

20D2YDX2 = torch.autograd.grad(

21 DYDX, X,

22 grad_outputs=torch.ones_like(DYDX))[0]

2.6.2 Exercícios

E. 2.6.1.

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

a)

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

$\displaystyle f(x)=x^{2}-2x+1$ para valores $x\in[-2,2]$ .
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, monte os grafos computacionais da propagação e da retropropagação na computação dos gradientes. Compare os valores computados com os valores esperados.

E. 2.6.2.

Para cada função no E.2.6.1, crie uma MLP para aproximar a função e, por diferenciação automática, compute as derivadas de primeira e segunda ordem. Compare os valores computados com os valores esperados.

E. 2.6.3.

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, monte os grafos computacionais da propagação e da retropropagação na computação dos gradientes. Compare os valores computados com os valores esperados.

E. 2.6.4.

Para cada função no E.2.6.3, crie uma MLP para aproximar a função e compute as derivadas $\partial/\partial x$ , $\partial/\partial y$ , $\partial^{2}/\partial x^{2}$ , $\partial^{2}/\partial x\partial y$ e $\partial^{2}/\partial y^{2}$ pela MLP. Compare os valores computados com os valores esperados.

E. 2.6.5.

Para cada função no E.2.6.3, crie uma MLP para aproximar a função e compute o laplacino $\Delta=(\partial^{2}/\partial x^{2}+\partial^{2}/\partial y^{2})$ pela MLP. Compare os valores computados com os valores esperados.

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