线性回归

def synthetic_data(w, b, num_examples):
    x = torch.normal(0, 1, (num_examples, len(w)))
    ## 从平均值为0，方差为1的正态分布随机创造num_examples个（这里是1000）张量，其长度与w相同，输出是一个1000×2的矩阵。
    y = torch.matmul(X, w) + b
    ## mutmul()是矩阵乘法。
    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)
## features特征，表示已有的数据集，labels是真值。

def data_iter(batch_size, features, labels):
    num_examples = len(features)
    indices = list(range(num_examples))
    ## 得到一个与特征等长的序列
    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]
    ## 确定批次量作为步长，这里取10，生成器每运行一次，就会创造出一个长度为10的张量。

batch_size = 10

for X, y in data_iter(batch_size, features, labels):
    print(X, '\n', y)
    break
    ## break 用于中断生成器，要么就会生成100组。

w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)
b = torch.zeros(1, requires_grad=True)
## 设置初值。

def linreg(X, w, b):
    return torch.matmul(X, w) + b
## 定义模型

def squared_loss(y_hat, y):
    return(y_hat - y.reshape(y_hat.shape)) ** 2 / 2

def sgd(params, lr, batch_size):
    with torch.no_grad():
    ## 更新参数不需要求导
         for param in params:
         ## 传入w, b的列表。
            param -= lr * param.grad / batch_size
            param.grad.zero_()
            ## pyTorch需要手动梯度清零
    ## 对于列表对象，函数中改变就会改变全局变量，故不需return

  lr = 0.03
  num_epochs = 3
  net = linreg
  loss = squared_loss
  ## 定义超参数

  for epoch in range(num_epochs):
  ## 打乱一遍，出100组，一共打乱三遍。
    for X, y in data_iter(batch_size, features, labels):
        l = loss(net(X, w, b), y)
        l.sum().backward()
        ## 前面定义了b, w的grad_requires=True
        sgd([w, b], lr, batch_size)
    with torch.no_grad():
        train_l = loss(net(features, w, b), labels)
        ## 显示每遍历完一遍后的最终损失。
        print('output:')

import numpy as np
import torch
from torch.utils import data
from d2l import torch as d2l

## 创建数据集
true_w = torch.tensor([2, -3.4])
true_b = 4.2
features, labels = d2l.synthetic_data(true_w, true_b, 1000)

## 创建批量
def load_array(data_arrays, batch_size, is_train=True):
    dataset = data.TensorDataset(*data_arrays)  # *代表传入列表
    ## 把X,y连成列表作为数据集
    return data.DataLoader(dataset, batch_size, shuffle=is_train)
    ## DataLoader()函数表示提取一个批次。

batch_size = 10
data_iter = load_array((features, labels), batch_size)

next(iter(data_iter))


from torch import nn
net = nn.Sequential(nn.Linear(2, 1))
## Linear()线性回归，输入输出的维度。Sequential()表示List of Layers

net[0].weight.data.normal_(0, 0.01)
## 设置权重参数w的初始值。
net[0].bias.data.fill_(0)

## 调入损失函数
loss = nn.MSELoss()

## 调入优化方法
trainer = torch.optim.SGD(net.parameters(), lr=0.03)
## parameters是network里所有的参数，包括w和b。

## 训练
num_epochs = 3
for epoch in range(num_epochs):
    for X, y in data_iter:
        l = loss(net(X), y)
        trainer.zero_grad()
        l.backward()
        # 在执行过.backward()得到梯度后，才能执行.step()更新参数
        trainer.step()
    l = loss(net(features), labels)
    print(f'epoch {epoch + 1}, loss {1:f}')