标签：从零开始 回归 torch iter train softmax net hat metric

一、创建数据集

从Fashion-MNIST数据集中引入创建数据，并设置数据迭代器的批量大小为256

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

#batch_size=256，表明随机读取256张图片
batch_size = 256

# 返回训练集和测试集的迭代器
# load_data_fashion_mnist函数是在图像分类数据集中定义的一个函数，可以返回batch_size大小的训练数据集和测试数据集
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size)

　　

二、初始化模型参数

1、原始数据集中的每个样本都是28*28的图像

2、在本书中，我们将展平每个图像，把它们看作长度为784的向量

3、在softmax回归中，我们输出与类别一样多。(因为我们的数据集有10个类别，所以网络输出的维度为10)

4、权重将构成一个 784×10 的矩阵，偏置将构成一个 1×10 的行向量。与线性回归一样，我们将使用正态分布初始化我们的权重 W，偏置初始化为0

num_inputs = 784 # 样本的长和宽都是28，将其展平为空间向量，长度变为784
num_outputs = 10 # 数据集类别，也是输出数


#size=(num_inputs, num_outputs)；行数等于输入的个数，列数等于输出的个数
#requires_grad=True表明要计算梯度
#权重
#在这里W被定义为一个784*10的矩阵
W = torch.normal(0, 0.01, size=(num_inputs, num_outputs), requires_grad=True)

#偏离
b = torch.zeros(num_outputs, requires_grad=True)

　　

三、定义softmax操作

# 定义softmax()函数

def softmax(X):
    #torch.exp()对每个元素做指数计算
    X_exp = torch.exp(X)
    
    #对矩阵的每一行求和，重新生成新的矩阵
    partition = X_exp.sum(1, keepdim=True)
    
    
    # X_exp / partition：每一行代表一个样本，行中的每个数据代表在该类别的概率
    return X_exp / partition  # 这里应用了广播机制

可以发现，每个元素都变成了一个非负数。此外，依据概率原理，每行总和为1。

如下，是个小测试

#创建一个随机的均值为0，方差为1的两行五列的矩阵
X = torch.normal(0, 1, (2, 5))

#对矩阵进行softmax计算
X_prob = softmax(X)

X_prob, X_prob.sum(1)
#通过输出可以发现在softmax之后，每个元素都是正的，且行之和为1

#输出结果

(tensor([[0.0474, 0.0313, 0.8646, 0.0317, 0.0250],
         [0.1736, 0.4575, 0.2832, 0.0618, 0.0239]]),
 tensor([1.0000, 1.0000]))

　　

四、定义模型

1、利用之前实现的softmax操作，可以实现softmax回归模型

2、在将数据传递到模型之前，需要使用reshape函数将每张原始图像展平为向量

def net(X):
    #matmul是矩阵乘法
    #W.shape[0]=784
    
    # W是一个784*10的矩阵，W.shape就是[784,10]的列表，可以通过W.shape[0]来访问784
    return softmax(torch.matmul(X.reshape((-1, W.shape[0])), W) + b)

　　

五、定义损失函数

y = torch.tensor([0, 2])

# y_hat为预测值，此次是对两个样本做预测值
y_hat = torch.tensor([[0.1, 0.3, 0.6], [0.3, 0.2, 0.5]])

# 对第零个样本，拿出y0的数据=0.1；对第一个样本，拿出y1的书籍，y1=2,就是拿出第三个数据=0.5
# 第一个参数[0,1]表示样本号，第二个参数y表示在第一个参数确定的样本中取数的序号
y_hat[[0, 1], y]

#输出结果

tensor([0.1000, 0.5000])

上诉可以帮助我们理解“交叉”的含义。接下来，我们只需要添加一行代码实现损失函数

# 给定我的y_hat预测和真实标号y
def cross_entropy(y_hat, y):
    #对于每一行range(len(y_hat))：生成一个从零开始一直到len(y_hat)的向量
    
    return -torch.log(y_hat[range(len(y_hat)), y])

print(cross_entropy(y_hat, y))
-torch.log(y_hat[[0, 1], y])
#输出：2.3026样本零的损失，0.6931样本1的损失


#输出结果

tensor([2.3026, 0.6931])
tensor([2.3026, 0.6931])

　　

六、分类准确度

1、分类准确率即正确预测数量与总预测数量之比。

2、y_hat 是矩阵，假定第二个维度存储每个类的预测分数。

3、使用 argmax 获得每行中最大元素的索引来获得预测类别

4、将预测类别与真实 y 元素进行比较

# 计算分类准确率，正确预测数量与总预测数量之比
# y_hat是预测值，y是真实值

# 计算预测正确的样本数
def accuracy(y_hat, y):  #@save
    """计算预测正确的数量。"""
    # len是查看矩阵的行数
    # y_hat.shape[1]就是去列数，y_hat.
    if len(y_hat.shape) > 1 and y_hat.shape[1] > 1:
        #每一行中元素最大的那个下标存在y_hat里面
        #最大的元素就可以算为预测分类的类别
        y_hat = y_hat.argmax(axis=1)
        
    #将y_hat转换为y的数据类型然后作比较
    #使用cmp函数存储bool类型
    cmp = y_hat.type(y.dtype) == y
    
    #将cmp转化为y的数据类型再求和——得到找出来预测正确的类别数
    return float(cmp.type(y.dtype).sum())

5、按照之前定义的变量y_hat和y，我们预测准确率（第一个样本的预测类别是2（该行的最大元素为0.6，索引为2），这与实际标签0不一致。第二个样本的预测类别是2（该行的最大元素为0.5，索引为 2），这与实际标签2一致）

#除以整个y的长度（样本数），就是预测正确的概率
accuracy(y_hat, y) / len(y)

#输出结果

0.5

 6、泛化，对于任意数据迭代器data_iter 可访问的数据集，我们可以评估在任意模型 net 的准确率。

# 评估任意模型的准确率

def evaluate_accuracy(net, data_iter):  #@save
    """计算在指定数据集上模型的精度。"""
    
    
    # isinstance()：判断一个对象是否是一个已知的类型
    # 判断输入的net模型是否是torch.nn.Module类型
    if isinstance(net, torch.nn.Module):
        net.eval()  # 将模型设置为评估模式（不用计算梯度）
        
    metric = Accumulator(2)  # 存储正确预测数、预测总数
    
    # 每次从迭代器中拿出一个x和y
    for X, y in data_iter:
        
        # 1、net(X)：X放在net模型中进行softmax操作
        # 2、accuracy(net(X), y)：再计算所有预算正确的样本数
        # numel()函数：返回数组中元素的个数，在此可以求得样本数
        metric.add(accuracy(net(X), y), y.numel())
        
    #metric[0]:分类正确的样本数，metric[1]:总的样本数
    return metric[0] / metric[1]

evaluate_accuracy(net, test_iter)

#输出结果
0.1001

　　

七、训练

1、首先，我们定义一个函数来训练一个迭代周期

2、注意，updater是更新模型参数的常用函数，接受批量大小作为参数

def train_epoch_ch3(net, train_iter, loss, updater):  #@save

    """训练模型一个迭代周期（定义见第3章）。"""

    # 将模型设置为训练模式
    if isinstance(net, torch.nn.Module):
        net.train()#告诉pytorch我要计算梯度
        
    # 训练损失总和、训练准确度总和、样本数
    # Accumulator 是一个实用程序类，用于对多个变量进行累加
    #在此创建了一个长度为三的迭代器，用于累加信息
    metric = Accumulator(3)
    
    for X, y in train_iter:
        # 计算梯度并更新参数
        y_hat = net(X)
        l = loss(y_hat, y)
        if isinstance(updater, torch.optim.Optimizer):
            # 使用PyTorch内置的优化器和损失函数
            updater.zero_grad()#先把梯度设置为零
            l.backward() #计算梯度
            updater.step()#自更新
            
            metric.add(
                float(l) * len(y), accuracy(y_hat, y),
                y.size().numel())
        else:
            # 使用定制的优化器和损失函数
            # 如果是自我实现的话，l出来就是向量，我们先做求和，再求梯度
            l.sum().backward()
            updater(X.shape[0])
            metric.add(float(l.sum()), accuracy(y_hat, y), y.numel())
    # 返回训练损失和训练准确率
    # metric[0]就是损失样本数目；metric[1]是训练正确的样本数；metric[2]是总的样本数
    return metric[0] / metric[2], metric[1] / metric[2]

3、实现一个训练函数，它会在train_iter 访问到的训练数据集上训练一个模型net

4、该训练函数将会运行多个迭代周期（由num_epochs指定）

def train_ch3(net, train_iter, test_iter, loss, num_epochs, updater):  #@save
    """训练模型（定义见第3章）。"""
    animator = Animator(xlabel='epoch', xlim=[1, num_epochs], ylim=[0.3, 0.9],
                        legend=['train loss', 'train acc', 'test acc'])
    
    
    # num_epochs：训练次数
    for epoch in range(num_epochs):
        #train_epoch_ch3：训练模型，返回准确度和错误度
        train_metrics = train_epoch_ch3(net, train_iter, loss, updater)
        #在测试数据集上评估精度
        test_acc = evaluate_accuracy(net, test_iter)
        
        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

5、作为一个从零开始的实现，我们使用 小批量随机梯度下降来优化模型的损失函数，设置学习率为0.1

lr = 0.1

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

6、现在，训练模型10个迭代周期。请注意，迭代周期（num_epochs）和学习率（lr）都是可调节的超参数。通过更改它们的值，我们可以提高模型的分类准确率。

#开始训练
num_epochs = 10
train_ch3(net, train_iter, test_iter, cross_entropy, num_epochs, updater)

　　

八、预测

给定一系列图像，比较它们的实际标签（文本输出的第一行）和模型预测（文本输出的第二行）

def predict_ch3(net, test_iter, n=6):  #@save
    """预测标签（定义见第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 + '\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)

标签：从零开始,回归,torch,iter,train,softmax,net,hat,metric
来源： https://www.cnblogs.com/xiaoqing-ing/p/15067636.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。