李沐深度学习-softmax的简洁实现

最新推荐文章于 2024-05-21 20:35:44 发布

大小猫吃猫饼干

最新推荐文章于 2024-05-21 20:35:44 发布

阅读量378

点赞数 8

分类专栏：李沐深度学习编码实现文章标签：深度学习人工智能

本文链接：https://blog.csdn.net/qq_43401942/article/details/135697532

版权

李沐深度学习编码实现专栏收录该内容

26 篇文章 0 订阅

订阅专栏

本文介绍了如何使用PyTorch库对FashionMNIST数据集进行线性网络模型的构建、参数初始化、损失函数应用、优化器选择以及训练和测试过程。

摘要由CSDN通过智能技术生成

import torch
import numpy as np
import torchvision
from torch import nn
from torch.nn import init
import torchvision.transforms as transforms
import torch.utils.data as Data
import sys

sys.path.append("路径")
import d2lzh_pytorch as d2l

# --------------------获取和读取数据
batch_size = 256
train_mnist = torchvision.datasets.FashionMNIST(root='路径',
                                                download=True, train=True, transform=transforms.ToTensor())
test_mnist = torchvision.datasets.FashionMNIST(root='路径',
                                               train=False, download=True, transform=transforms.ToTensor())
# 得到小批量的元组格式数据
train_iter = Data.DataLoader(train_mnist, batch_size=batch_size, shuffle=True, num_workers=4)
test_iter = Data.DataLoader(test_mnist, batch_size=batch_size, shuffle=False, num_workers=4)

num_inputs = 784
num_outputs = 10


# 定义初始化模型
class LinearNet(nn.Module):
    def __init__(self, num_inputs, num_outputs):
        super(LinearNet, self).__init__()
        self.linear = nn.Linear(num_inputs, num_outputs)
        # softmax函数不在这里最外层使用，而是被pytorch集成在了一个损失函数中

    def forward(self, X):  # x shape:1x28x28
        X = self.linear(X.view(X.shape[0], -1))  # 要将X转换成（batch_size,784）的形状,进行线性运算
        return X


net = LinearNet(num_inputs, num_outputs)

# -------------------------------初始化网络模型参数
init.normal_(net.linear.weight, mean=0, std=0.01)
init.constant_(net.linear.bias, val=0)

# ---------------------softmax和交叉熵损失函数
# 该函数包含了softmax运算和交叉熵损失计算
loss = torch.nn.CrossEntropyLoss()

# --------------------定义优化算法
optimizer = torch.optim.SGD(net.parameters(), lr=0.1)

# ------------------------训练模型
num_epochs = 100


def train():
    for epoch in range(num_epochs):
        train_loss, train_acc, n, num, test_acc = 0.0, 0.0, 0, 0, 0.0
        for X, y in train_iter:  # 一个循环代表一个训练过程，模型的参数得到了调整
            train_l = loss(net(X), y)
            optimizer.zero_grad()
            train_l.backward()
            optimizer.step()
            n += X.shape[0]
            num += 1
            train_loss += train_l.item()
            train_acc += (((net(X).argmax(dim=1)) == y).sum().item())
        test_ac = d2l.evaluate_accuracy(test_iter, net)
        print(f'epoch %d, loss %.4f, train_acc %.3f, test_ac %.3f'
              % (epoch, train_loss / num, train_acc / n, test_ac))


train()

with torch.no_grad():
    test_acc, n = 0, 0
    for X, y in test_iter:
        test_acc += (net(X).argmax(dim=1) == y).float().sum().item()
        n += y.shape[0]