.. _sec_autograd:
Diferenciação automática
========================
Como já explicado em :numref:`sec_calculus`, a diferenciação é uma
etapa crucial em quase todos os algoritmos de otimização de *Deep
Learning*. Embora os cálculos para obter esses derivados sejam diretos,
exigindo apenas alguns cálculos básicos, para modelos complexos,
trabalhando as atualizações manualmente pode ser uma tarefa difícil (e
muitas vezes sujeita a erros). *Frameworks* de *Deep learning* aceleram
este trabalho calculando automaticamente as derivadas, ou seja,
*diferenciação automática*. Na prática, com base em nosso modelo
projetado o sistema constrói um *grafo computacional*, rastreando quais
dados combinados por meio de quais operações produzem a saída. A
diferenciação automática permite que o sistema propague gradientes
posteriormente. Aqui, propagar(do Inglês *backpropagate*) significa
simplesmente traçar o gráfico computacional, preencher as derivadas
parciais em relação a cada parâmetro.
Um exemplo simples
------------------
Como exemplo, digamos que estamos interessados em derivar a função
:math:`y = 2\mathbf{x}^{\top}\mathbf{x}` com respeito ao vetor coluna
:math:`\mathbf{x}`. Inicialmente criamos a variável ``x`` e atribuimos a
ela um valor inicial.
.. raw:: html
.. raw:: html
.. code:: python
from mxnet import autograd, np, npx
npx.set_np()
x = np.arange(4.0)
x
.. parsed-literal::
:class: output
array([0., 1., 2., 3.])
.. raw:: html
.. raw:: html
.. code:: python
import torch
x = torch.arange(4.0)
x
.. parsed-literal::
:class: output
tensor([0., 1., 2., 3.])
.. raw:: html
.. raw:: html
.. code:: python
import tensorflow as tf
x = tf.range(4, dtype=tf.float32)
x
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
# Alocamos memória do gradiente do vetor invocando `attach_grad`
x.attach_grad()
# Após calcularmos o gradiente como respeito a `x`, será possível
# acessa-lo vai atributo `grad`, cujo valor inicializará com 0s
x.grad
.. parsed-literal::
:class: output
array([0., 0., 0., 0.])
.. raw:: html
.. raw:: html
.. code:: python
x.requires_grad_(True) # Same as `x = torch.arange(4.0, requires_grad=True)`
x.grad # O valor padrão é None
.. raw:: html
.. raw:: html
.. code:: python
x = tf.Variable(x)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
# Colocaremos o código dentro do escopo `autograd.record` para contruir
# o grafo computacional
with autograd.record():
y = 2 * np.dot(x, x)
y
.. parsed-literal::
:class: output
array(28.)
.. raw:: html
.. raw:: html
.. code:: python
y = 2 * torch.dot(x, x)
y
.. parsed-literal::
:class: output
tensor(28., grad_fn=)
.. raw:: html
.. raw:: html
.. code:: python
# Gravando todos os calculos em um *tape*
with tf.GradientTape() as t:
y = 2 * tf.tensordot(x, x, axes=1)
y
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
y.backward()
x.grad
.. parsed-literal::
:class: output
[03:58:07] src/base.cc:49: GPU context requested, but no GPUs found.
.. parsed-literal::
:class: output
array([ 0., 4., 8., 12.])
.. raw:: html
.. raw:: html
.. code:: python
y.backward()
x.grad
.. parsed-literal::
:class: output
tensor([ 0., 4., 8., 12.])
.. raw:: html
.. raw:: html
.. code:: python
x_grad = t.gradient(y, x)
x_grad
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
x.grad == 4 * x
.. parsed-literal::
:class: output
array([ True, True, True, True])
.. raw:: html
.. raw:: html
.. code:: python
x.grad == 4 * x
.. parsed-literal::
:class: output
tensor([True, True, True, True])
.. raw:: html
.. raw:: html
.. code:: python
x_grad == 4 * x
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
with autograd.record():
y = x.sum()
y.backward()
x.grad # Sobrescrito pelo novo gradiente calculado
.. parsed-literal::
:class: output
array([1., 1., 1., 1.])
.. raw:: html
.. raw:: html
.. code:: python
# O PyTorch acumula os gradientes por padrão, precisamos
# apagar os valores anteriores
x.grad.zero_()
y = x.sum()
y.backward()
x.grad
.. parsed-literal::
:class: output
tensor([1., 1., 1., 1.])
.. raw:: html
.. raw:: html
.. code:: python
with tf.GradientTape() as t:
y = tf.reduce_sum(x)
t.gradient(y, x) # Overwritten by the newly calculated gradient
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
# Quando invocamos `backward` em uma variável de vetor valorado `y` (em função de `x`),
# uma nova variável escalar é criada somando os elementos em `y`. Então o
# gradiente daquela variável escalar em respeito a `x` é computada
with autograd.record():
y = x * x # `y` is a vector
y.backward()
x.grad # Igual a y = sum(x * x)
.. parsed-literal::
:class: output
array([0., 2., 4., 6.])
.. raw:: html
.. raw:: html
.. code:: python
# Invocar `backward` em um não escalar requer passar um argumento `gradient`
# que especifica o gradiente da função diferenciada w.r.t `self`.
# Em nosso caso, simplesmente queremos somar as derivadas parciais, assim passando
# em um gradiente de uns é apropriado
x.grad.zero_()
y = x * x
# y.backward(torch.ones(len(x))) equivalente a:
y.sum().backward()
x.grad
.. parsed-literal::
:class: output
tensor([0., 2., 4., 6.])
.. raw:: html
.. raw:: html
.. code:: python
with tf.GradientTape() as t:
y = x * x
t.gradient(y, x) # Same as `y = tf.reduce_sum(x * x)`
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
with autograd.record():
y = x * x
u = y.detach()
z = u * x
z.backward()
x.grad == u
.. parsed-literal::
:class: output
array([ True, True, True, True])
.. raw:: html
.. raw:: html
.. code:: python
x.grad.zero_()
y = x * x
u = y.detach()
z = u * x
z.sum().backward()
x.grad == u
.. parsed-literal::
:class: output
tensor([True, True, True, True])
.. raw:: html
.. raw:: html
.. code:: python
# Defina `persistent=True` para executar `t.gradient` mais de uma vez
with tf.GradientTape(persistent=True) as t:
y = x * x
u = tf.stop_gradient(y)
z = u * x
x_grad = t.gradient(z, x)
x_grad == u
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
y.backward()
x.grad == 2 * x
.. parsed-literal::
:class: output
array([ True, True, True, True])
.. raw:: html
.. raw:: html
.. code:: python
x.grad.zero_()
y.sum().backward()
x.grad == 2 * x
.. parsed-literal::
:class: output
tensor([True, True, True, True])
.. raw:: html
.. raw:: html
.. code:: python
t.gradient(y, x) == 2 * x
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def f(a):
b = a * 2
while np.linalg.norm(b) < 1000:
b = b * 2
if b.sum() > 0:
c = b
else:
c = 100 * b
return c
.. raw:: html
.. raw:: html
.. code:: python
def f(a):
b = a * 2
while b.norm() < 1000:
b = b * 2
if b.sum() > 0:
c = b
else:
c = 100 * b
return c
.. raw:: html
.. raw:: html
.. code:: python
def f(a):
b = a * 2
while tf.norm(b) < 1000:
b = b * 2
if tf.reduce_sum(b) > 0:
c = b
else:
c = 100 * b
return c
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a = np.random.normal()
a.attach_grad()
with autograd.record():
d = f(a)
d.backward()
.. raw:: html
.. raw:: html
.. code:: python
a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()
.. raw:: html
.. raw:: html
.. code:: python
a = tf.Variable(tf.random.normal(shape=()))
with tf.GradientTape() as t:
d = f(a)
d_grad = t.gradient(d, a)
d_grad
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
a.grad == d / a
.. parsed-literal::
:class: output
array(True)
.. raw:: html
.. raw:: html
.. code:: python
a.grad == d / a
.. parsed-literal::
:class: output
tensor(True)
.. raw:: html
.. raw:: html
.. code:: python
d_grad == d / a
.. parsed-literal::
:class: output
.. raw:: html
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html