1. import numpy as np
    2. import torch
    3. from torch.utils import data
    4. from d2l import torch as d2l
    6. """生成数据"""
    7. true_w = torch.tensor([2, -3.4])
    8. true_b = 4.2
    9. features, labels = d2l.synthetic_data(true_w, true_b, 1000)
    1. def load_array(data_arrays, batch_size, is_train=True):  #@save
    2.     """构造一个PyTorch数据迭代器。"""
    3.     dataset = data.TensorDataset(*data_arrays)
    4.     """shuffle=is_train：打乱数据顺序"""
    5.     return data.DataLoader(dataset, batch_size, shuffle=is_train)
    7. batch_size = 10
    8. """形成一个新的数据集"""
    9. data_iter = load_array((features, labels), batch_size)
    1. next(iter(data_iter))
    1. [tensor([[ 0.7836,  1.0064],
    2.          [-0.6185, -1.3923],
    3.          [-0.6124,  0.4895],
    4.          [ 0.4377,  0.0993],
    5.          [ 0.4083,  0.9128],
    6.          [-1.2252,  0.1269],
    7.          [-0.4364, -0.5128],
    8.          [-0.4539,  0.6795],
    9.          [-1.4068, -0.0619],
    10.          [-0.9712, -0.1202]]),
    11.  tensor([[2.3406],
    12.          [7.6942],
    13.          [1.3251],
    14.          [4.7355],
    15.          [1.9154],
    16.          [1.3303],
    17.          [5.0822],
    18.          [0.9745],
    19.          [1.5959],
    20.          [2.6766]])]
    1. # `nn` 是神经网络的缩写
    2. from torch import nn
    3. net = nn.Sequential(nn.Linear(2, 1))
    1. net[0].weight.data.normal_(0, 0.01)
    2. net[0].bias.data.fill_(0)
    1. tensor([0.])
    1. loss = nn.MSELoss()
    1. trainer = torch.optim.SGD(net.parameters(), lr=0.03)
    1. num_epochs = 3
    2. for epoch in range(num_epochs):
    3.     for X, y in data_iter:
    4.         l = loss(net(X) ,y)
    5.         trainer.zero_grad()
    6.         l.backward()
    7.         trainer.step()
    8.     l = loss(net(features), labels)
    9.     print(f'epoch {epoch + 1}, loss {l:f}')
    1. epoch 1, loss 0.000255
    2. epoch 2, loss 0.000098
    3. epoch 3, loss 0.000097