一、线性回归

  解析解：模型的解可以用一个公式简单的表示，这类解叫做解析解。
  超参数：可以调整但不在训练过程中更新的参数称为超参数。调参是选择超参数的过程。超参数通常是我们根据训练迭代结果来调整的。
  在无法得到解析解的情况下，我们也可以有效训练模型。用到一种称为梯度下降的方法，这种方法几乎可以优化所有的深度学习模型。它通过不断地在损失函数递减的方向上更新参数来降低误差。
  梯度下降的最简单的用法是计算损失函数（数据集中所有样本的损失均值）关于模型参数的导数（梯度）。在实际中可能比较慢，因为在每次更新参数之前，我们必须遍历整个数据集。因此，我们通常会在每次需要计算更新的时候随机抽取一小批样本，这种变体叫做小批量随机梯度下降。

1.1 线性回归从零开始实现

  通过代码从零开始实现线性回归整个方法，包括数据流水线、模型、损失函数和小批量随机梯度下降优化器。从零开始实现可以确保我们真正知道自己在做什么，同时，了解更细致的工作原理将方便我们自定义模型、自定义层或自定义损失函数。

1.1.1 生成数据集

  根据带有噪声的线性模型构造一个数据集，任务是使用这个有限样本的数据集来恢复这个模型的参数。生成一个包含1000个样本的数据集，每个样本包含从标准正态分布中抽样的两个特征。合成的数据集是一个1000个2维的矩阵。
  使用线性模型参数w=[2，-3.4]，b=4.2和噪声项 𝝴 来生成数据集及其标签：y=wX+b+𝝴，𝝴 可以视为模型预测和标签的潜在观测误差。假设 𝝴 服从均值为0的正态分布。

import torch
from d2l import torch as d2l
def synthetic_data(w,b,num_examples):
    """生成y=wx+b+噪声"""
    X = torch.normal(0, 1, (num_examples, len(w))) # 生成特征矩阵
    y = torch.matmul(X, w) + b # 计算 X 和 w 的矩阵乘法
    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)
print('features:',features[0],'\nlabel:',labels[0])

注意：features的中的每一行都包含一个二维数据样本，labels中的每一行都包含一维标签值（一个标量）。通过生成第二个特征features[:,1]和 labels 的散点图，可以直观地观察到两者之间的线性关系。

d2l.set_figsize(figsize=(8,4)) #设置图形的尺寸  
d2l.plt.scatter(features[:, (1)].detach().numpy(), labels.detach().numpy(), 1) #选择 features 矩阵中的第二列
#detach() 用于从计算图中分离出该张量，这意味着此操作后，features[:, (1)] 和 labels 将不会再参与梯度计算。将PyTorch 张量转换为 NumPy 数组

1.1.2 读取数据

  训练模型时要对数据集进行遍历，每次抽取小批量样本，并使用它们来更新我们的模型，由于这个过程是训练机器学习算法的基础，因此有必要定义一个函数，该函数能打乱数据集中的样本并以小批量方式获取数据。

import random
def data_iter(batch_size,features,labels): #实现了一个数据迭代器 data_iter，用于按批次生成数据
    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
        #这是一个生成器函数，意味着函数在调用时会返回一个批次的数据，之后可以继续从当前位置继续执行。这使得 data_iter 可以按需生成批次，而不是一次性加载所有数据到内存。

  读取第一个小批量数据样本并打印，每个批量的特征维度显示批量大小和输入特征数。同样，批量的标签形状与batch_size相等。

batch_size=10
for X,y in data_iter(batch_size,features,labels):
    print(X,y)
    break

  当我们执行迭代时，会连续地获得不同的小批量，直至遍历完整个数据集。

1.1.3 初始化模型参数

  在我们开始用小批量随机梯度下降优化我们的模型参数之前，我们需要先有一些参数。通过从均值为0，标准差为0.01的正态分布中抽样随机数来初始化权重，并将偏置初始化为0。

w=torch.normal(0,0.01,size=(2,1),requires_grad=True)
b=torch.zeros(1,requires_grad=True)

  在初始化参数之后，我们的任务是更新这些参数，直到这些参数足以拟合我们的数据。每次更新都需要计算损失函数关于模型参数的梯度。有了这个梯度，我们就可以向减小损失的方向更新每个参数。可以通过自动微分来计算梯度。

1.1.4 定义模型

  接下来，需要定义模型，将模型的输入和参数同模型的输出关联起来。

def linreg(X,w,b):
    """线性回归模型"""
    return torch.matmul(X,w)+b

1.1.5 定义损失函数

  因为需要计算损失函数的梯度，所以应该先定义损失函数。

def squared_loss(y_hat,y):
    """均方损失"""
    return (y_hat-y.reshape(y_hat.shape))**2/2

1.1.6 定义优化算法

  在每一步中，使用从数据集中随机抽取的一个小批量，然后根据参数计算损失的梯度。接下来，朝着减少损失的方向更新我们的参数。下面的函数实现小批量随机梯度下降更新。该函数接收模型参数集合、学习率和批量大小作为输入。每一步更新的大小由学习率lr决定。

def sgd(params,lr,batch_size): #params一个列表或迭代器，包含了模型的所有需要优化的参数，学习率（learning rate）
    """小批量随机梯度下降"""
    with torch.no_grad(): #上下文管理器用于指示 PyTorch 在执行其中的操作时不需要计算梯度。
        for param in params:
            param-=lr*param.grad/batch_size #param.grad 获取当前参数的梯度 
            #因为在小批量随机梯度下降中，根据批次样本的平均梯度来更新参数，所以这里需要除以batch_size来平均每个样本对参数更新的贡献。
            param.grad.zero_() #清空当前参数的梯度

1.1.7 训练

  在每次迭代中，读取小批量训练样本，并通过模型来获得一组预测。计算完损失后，开始反向传播，存储每个参数的梯度。最后，调用优化算法 sgd 来更新模型参数。

#训练过程
lr=0.03
num_epochs=10
net=linreg   
squared_loss=squared_loss
for epoch in range(num_epochs):
    for X,y in data_iter(batch_size,features,labels):
        l=squared_loss(net(X,w,b),y)
        l.sum().backward()
        sgd([w,b],lr,batch_size)
    with torch.no_grad():
        train_l=squared_loss(net(features,w,b),labels)
        print(f'epoch{epoch+1},loss{float(train_l.mean())}')

  使用的是自己合成的数据集，知道真实参数是什么，因此，可以通过比较真实参数和通过训练学习的参数来评估训练的成功程度。事实上，从估计误差结果可以看出真实参数和通过训练学习的参数确实非常接近。

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

1.2 线性回归的简洁实现

1.2.1 生成数据集

import pandas as pd
import torch
from torch.utils import data
from d2l import torch as d2l

true_w=torch.tensor([2,-3.4])
true_b=4.2
def synthetic_data(w,b,num_examples):
    """生成y=wx+b+噪声"""
    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))
features,labels=synthetic_data(true_w,true_b,1000)

1.2.2 读取数据

  可以通过调用框架中现有的API来读取数据，将 features 和 labels 作为API的参数传递，并通过数据迭代器指定batch_size。此外，布尔值is_train表示是否希望数据迭代器对象在每轮内打乱数据。

def load_array(data_arrays,batch_size,is_train=True):
    """构造pytorch 数据迭代器"""
    dataset=data.TensorDataset(*data_arrays)
    #它将输入的特征和标签（通过 *data_arrays 解包传递）打包成一个数据集对象。
    return data.DataLoader(dataset,batch_size,shuffle=is_train)
#data_arrays是一个包含数据的元组，通常是两个元素：一个是特征（X），另一个是标签（y）。数据会被封装成PyTorch的TensorDataset，供后续的 DataLoader使用。
#函数最终返回的是一个 DataLoader 对象，允许我们以小批量的形式迭代数据。
batch_size=10
data_iter=load_array((features,labels),batch_size)
next(iter(data_iter))

1.2.3 定义模型

  对于标准深度学习模型，可以使用框架的预定义好的层。这使我们只需关注使用哪些层来构造模型，而不必关注层的实现细节。我们先定义一个模型变量net，它是一个Sequential类的实例。Sequential类将多个层串联在一起。当给定输入数据时，Sequential实例将数据传入第一层，然后将第一层的输出作为第二层的输入，以此类推。
  在Pytorch中，全连接层在Linear类中定义，将两个参数传递到nn.Linear中。第一个参数指定输入特征形状，即2.第二个参数指定输出特征形状，输出特征形状为单个标量，因此为1.

from torch import nn
net=nn.Sequential(nn.Linear(2,1))

1.2.4 初始化模型参数

  在使用net之前，需要初始化模型参数，如在线性回归模型中的权重和偏置。深度学习框架通常由预定义的方法来初始化参数。在这里，指定每个权重参数应该从均值为0，标准差为0.01的正态分布中随机抽样，偏置参数初始化为零。通过net[0]选择网络中第一层，然后使用weight.data和bias.data方法访问参数。还可以使用替换方法normal_和fill_来重写参数值。

net[0].weight.data.normal_(0,0.01)
net[0].bias.data.fill_(0)

1.2.5 定义损失函数

  计算均方误差使用的是MSELoss类，其也称为平方L2范数。默认情况下，它返回所有样本损失的平均值。

loss=nn.MSELoss()

1.2.6 定义优化算法

  小批量随机梯度下降算法是一种优化神经网络的标准工具，Pytorch在optim模块中实现了该算法的许多变体。实例化一个SGD实例时，需要指定优化的参数（可通过net.parameters()从模型中获得）以及优化算法所需的超参数字典。小批量随机梯度下降只需要设置lr的值，这里设置为0.03。

trainer=torch.optim.SGD(net.parameters(),lr=0.03)

1.2.7 训练

  通过深度学习框架的高级API来实现模型只需要相对较少的代码，不必单独分配参数，不必定义损失函数，也不必手动实现小批量随机梯度下降。使用更复杂的模型时，高级API的优势将极大显现。有了所有的基本组件，训练过程的代码与从零开始实现时的非常相似。
  回顾一下，在每轮里，将完整遍历一次数据，不断地从中获取一个小批量的输入和相应的标签。对于每个小批量，我们会执行以下步骤。

• 通过调用net(x)生成预测并计算损失L(前向传播)
• 通过反向传播来计算梯度
• 通过调用优化器来更新模型参数

为了更好地度量训练效果，我们计算每轮后的损失，并打印处理监控训练过程

num_epochs=10
for epoch in range(num_epochs):
    for X,y in train_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:.4f}') #f:普通浮动点数格式；.4f保留四位小数

  比较生成数据集的真实参数和通过有限数据训练获得的模型参数。要访问参数，首先从net访问所需的层，然后读取该层的权重和偏置。

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

二、softmax回归

  通常，机器学习实践者用分类这个词来描述两个有微妙差别的问题：（1）如果我们只对样本的“硬性”类别感兴趣，就属于某个类别；（2）如果我们希望得到“软性”类别，就属于某个类别的概率。这两者的界限往往很模糊，其中的一个原因是：即使我们只关心硬性类别，我们也仍然使用软性类别的模型。
  与线性回归一样，softmax回归也是一个单层神经网络，输出层也是全连接层。softmax运算不会改变未规范化的预测值之间的大小次序，只会确定分配给每个类别的概率。

2.1 图像分类数据集

2.1.1 读取数据

  MINIST数据集是图像分类中广泛使用的数据集之一，但作为基准数据集过于简单。此次使用类似但复杂的Fashion-MINIST数据集。通过框架中的内置函数将Fashion-MINIST数据集下载并读取到内存中。

%matplotlib inline
import torch
import torchvision
from torch.utils import data
import torchvision.transforms as transforms
from d2l import torch as d2l
import numpy as np

d2l.use_svg_display()
trans = transforms.ToTensor() #通过ToTensor实例将图像数据从PIL类型变换成32位浮点数形式，并除以255使得所有像素的数值均为0~1
mnist_train = torchvision.datasets.FashionMNIST(root="../data", train=True, transform=trans, download=True)
mnist_test = torchvision.datasets.FashionMNIST(root="../data", train=False, transform=trans, download=True)

  Fashion-MINIST 由10个类别的图像组成，每个类别由训练数据集中的6000张图像和测试数据集中的1000张图像组成。因此，训练集和测试集分别包含6000和1000张图像。测试数据集不会用于训练，只用于评估模型性能。

len(mnist_train), len(mnist_test)

  每个输入图像的高度和宽度均为28像素。数据集由灰度图像组成，其通道数为1，为简洁起见，将高度为h像素，宽度为w像素的图像的形状记为（h,w）或 hxw

mnist_train[0][0].shape

  Fashion-MINIST中包含的10个类别分别为T-shirt(T恤)、trouser(裤子)、pullover(套衫)、dress(连衣裙)、coat(外套)、sandal(凉鞋)、shirt(衬衫)、sneaker(运动鞋)、bag(包)和ankle boot(短靴)。

def get_fashion_mnist_labels(labels):
    text_labels = ['t-shirt', 'trouser', 'pullover', 'dress', 'coat', 'sandal', 'shirt', 'sneaker', 'bag', 'ankle 				    boot']           
    return [text_labels[int(i)] for i in labels]

  创建一个函数来可视化这些样本。

def show_images(imgs, num_rows, num_cols, titles=None, scale=1.5):
    figsize = (num_cols * scale, num_rows * scale)
    _, axes = d2l.plt.subplots(num_rows, num_cols, figsize=figsize)
    axes = axes.flatten()
    for i, (ax, img) in enumerate(zip(axes, imgs)):
        if torch.is_tensor(img):
            ax.imshow(img.numpy())
        else:
            ax.imshow(img)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        if titles:
            ax.set_title(titles[i])
    return axes

  训练数据集中前几个样本的图像及其相应的标签。

X, y = next(iter(data.DataLoader(mnist_train, batch_size=18)))
show_images(X.reshape(18, 28, 28), 2, 9, titles=get_fashion_mnist_labels(y)) 

2.1.2 读取小批量数据

  为了使读取训练集和测试集时更容易，使用内置的数据迭代器，而不是从零开始创建。在每次迭代中，数据加载器都会读取一小批量数据，大小为batch_size。通过内置的数据迭代器，可以随机打乱所有样本，从而无偏见的读取小批量数据。

batch_size = 256
train_iter = data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=4) #使用4个进程来读取数据
#读取数据所需时间
timer=d2l.Timer()
for X, y in train_iter:
    continue
print(f'{timer.stop():.2f} sec')

2.1.3 整合所有组件

  定义load_data_fashion_mnist函数，用户获取和读取Fashion-MINIST数据集，这个函数返回训练集和验证集的数据迭代器。实现了加载并处理 FashionMNIST 数据集的功能。此外，这个函数还接收一个可选参数resize，用来将图像调整为另一种形状。

def load_data_fashion_mnist(batch_size, resize=None): #通过resize参数来测试load_data_fashion_mnist函数图像大小调整功能。
    trans = [transforms.ToTensor()] #创建列表，ToTensor()是一个图像转换函数，将图像从PIL格式或numpy数组转换为tensor格式。
    if resize:
        trans.insert(0, transforms.Resize(resize))
    trans = transforms.Compose(trans) #transforms.Compose() 是一个容器，可以将多个图像转换操作组合成一个流水线。
    mnist_train = torchvision.datasets.FashionMNIST(root="../data", train=True, transform=trans, download=False)
    mnist_test = torchvision.datasets.FashionMNIST(root="../data", train=False, transform=trans, download=False)
    return (data.DataLoader(mnist_train, batch_size, shuffle=True, num_workers=4),
            data.DataLoader(mnist_test, batch_size, shuffle=False, num_workers=4))
train_iter, test_iter = load_data_fashion_mnist(32, resize=64)
for X, y in train_iter:
    print(X.shape, X.dtype, y.shape, y.dtype) #X.shape：32 是批量大小，1 是通道数，64x64 是图像的大小
    break

2.2 softmax 回归从零开始实现

  原始数据集中的每个样本都是28像素x28像素。展平每张图像，把它们看作长度为784的向量。输出与类别一样多，因为数据集有10个类别，所以网络输出维度为10，因此，权重将构建一个784x10的矩阵，偏置将构成一个1x10的行向量。使用正态分布初始化权重w，偏置初始化为0。

2.2.1 初始化模型参数

import torch
from IPython import display
from d2l import torch as d2l
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

num_inputs = 784
num_outputs = 10
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)
b = torch.zeros(num_outputs, requires_grad=True)

2.2.2 定义softmax 操作

  实现softmax由以下3个步骤组成：
（1）对每个项求幂（使用exp）
（2）对每一行求和（同一列轴0，同一行轴1，小批量中的每个样本是一行），得到每个样本的规范化参数
（3）将每一行除以其规范化常数，确保结果的和为1

def softmax(X):
    X_exp = torch.exp(X)
    partition = X_exp.sum(1, keepdim=True) #同一列轴0，同一行轴1 keepdim=True：保持维度
    return X_exp / partition
#测试数据样例    
X=torch.normal(0, 1, (2, 5))
X_prob = softmax(X)
X_prob,X_prob.sum(1)

2.2.3 定义模型

def net(X):
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

2.2.4 定义损失函数

  计算交叉熵损失函数。

def cross_entropy(y_hat, y):
    return - torch.log(y_hat[range(len(y_hat)), y])

2.2.5 分类精度

  当预测与分类标签y一致时是正确的。分类精度是正确预测数与预测总数之比。为了计算精度，首先，如果y_hat是矩阵，那么假定第二个维度存储每个类别的预测分数，使用argmax获得每行中最大元素的索引来获得预测类别，然后，将预测类别与真实y元素进行比较。由于等式运算符“==”对数据类型很敏感，因此将y_hat的数据类型转换为与y的数据类型一致。结果是一个包含0（错）和1（对）的张量。最后，我们求和会得到预测正确的数量。

def accuracy(y_hat, y):
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        y_hat = y_hat.argmax(axis=1)
    cmp = y_hat.type(y.dtype) == y
    return float(cmp.type(y.dtype).sum())
    
def evaluate_accuracy(data_iter, net):
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式
    metric = d2l.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]

  定义一共实用Accumulator，用于对多个变量进行累加。在evaluate_accuracy中Accumulator实例创建了两个变量，分别用于存储正确预测数和预测总数。当我们遍历数据集时，两者都将随着时间的推移而累加。

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]

  由于使用随机权重初始化net模型，因此该模型的精度应接近于随机猜测。在有10个类别情况下的精度接近0.1

evaluate_accuracy(test_iter, net)  #输出：0.1047

2.2.6 训练

def train_epoch_ch3(net, train_iter, loss, updater):
    if isinstance(net, torch.nn.Module): # 是否是pytorch的nn.Module
        net.train()
    metric = Accumulator(3) #训练损失总和、训练准确度总和、样本数
    for X, y in train_iter:
        y_hat = net(X)
        l=loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            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()) 
    return metric[0] / metric[2], metric[1] / metric[2]

  在展示训练函数之前，定义一个在动画中绘制图表的实用程序类 Animator，它能简化其余部分代码。

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,]
        self.axes = [self.axes,]
        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)

  接下来实现一个训练函数，它会在train_iter 访问的训练数据集上训练一个模型net，该训练函数将会运行多轮（由num_epochs指定），在每轮结束时，利用test_iter访问的测试数据集对模型进行评估。

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):
    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):
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        test_acc = evaluate_accuracy(test_iter, net)
        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

  使用小批量随机梯度下降来优化模型的损失函数，设置学习率为0.1。

lr=0.1
def updater(batch_size):
    return d2l.sgd([W, b], lr, batch_size)
num_epochs=10 #训练模型10轮。
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)

2.2.7 预测

def predict_ch3(net, test_iter, n=6):
    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 + '\n' + pred for true, pred in zip(trues, preds)]
    d2l.show_images(X[0:n].reshape((n, 28, 28)), 1, n, titles=titles[0:n])
predict_ch3(net, test_iter)

2.3 softmax回归简洁实现

2.3.1 初始化模型参数

import torch
from torch import nn
from d2l import torch as d2l
batch_size = 256
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)
net=nn.Sequential(nn.Flatten(), nn.Linear(784, 10))
def init_weights(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, std=0.01)
net.apply(init_weights)

2.3.2 定义损失函数

loss = nn.CrossEntropyLoss()

2.3.3 优化算法

  使用学习率为0.1的小批量随机梯度下降作为优化算法。

trainer = torch.optim.SGD(net.parameters(), lr=0.1)

2.3.4 训练

num_epochs = 10
d2l.train_ch3(net, train_iter, test_iter, loss, num_epochs, trainer)