.. _sec_linear_scratch:
Linear Regression Implementation from Scratch
=============================================
Agora que você entende as principais ideias por trás da regressão
linear, podemos começar a trabalhar por meio de uma implementação
prática no código. Nesta seção, vamos implementar todo o método do zero,
incluindo o pipeline de dados, o modelo, a função de perda e o
otimizador de descida gradiente estocástico do minibatch. Embora as
estruturas modernas de *deep learning* possam automatizar quase todo
esse trabalho, implementar coisas do zero é a única maneira para ter
certeza de que você realmente sabe o que está fazendo. Além disso,
quando chega a hora de personalizar modelos, definindo nossas próprias
camadas ou funções de perda, entender como as coisas funcionam nos
bastidores será útil. Nesta seção, contaremos apenas com tensores e
diferenciação automática. Posteriormente, apresentaremos uma
implementação mais concisa, aproveitando sinos e assobios de
*frameworks* de *deep learning*.
.. raw:: html
.. raw:: html
.. code:: python
%matplotlib inline
import random
from mxnet import autograd, np, npx
from d2l import mxnet as d2l
npx.set_np()
.. raw:: html
.. raw:: html
.. code:: python
%matplotlib inline
import random
import torch
from d2l import torch as d2l
.. raw:: html
.. raw:: html
.. code:: python
%matplotlib inline
import random
import tensorflow as tf
from d2l import tensorflow as d2l
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def synthetic_data(w, b, num_examples): #@save
"""Generate y = Xw + b + noise."""
X = np.random.normal(0, 1, (num_examples, len(w)))
y = np.dot(X, w) + b
y += np.random.normal(0, 0.01, y.shape)
return X, y.reshape((-1, 1))
true_w = np.array([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
.. raw:: html
.. raw:: html
.. code:: python
def synthetic_data(w, b, num_examples): #@save
"""Generate y = Xw + b + noise."""
X = torch.normal(0, 1, (num_examples, len(w)))
y = torch.matmul(X, w) + b
y += torch.normal(0, 0.01, y.shape)
return X, y.reshape((-1, 1))
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
.. raw:: html
.. raw:: html
.. code:: python
def synthetic_data(w, b, num_examples): #@save
"""Generate y = Xw + b + noise."""
X = tf.zeros((num_examples, w.shape[0]))
X += tf.random.normal(shape=X.shape)
y = tf.matmul(X, tf.reshape(w, (-1, 1))) + b
y += tf.random.normal(shape=y.shape, stddev=0.01)
y = tf.reshape(y, (-1, 1))
return X, y
true_w = tf.constant([2, -3.4])
true_b = 4.2
features, labels = synthetic_data(true_w, true_b, 1000)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
print('features:', features[0],'\nlabel:', labels[0])
.. parsed-literal::
:class: output
features: [2.2122064 1.1630787]
label: [4.662078]
.. raw:: html
.. raw:: html
.. code:: python
print('features:', features[0],'\nlabel:', labels[0])
.. parsed-literal::
:class: output
features: tensor([-0.9563, 1.2447])
label: tensor([-1.9621])
.. raw:: html
.. raw:: html
.. code:: python
print('features:', features[0],'\nlabel:', labels[0])
.. parsed-literal::
:class: output
features: tf.Tensor([1.1301318 0.14684609], shape=(2,), dtype=float32)
label: tf.Tensor([5.960015], shape=(1,), dtype=float32)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
d2l.set_figsize()
# The semicolon is for displaying the plot only
d2l.plt.scatter(features[:, (1)].asnumpy(), labels.asnumpy(), 1);
.. figure:: output_linear-regression-scratch_58de05_39_0.svg
.. raw:: html
.. raw:: html
.. code:: python
d2l.set_figsize()
# The semicolon is for displaying the plot only
d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1);
.. figure:: output_linear-regression-scratch_58de05_42_0.svg
.. raw:: html
.. raw:: html
.. code:: python
d2l.set_figsize()
# The semicolon is for displaying the plot only
d2l.plt.scatter(features[:, (1)].numpy(), labels.numpy(), 1);
.. figure:: output_linear-regression-scratch_58de05_45_0.svg
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def data_iter(batch_size, features, labels):
num_examples = len(features)
indices = list(range(num_examples))
# The examples are read at random, in no particular order
random.shuffle(indices)
for i in range(0, num_examples, batch_size):
batch_indices = np.array(
indices[i: min(i + batch_size, num_examples)])
yield features[batch_indices], labels[batch_indices]
.. raw:: html
.. raw:: html
.. code:: python
def data_iter(batch_size, features, labels):
num_examples = len(features)
indices = list(range(num_examples))
# The examples are read at random, in no particular order
random.shuffle(indices)
for i in range(0, num_examples, batch_size):
batch_indices = torch.tensor(
indices[i: min(i + batch_size, num_examples)])
yield features[batch_indices], labels[batch_indices]
.. raw:: html
.. raw:: html
.. code:: python
def data_iter(batch_size, features, labels):
num_examples = len(features)
indices = list(range(num_examples))
# The examples are read at random, in no particular order
random.shuffle(indices)
for i in range(0, num_examples, batch_size):
j = tf.constant(indices[i: min(i + batch_size, num_examples)])
yield tf.gather(features, j), tf.gather(labels, j)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
.. parsed-literal::
:class: output
[[ 1.0702589 0.22332872]
[ 0.576972 0.8087885 ]
[ 0.10064353 0.64281934]
[ 1.2020247 -2.1224012 ]
[-1.0674467 -0.34258512]
[ 0.20714448 1.0840217 ]
[ 0.90336937 -0.38090217]
[ 0.8332984 1.8107505 ]
[ 1.8917114 -1.1688148 ]
[ 0.59860843 -3.0636313 ]]
[[ 5.5869737 ]
[ 2.5922568 ]
[ 2.215121 ]
[13.813773 ]
[ 3.2241936 ]
[ 0.91169757]
[ 7.301087 ]
[-0.2817729 ]
[11.958657 ]
[15.81957 ]]
.. raw:: html
.. raw:: html
.. code:: python
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
.. parsed-literal::
:class: output
tensor([[-0.0649, 0.4390],
[-0.2518, -0.4019],
[-0.1489, 0.2960],
[ 1.6701, -0.8914],
[ 0.6946, 0.2719],
[-1.4623, 0.5890],
[ 0.1270, 0.7019],
[-1.2410, 0.1549],
[-0.3620, -0.1373],
[-0.2483, -1.6446]])
tensor([[ 2.5737],
[ 5.0419],
[ 2.8981],
[10.5841],
[ 4.6693],
[-0.7264],
[ 2.0609],
[ 1.1768],
[ 3.9539],
[ 9.2774]])
.. raw:: html
.. raw:: html
.. code:: python
batch_size = 10
for X, y in data_iter(batch_size, features, labels):
print(X, '\n', y)
break
.. parsed-literal::
:class: output
tf.Tensor(
[[-0.5730527 0.7819388 ]
[-1.4290377 0.501779 ]
[-1.0716456 -0.3164782 ]
[-0.7258405 0.5719521 ]
[ 1.7161779 -0.6173083 ]
[-1.5024987 1.2860105 ]
[ 0.5211034 -1.16397 ]
[ 0.5002108 -0.70382583]
[ 0.2605837 1.0829461 ]
[ 0.4482001 -0.56022495]], shape=(10, 2), dtype=float32)
tf.Tensor(
[[ 0.38191256]
[-0.36548588]
[ 3.1524463 ]
[ 0.80933195]
[ 9.73811 ]
[-3.1788385 ]
[ 9.195568 ]
[ 7.5800247 ]
[ 1.0323184 ]
[ 7.0033584 ]], shape=(10, 1), dtype=float32)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
w = np.random.normal(0, 0.01, (2, 1))
b = np.zeros(1)
w.attach_grad()
b.attach_grad()
.. raw:: html
.. raw:: html
.. code:: python
w = torch.normal(0, 0.01, size=(2,1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
.. raw:: html
.. raw:: html
.. code:: python
w = tf.Variable(tf.random.normal(shape=(2, 1), mean=0, stddev=0.01),
trainable=True)
b = tf.Variable(tf.zeros(1), trainable=True)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def linreg(X, w, b): #@save
"""The linear regression model."""
return np.dot(X, w) + b
.. raw:: html
.. raw:: html
.. code:: python
def linreg(X, w, b): #@save
"""The linear regression model."""
return torch.matmul(X, w) + b
.. raw:: html
.. raw:: html
.. code:: python
def linreg(X, w, b): #@save
"""The linear regression model."""
return tf.matmul(X, w) + b
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def squared_loss(y_hat, y): #@save
"""Squared loss."""
return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
.. raw:: html
.. raw:: html
.. code:: python
def squared_loss(y_hat, y): #@save
"""Squared loss."""
return (y_hat - y.reshape(y_hat.shape)) ** 2 / 2
.. raw:: html
.. raw:: html
.. code:: python
def squared_loss(y_hat, y): #@save
"""Squared loss."""
return (y_hat - tf.reshape(y, y_hat.shape)) ** 2 / 2
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
def sgd(params, lr, batch_size): #@save
"""Minibatch stochastic gradient descent."""
for param in params:
param[:] = param - lr * param.grad / batch_size
.. raw:: html
.. raw:: html
.. code:: python
def sgd(params, lr, batch_size): #@save
"""Minibatch stochastic gradient descent."""
with torch.no_grad():
for param in params:
param -= lr * param.grad / batch_size
param.grad.zero_()
.. raw:: html
.. raw:: html
.. code:: python
def sgd(params, grads, lr, batch_size): #@save
"""Minibatch stochastic gradient descent."""
for param, grad in zip(params, grads):
param.assign_sub(lr*grad/batch_size)
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss
for epoch in range(num_epochs):
for X, y in data_iter(batch_size, features, labels):
with autograd.record():
l = loss(net(X, w, b), y) # Minibatch loss in `X` and `y`
# Because `l` has a shape (`batch_size`, 1) and is not a scalar
# variable, the elements in `l` are added together to obtain a new
# variable, on which gradients with respect to [`w`, `b`] are computed
l.backward()
sgd([w, b], lr, batch_size) # Update parameters using their gradient
train_l = loss(net(features, w, b), labels)
print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')
.. parsed-literal::
:class: output
[03:59:56] src/base.cc:49: GPU context requested, but no GPUs found.
epoch 1, loss 0.025171
epoch 2, loss 0.000088
epoch 3, loss 0.000051
.. raw:: html
.. raw:: html
.. code:: python
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss
for epoch in range(num_epochs):
for X, y in data_iter(batch_size, features, labels):
l = loss(net(X, w, b), y) # Minibatch loss in `X` and `y`
# Compute gradient on `l` with respect to [`w`, `b`]
l.sum().backward()
sgd([w, b], lr, batch_size) # Update parameters using their gradient
with torch.no_grad():
train_l = loss(net(features, w, b), labels)
print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')
.. parsed-literal::
:class: output
epoch 1, loss 0.044391
epoch 2, loss 0.000181
epoch 3, loss 0.000046
.. raw:: html
.. raw:: html
.. code:: python
lr = 0.03
num_epochs = 3
net = linreg
loss = squared_loss
for epoch in range(num_epochs):
for X, y in data_iter(batch_size, features, labels):
with tf.GradientTape() as g:
l = loss(net(X, w, b), y) # Minibatch loss in `X` and `y`
# Compute gradient on l with respect to [`w`, `b`]
dw, db = g.gradient(l, [w, b])
# Update parameters using their gradient
sgd([w, b], [dw, db], lr, batch_size)
train_l = loss(net(features, w, b), labels)
print(f'epoch {epoch + 1}, loss {float(tf.reduce_mean(train_l)):f}')
.. parsed-literal::
:class: output
epoch 1, loss 0.034802
epoch 2, loss 0.000124
epoch 3, loss 0.000052
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
print(f'error in estimating w: {true_w - w.reshape(true_w.shape)}')
print(f'error in estimating b: {true_b - b}')
.. parsed-literal::
:class: output
error in estimating w: [ 0.00044966 -0.00043631]
error in estimating b: [0.00071049]
.. raw:: html
.. raw:: html
.. code:: python
print(f'error in estimating w: {true_w - w.reshape(true_w.shape)}')
print(f'error in estimating b: {true_b - b}')
.. parsed-literal::
:class: output
error in estimating w: tensor([ 0.0006, -0.0003], grad_fn=)
error in estimating b: tensor([0.0008], grad_fn=)
.. raw:: html
.. raw:: html
.. code:: python
print(f'error in estimating w: {true_w - tf.reshape(w, true_w.shape)}')
print(f'error in estimating b: {true_b - b}')
.. parsed-literal::
:class: output
error in estimating w: [ 0.00061536 -0.00040913]
error in estimating b: [-0.00094461]
.. raw:: html
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html
`Discussions `__
.. raw:: html
.. raw:: html