02线性回归

08_P3  pycharm代码

import random  # 需要随机化梯度下降和随机初始化参数
import torch


# 定义模型 预测y 即y_hat
def linreg(X, w, b):
    """线性回归模型"""
    return torch.matmul(X, w) + b


# 定义合成数据的函数
def synthetic_data(w, b, num_examples):
    """生成y=Xw+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w)))  # 生成均值为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))  # 列数为1，行数需要计算


# 小批量数据读取
def data_iter(batch_size, features, labels):
    num_examples = len(features)  # num_examples为X中的行数 即多少组数据
    indices = list(range(num_examples))  # 生成索引列表[1，2，3，....，500]
    random.shuffle(indices)  # 随机读取索引 [23，42，103，....，487]
    for i in range(0, num_examples, batch_size):  # 步长为batch_size
        batch_indices = torch.tensor(  # 生成数据块，从列表的第i个元素到i+batch_size的元素即每次取10个
            indices[i: min(i + batch_size, num_examples)])  # 例 第一次取到[23，42，103，....，368]
        yield features[batch_indices], labels[batch_indices]  # 不断返回features和batch_indices中第23，42，103，....，368行数据


# 定义损失函数
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:
            param -= lr * param.grad / batch_size  # 除不除batch_size变化不大
            param.grad.zero_()  # 避免梯度累计

if __name__ == '__main__':
    # 初始化模型参数
    w = torch.normal(0, 0.01, size=(2, 1), requires_grad=True)  # 生成均值为0方差为0.01的随机向量，2行1列
    b = torch.zeros(1, requires_grad=True)
    # 给出真实值true_w true_b
    true_w = torch.tensor([2, -3.4])
    true_b = 4.2
    # 构建数据集X作为features,并通过真实值true_w true_b算出y的真实值作为labels
    features, labels = synthetic_data(true_w, true_b, 1000)  # 生成特征和标注。features, labels分别接收函数的返回值X、y
    # 训练的超参数
    batch_size = 10
    lr = 0.03  # 学习率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):  # 拿出批量大小的赋给X，y。 每次拿10行，拿50次。
            # X和y的小批量损失
            l = loss(net(X, w, b), y)  # 把X, w, b放入linreg中做预测，并与真实的y做均方损失
            # 因为l形状是(batch_size,1)，而不是一个标量。l中的所有元素被加到一起，
            # 并以此计算关于[w,b]的梯度
            l.sum().backward()  # 求和并算梯度
            sgd([w, b], lr, batch_size)  # 使用参数的梯度更新参数   对w,b进行更新
        with torch.no_grad():  # 做预测，不需要梯度
            train_l = loss(net(features, w, b), labels)  # 放入整个数据
            print(f'epoch {epoch + 1}, loss {float(train_l.mean()):f}')  # .mean()求均值

    print(f'w的估计误差: {true_w - w.reshape(true_w.shape)}')
    print(f'b的估计误差: {true_b - b}')

笔记

 

 08_P4  pycharm代码

import torch
from torch.utils import data
from d2l import torch as d2l
from torch import nn


def load_array(data_arrays, batch_size, is_train=True):
    """用(features, labels)构造一个PyTorch数据迭代器"""
    dataset = data.TensorDataset(*data_arrays)  # 生成数据集dataset
    return data.DataLoader(dataset, batch_size, shuffle=is_train)  # 随机返回dataset的batch_size行数据

if __name__ == '__main__':
    true_w = torch.tensor([2, -3.4])
    true_b = 4.2
    features, labels = d2l.synthetic_data(true_w, true_b, 1000)

    batch_size = 10
    data_iter = load_array((features, labels), batch_size)     # 构造并得到小批量数据，是一个矩阵
    next(iter(data_iter))  # 将data_iter转成python的iter，通过next不断获取并返回iter的下一条数据，即矩阵的下一行
    # Sequential顺序容器，模块将按照在构造函数中传递的顺序添加到模块中。
    net = nn.Sequential(nn.Linear(2, 1))  # 导入线性回归模型，输入的维度为2（X的列数为2），输出y_hat维度为1
    net[0].weight.data.normal_(0, 0.01)  # 模型中第一层（net[0]）用随机正态分布改写权重参数。可以不设，使用默认。
    net[0].bias.data.fill_(0)  # 偏差设为0
    loss = nn.MSELoss()  # 使用均方误差，也称为平方 L2 范数，默认情况下，它返回所有样本损失的平均值
    trainer = torch.optim.SGD(net.parameters(), lr=0.03)  # 传入所有待优化的参数（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()
            trainer.step()  # 调用优化器来更新模型参数
        l = loss(net(features), labels)
        print(f'epoch {epoch + 1}, loss {l:f}')

    w = net[0].weight.data
    print('w的估计误差：', true_w - w.reshape(true_w.shape))
    b = net[0].bias.data
    print('b的估计误差：', true_b - b)

09_P4  pycharm代码

import torch
from IPython import display
from d2l import torch as d2l

# 动画绘制
class Animator:
    """在动画中绘制数据"""
    def __init__(self, xlabel=None, ylabel=None, legend=None, xlim=None,
                 ylim=None, xscale='linear', yscale='linear',
                 fmts=('-', 'm--', 'g-.', 'r:'), nrows=1, ncols=1,
                 figsize=(3.5, 2.5)):
        # 增量地绘制多条线
        if legend is None:
            legend = []
        d2l.use_svg_display()
        self.fig, self.axes = d2l.plt.subplots(nrows, ncols, figsize=figsize)
        if nrows * ncols == 1:
            self.axes = [self.axes, ]
        # 使用lambda函数捕获参数
        self.config_axes = lambda: d2l.set_axes(
            self.axes[0], xlabel, ylabel, xlim, ylim, xscale, yscale, legend)
        self.X, self.Y, self.fmts = None, None, fmts

    def add(self, x, y):
        # 向图表中添加多个数据点
        if not hasattr(y, "__len__"):
            y = [y]
        n = len(y)
        if not hasattr(x, "__len__"):
            x = [x] * n
        if not self.X:
            self.X = [[] for _ in range(n)]
        if not self.Y:
            self.Y = [[] for _ in range(n)]
        for i, (a, b) in enumerate(zip(x, y)):
            if a is not None and b is not None:
                self.X[i].append(a)
                self.Y[i].append(b)
        self.axes[0].cla()
        for x, y, fmt in zip(self.X, self.Y, self.fmts):
            self.axes[0].plot(x, y, fmt)
        self.config_axes()
        display.display(self.fig)
        display.clear_output(wait=True)

# 定义softmax操作
def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True)  # 按轴求和，keepdim=True保持原矩阵维度不变
    return X_exp / partition  # 这里应用了广播机制

# 定义模型
def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)  # -1自动算行数（256），W.shape[0]返回w的行数
'''
# 定义损失函数（交叉熵损失）
y = torch.tensor([0, 2])
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])
#  z = y_hat[[0, 1], y]  # 从y_hat[0]中取出第y[0]个元素，y_hat[0][0].从y_hat[1]中取出第y[1]个元素,y_hat[1][2]
'''
def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

# 将预测类别y_hat与真实的y元素进行比较
def accuracy(y_hat, y):
    """计算预测正确的数量"""
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:  # len(y_hat.shape)行数大于1，y_hat.shape[1]列数大于1.
        y_hat = y_hat.argmax(axis=1)    # 将y_hat每一行最大的值的索引取出放入y_hat
    cmp = y_hat.type(y.dtype) == y      # cmp为每个元素都为布尔值的张量
    return float(cmp.type(y.dtype).sum())  # 将cmp中数据类型转换成y中的数据类型，false=0.true=1.返回预测正确的个数


class Accumulator:
    """在n个变量上累加"""
    def __init__(self, n):
        self.data = [0.0] * n

    def add(self, *args):
        self.data = [a + float(b) for a, b in zip(self.data, args)]

    def reset(self):
        self.data = [0.0] * len(self.data)

    def __getitem__(self, idx):
        return self.data[idx]
def evaluate_accuracy(net, data_iter):
    """计算在指定数据集上模型的精度"""
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式
    metric = Accumulator(2)  # 正确预测数、预测总数
    with torch.no_grad():
        for X, y in data_iter:
            metric.add(accuracy(net(X), y), y.numel())
    return metric[0] / metric[1]

def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)

# 训练  迭代一次的流程  .nn还是还是自定义
def train_epoch_ch3(net, train_iter, loss, updater):
    """训练模型一个迭代周期（定义见第3章）"""
    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()
    # 长度为3的迭代器累加信息。   训练损失总和、训练准确度总和、样本数
    metric = Accumulator(3)
    for X, y in train_iter:    # 循环235次
        # 计算梯度并更新参数
        # print(X.shape) [256,1,28,28]
        # print(y.shape) [256]
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()
            l.mean().backward()
            updater.step()
        else:
            # 使用定制的优化器和损失函数
            l.sum().backward()
            updater(X.shape[0])
        metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失（所有loss的累加/样本总数）和训练精度（所有分类正确样本数/样本总数）
    return metric[0] / metric[2], metric[1] / metric[2]

#  训练
def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    """训练模型（定义见第3章）"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    for epoch in range(num_epochs):                                       # 扫10遍
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)   # train_metrics训练误差
        test_acc = evaluate_accuracy(net, test_iter)                      # test_acc在测试数据集上的精度
        animator.add(epoch + 1, train_metrics + (test_acc,))              # 可视化
    train_loss, train_acc = train_metrics
    assert train_loss < 0.5, train_loss
    assert train_acc <= 1 and train_acc > 0.7, train_acc
    assert test_acc <= 1 and test_acc > 0.7, test_acc

# 预测
def predict_ch3(net, test_iter, n=12):
    """预测标签（定义见第3章）"""
    for X, y in test_iter:
        break
    trues = d2l.get_fashion_mnist_labels(y)
    preds = d2l.get_fashion_mnist_labels(net(X).argmax(axis=1))
    titles = [true+pred for true, pred in zip(trues, preds)]
    d2l.show_images(
        X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])
    d2l.plt.show()


if __name__ == '__main__':
    # 初始化参数模型
    batch_size = 256
    num_inputs = 784  # 把28*28的图片拉成一个784的向量
    num_outputs = 10  # 因为有10种类型，故输出为10
    # 权重将构成一个 784×10 的矩阵W， 偏置将构成一个 1×10 的行向量b
    W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
    b = torch.zeros(num_outputs, requires_grad=True)
    lr = 0.1
    num_epochs = 10
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)  # 加载所有数据，每256个为一组
    # print(len(train_iter))  235
    train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)
    d2l.plt.show()
    # 预测
    predict_ch3(net, test_iter)

 09_P5  pycharm代码

import torch
from torch import nn
from d2l import torch as d2l


# 初始化模型参数
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)  # 将权重初始化为均值为0，方差0.01的随机值

if __name__ == '__main__':
    batch_size = 256
    num_epochs = 10
    train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
    # PyTorch不会隐式地调整输入的形状。因此，我们在线性层前定义了展平层（flatten），来调整网络输入的形状
    # 把任何维度的tensor转成向量（二维）  线性层Linear输入784输出10   Sequential类构造器
    net = nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
    net.apply(init_weights)  # 每一层都跑一下此函数
    # 交叉熵损失函数
    loss = nn.CrossEntropyLoss(reduction='none')
    # 优化算法
    trainer = torch.optim.SGD(net.parameters(), lr=0.1)
    # 训练
    d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)
    d2l.plt.show()