.. _sec_autograd:
Sự khác biệt tự động
====================
Như chúng tôi đã giải thích trong :numref:`sec_calculus`, sự khác biệt
là một bước quan trọng trong gần như tất cả các thuật toán tối ưu hóa
học tập sâu. Trong khi các tính toán để lấy các dẫn xuất này rất đơn
giản, chỉ đòi hỏi một số phép tính cơ bản, đối với các mô hình phức tạp,
làm việc các bản cập nhật bằng tay có thể là một nỗi đau (và thường dễ
bị lỗi).
Các khung học sâu đẩy nhanh công việc này bằng cách tự động tính toán
các dẫn xuất, tức là *phân biệt tự động*. Trong thực tế, dựa trên mô
hình được thiết kế của chúng tôi, hệ thống xây dựng một biểu đồ tính
toán *, theo dõi dữ liệu kết hợp thông qua đó các hoạt động để tạo ra
đầu ra. Sự khác biệt tự động cho phép hệ thống để sau đó backpropagate
gradients. Ở đây, * backpropagate\* chỉ đơn giản là có nghĩa là theo dõi
thông qua biểu đồ tính toán, điền vào các dẫn xuất từng phần đối với mỗi
tham số.
Một ví dụ đơn giản
------------------
Như một ví dụ đồ chơi, nói rằng chúng ta quan tâm đến phân biệt chức
năng :math:`y = 2\mathbf{x}^{\top}\mathbf{x}` đối với vector cột
:math:`\mathbf{x}`. Để bắt đầu, chúng ta hãy tạo biến ``x`` và gán cho
nó một giá trị ban đầu.
.. 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
# We allocate memory for a tensor's gradient by invoking `attach_grad`
x.attach_grad()
# After we calculate a gradient taken with respect to `x`, we will be able to
# access it via the `grad` attribute, whose values are initialized with 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 # The default value is None
.. raw:: html
.. raw:: html
.. code:: python
x = tf.Variable(x)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
# Place our code inside an `autograd.record` scope to build the computational
# graph
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
# Record all computations onto a 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
[10:57:46] 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 # Overwritten by the newly calculated gradient
.. parsed-literal::
:class: output
array([1., 1., 1., 1.])
.. raw:: html
.. raw:: html
.. code:: python
# PyTorch accumulates the gradient in default, we need to clear the previous
# values
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
# When we invoke `backward` on a vector-valued variable `y` (function of `x`),
# a new scalar variable is created by summing the elements in `y`. Then the
# gradient of that scalar variable with respect to `x` is computed
with autograd.record():
y = x * x # `y` is a vector
y.backward()
x.grad # Equals to y = sum(x * x)
.. parsed-literal::
:class: output
array([0., 2., 4., 6.])
.. raw:: html
.. raw:: html
.. code:: python
# Invoking `backward` on a non-scalar requires passing in a `gradient` argument
# which specifies the gradient of the differentiated function w.r.t `self`.
# In our case, we simply want to sum the partial derivatives, so passing
# in a gradient of ones is appropriate
x.grad.zero_()
y = x * x
# y.backward(torch.ones(len(x))) equivalent to the below
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
# Set `persistent=True` to run `t.gradient` more than once
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