首页 > 其他分享 >【基于PyTorch的简单多层感知机（MLP）神经网络（深度学习经典代码实现）】

【基于PyTorch的简单多层感知机（MLP）神经网络（深度学习经典代码实现）】

时间：2024-11-21 18:18:49浏览次数：3  
标签：loss nn self torch MLP 感知机 PyTorch train test 

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim
#准备数据集
batch_size=64
transform=transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307, ),(0.3081, ))
])
train_dataset=datasets.MNIST(root=r'D:\Python-Code\深度学习\data\MNIST',
                             train=True,
                             download=True,
                             transform=transform)
train_loader=DataLoader(train_dataset,
                        shuffle=True,
                        batch_size=batch_size)


test_dataset=datasets.MNIST(root=r'D:\Python-Code\深度学习\data\MNIST',
                             train=False,
                             download=True,
                             transform=transform)
test_loader=DataLoader(test_dataset,
                       shuffle=False,
                       batch_size=batch_size)
#设计模型
class Net(torch.nn.Module):
    def __init__(self):
        super(Net,self).__init__()
        self.l1=torch.nn.Linear(784,512)
        self.l2=torch.nn.Linear(512,256)
        self.l3=torch.nn.Linear(256,128)
        self.l4=torch.nn.Linear(128,64)
        self.l5=torch.nn.Linear(64,10)
    def forward(self,x):
        x=x.view(-1,784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)
model=Net()
## 损失函数和优化器
criterion=torch.nn.CrossEntropyLoss()#交叉熵损失
optimizer=optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

#训练
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):
        inputs,target=data
        optimizer.zero_grad()
        #forward+backward+update
        outputs=model(inputs)
        loss=criterion(outputs,target)
        loss.backward()
        optimizer.step()

        running_loss+=loss.item()
        if batch_idx%300==299:
            print('[%d,%5d] loss:%.3f' %(epoch+1,batch_idx+1,running_loss/300))
            running_loss=0.0

#测试
def test():
    correct=0
    total=0
    with torch.no_grad():
        for data in test_loader:
            images,labels=data
            outputs=model(images)
            _,predicted=torch.max(outputs.data,dim=1)
            total+=labels.size(0)
            correct+=(predicted==labels).sum().item()
    print('Accuracy on test set: %d %%' %(100*correct/total))

if __name__=='__main__':
    for epoch in range(10):
        train(epoch)
        test()

这段代码实现了一个基于PyTorch的简单多层感知机（MLP）神经网络，用于MNIST手写数字识别任务。以下是代码的详细解释：
导入库

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

● torch：PyTorch的主库。
● torchvision：提供常用的计算机视觉数据集和数据预处理方法。
● torch.nn.functional：包含激活函数等神经网络功能。
● torch.optim：提供各种优化器，例如随机梯度下降（SGD）。
准备数据集

batch_size = 64
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

● batch_size：每个批次的样本数。
● transforms.Compose：将多个数据转换步骤组合。
○ transforms.ToTensor()：将图片数据转为Tensor，并将像素值缩放到[0, 1]。
○ transforms.Normalize()：归一化，使数据符合标准正态分布，均值为0.1307，标准差为0.3081，这些数值是对MNIST训练集计算得到的。

train_dataset = datasets.MNIST(root=r'D:\Python-Code\深度学习\data\MNIST', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)

● datasets.MNIST：加载MNIST训练集。
○ root：数据存放路径。
○ train=True：加载训练集。
○ download=True：如果数据不存在则自动下载。
○ transform=transform：指定数据预处理方式。
● DataLoader：加载数据并生成批次，支持随机打乱。

test_dataset = datasets.MNIST(root=r'D:\Python-Code\深度学习\data\MNIST', train=False, download=True, transform=transform)
test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

● datasets.MNIST：加载MNIST测试集。
● shuffle=False：测试集数据顺序不打乱。
定义模型

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)

● 该模型是一个5层的多层感知机（MLP），每一层由torch.nn.Linear创建的线性层构成。
○ 784：输入层大小（28×28像素的MNIST图像展平）。
○ 512、256、128、64：每层的神经元数。
○ 10：输出层的神经元数，表示10个类别（数字0-9）。

def forward(self, x):
    x = x.view(-1, 784)
    x = F.relu(self.l1(x))
    x = F.relu(self.l2(x))
    x = F.relu(self.l3(x))
    x = F.relu(self.l4(x))
    return self.l5(x)

● x.view(-1, 784)：将输入图像展平为1维向量。
● F.relu：ReLU激活函数，用于添加非线性。
● self.l5(x)：最后一层的输出，得到10个类别的分数。
损失函数和优化器

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

● torch.nn.CrossEntropyLoss()：计算交叉熵损失，适合用于分类问题。
● optim.SGD：使用带动量的随机梯度下降（SGD）优化器。
训练过程

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
        
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0

● optimizer.zero_grad()：清空梯度缓存。
● outputs = model(inputs)：前向传播，得到预测值。
● loss.backward()：计算梯度。
● optimizer.step()：更新模型参数。
● print：每300个批次输出一次平均损失。
测试过程

def test():
    correct = 0
    total = 0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))

● torch.no_grad()：测试时不计算梯度，减少内存占用。
● torch.max(outputs.data, dim=1)：选择输出中最大值的索引，作为预测类别。
● correct：累加预测正确的样本数。
● print：输出测试集的准确率。
主函数

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

● 进行10轮训练，每轮训练结束后进行测试。
实验结果：
[1, 300] loss:2.239
[1, 600] loss:0.976
[1, 900] loss:0.409
Accuracy on test set: 90 %
[2, 300] loss:0.311
[2, 600] loss:0.273
[2, 900] loss:0.230
Accuracy on test set: 94 %
[3, 300] loss:0.193
[3, 600] loss:0.170
[3, 900] loss:0.151
Accuracy on test set: 95 %
[4, 300] loss:0.132
[4, 600] loss:0.115
[4, 900] loss:0.117
Accuracy on test set: 96 %
[5, 300] loss:0.089
[5, 600] loss:0.098
[5, 900] loss:0.091
Accuracy on test set: 97 %
[6, 300] loss:0.073
[6, 600] loss:0.075
[6, 900] loss:0.073
Accuracy on test set: 97 %
[7, 300] loss:0.056
[7, 600] loss:0.064
[7, 900] loss:0.057
Accuracy on test set: 97 %
[8, 300] loss:0.045
[8, 600] loss:0.048
[8, 900] loss:0.050
Accuracy on test set: 97 %
[9, 300] loss:0.038
[9, 600] loss:0.040
[9, 900] loss:0.040
Accuracy on test set: 97 %
[10, 300] loss:0.031
[10, 600] loss:0.030
[10, 900] loss:0.033
Accuracy on test set: 97 %

标签：loss,nn,self,torch,MLP,感知机,PyTorch,train,test
From： https://blog.csdn.net/RG_xwz/article/details/143923303

相关文章

  • 神经网络（系统性学习三）：多层感知机（MLP）
    相关文章：神经网络中常用的激活函数神经网络（系统性学习一）：入门篇神经网络（系统性学习二）：单层神经网络（感知机）多层感知机（MLP）多层感知机（MLP）是一种经典的前馈神经网络（FeedforwardNeuralNetwork），通常用于解决分类、回归、监督学习任务。它由一个输入层、一个或多个隐藏层和一个输......
  • Open-RAG：将开源LLM模型集成为高效RAG模型 | ENMLP'24
    本文是对公开论文的核心提炼，旨在进行学术交流。如有任何侵权问题，请及时联系号主以便删除。来源：晓飞的算法工程笔记公众号，转载请注明出处论文:Open-RAG:EnhancedRetrieval-AugmentedReasoningwithOpen-SourceLargeLanguageModels论文地址：https://arxiv.org/abs/24......
  • RNN (循环神经网络 - 从mlp到rnn - 困惑度 - 梯度剪裁) + 代码实现 —— 笔记3.4《动
    0.前言课程全部代码（pytorch版）已上传到附件本章节为原书第8章(循环神经网络)，共分为7节，本篇是第4-6节：RNNRNN从零实现RNN简洁实现本节(4-6节)的代码位置为：chapter_recurrent-neural-networks/rnn.ipynbchapter_recurrent-neural-networks/rnn-scratch.ipynbchapte......
  • PyTorch基础学习01_创建张量&常见属性&数据转换&图像
    目录一、PyTorch——经典的深度学习框架1、 PyTorch简介2、其他常见深度学习框架3、安装二、Tensor概述1、张量概念2、数据类型三、Tensor创建1、基本创建方式 2、创建线性和随机张量3、创建全0、全1张量 4、创建指定值张量5、创建单位张量 四、Tensor常见属......
  • 深入解析 PyTorch 的 BatchNorm2d：原理与实现
    在深度学习中，BatchNormalization是一种常用的技术，用于加速网络训练并稳定模型收敛。本文将结合一个具体代码实例，详细解析PyTorch中BatchNorm2d的实现原理，同时通过手动计算验证其计算过程，帮助大家更直观地理解BatchNorm的工作机制。1.BatchNormalization的基本原理1.......
  • PyTorch深度学习在医学影像端到端判别项目中的应用：构建企业级解决方案
    PyTorch深度学习在医学影像端到端判别项目中的应用：构建企业级解决方案随着深度学习技术的飞速发展，其在医学影像分析领域的应用日益广泛。本文将介绍如何使用PyTorch框架开发一个企业级的医学影像端到端判别项目，该项目旨在通过深度学习模型对医学影像进行自动分类和诊断，提高医疗诊......
  • 神经网络（系统性学习二）：单层神经网络（感知机）
    此前篇章：神经网络中常用的激活函数神经网络（系统性学习一）：入门篇单层神经网络（又叫感知机）单层网络是最简单的全连接神经网络，它仅有输入层和输出层，没有隐藏层。即，网络的所有输入直接影响到输出。结构：输入层→输出层特点：只适用于线性可分问题。即，单层网络只能学习并解决......
  • 零基础 AI 入门实战（深度学习 + Pytorch）
    零基础AI入门实战（深度学习+Pytorch）一、引言在当今这个科技飞速发展的时代，人工智能（AI）已经渗透到了我们生活和工作的方方面面。深度学习作为AI领域中的强大技术，更是展现出了巨大的应用潜力。而Pytorch作为一款广受欢迎的深度学习框架，为我们实现各种AI应用提供了便捷的工......
  • 基于yolov10的草莓成熟度检测系统，支持图像、视频和摄像实时检测【pytorch框架、python
     更多目标检测和图像分类识别项目可看我主页其他文章功能演示：yolov10，草莓成熟度检测系统，支持图像、视频和摄像实时检测【pytorch框架、python】_哔哩哔哩_bilibili（一）简介基于yolov10的草莓成熟度检测系统是在pytorch框架下实现的，这是一个完整的项目，包括代码，数据集，训练好的......
  • 哋它亢编程语言机器学习框架（如TensorFlow、PyTorch等）
    “哋它亢”作为一种新一代机器学习与深度学习的编程语言，虽然现实中并不存在这种语言，但我们可以基于其被假定为高性能和强编程能力的特性，来构想其可能的优势，并尝试给出一个示例代码。以下是对“哋它亢”编程语言优势的详细阐述及示例代码。哋它亢编程语言“哋它亢”编程语言的优......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99