Pytorch笔记4：多层感知机实现MNIST数据集分类

最新推荐文章于 2023-06-16 19:29:59 发布
最新推荐文章于 2023-06-16 19:29:59 发布
阅读量5.6k 收藏 109
点赞数 27
分类专栏： Pytorch学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dxf1017524157/article/details/115433373
版权

文章目录

前言

复杂的神经网络也是由许多神经元组成，在深度学习领域，神经元即感知机。深度学习通过许多感知机，尽可能的学习一个任务的复杂数学表示。神经网络在模拟生物神经元时，创造性的引入非线性的函数，通过判断是否达到阈值，来觉得信号是否输出，完成信息传递。因此，在阶跃函数的基础上，进一步优化，拓展，得到sigmoid激活函数、Relu、leak ReLu等，细细品味，你将发现这构思的巧妙性、合理性。
本节主要MNIST的代码实现，关于感知机，激活函数等介绍，大家可以参考入手这本书，通俗易懂，内容详实，极具阅读价值。

pdf 地址如下，仅供学习参考：
链接: https://wwe.lanzous.com/ieOE2noazwj.

在这里插入图片描述

一、Torch相关包介绍

torch.nn ：完成神经网络一些相关操作，包含了在计算机视觉任务中常用到的卷积，池化等一些列API接口实现。
torch.nn.fubctional ： 可以比nn更进一步接触实现底层代码的修改。
torch.nn.optim：优化器，提供了学习率设置，及更好的梯度下降方式的选择。
torchvision：计算机视觉任务的工具，提供了常用的数据集，模型，转换函数等。实现视觉类任务如分类、目标检测、分割必不可少的。

导入所需包（示例）：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets,transforms

若提示出错，可使用命令行窗口，进行 conda install 安装。或者在pycharm中进行安装，以pycharm为例：输入要安装的包，点击安装即可。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、搭建多层感知机

1.MNIST介绍

MNIST简介: 包含0-9 共10个手写数字，每个数字由7000张（高度28*宽度28）的图像，将70k数据，分为了训练集60K，测试集10大小。本节，通过感知机实现对MNIST手写数字的分类。

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.下载MNIST数据集

如果下载失败，也可使用下载好的数据集，还在目录下：
链接: https://wwe.lanzous.com/b01c9d0sj.
密码:3dii
在这里插入图片描述
在这里插入图片描述

代码如下：

‘./data’：设置要保存的下载目录。
train=True：设置要下载的是60k的训练数据集。
download=True：如果当前文件夹没有数据集，则从网上下载。
transforms.ToTensor()：下载的数据集为numpy格式，需要转换为张量格式。
transforms.Normalize((0.1307,), (0.3081,)：（此项非必要设置项）为了更好的训练结果，因为图像的数据值是0-1之间，将数据值正则花在0左右，对模型梯度下降效果更好。
batch_size=batch_size, shuffle=True：设置批次大小，随机打算数据。
测试集设置类似

#MNIST 数据集
#设置训练的批次大小、学习率、及训练代数
batch_size=200
learning_rate=0.001
epochs=20


#下载数据集
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=False, download=True, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=batch_size, shuffle=True)

3.搭建神经网络层

1.权重和偏置

代码如下：

w1,b1：第一层网络感知机。输入图像大小是28*28=784，因此输入为784，输出设置为100（这个参数随意设置，可以尝试不同的数目查看效果）因为W要转置所以输入放后面，输出放前面。b1为第一层网络对应的偏置项。
w2, b2：与上叙述类似。
==w3, b3 ==：注意输出要与分类的10个数字类别数一致，其他与上述类似。
requires_grad=True：此项设置为True，表示要对w，b求梯度。

#生成 三个神经网络成，对应感知节分别为第一层100，第二成200，第三层10，即要分类的数目
w1, b1 = torch.randn(100, 784, requires_grad=True),\
         torch.zeros(100, requires_grad=True)
w2, b2 = torch.randn(200, 100, requires_grad=True),\
         torch.zeros(200, requires_grad=True)
w3, b3 = torch.randn(10, 200, requires_grad=True),\
         torch.zeros(10, requires_grad=True)

2.定义前向计算网络

代码如下：

relu激活函数：确保网络的非线性，实现更好的分类效果。

#定义前向网络计算，每层神经网络输出后增加relu激活函数，确保网络的非线性，实现更好的分类效果
def forward(x):
    x = x@w1.t() + b1
    x = F.relu(x)
    x = x@w2.t() + b2
    x = F.relu(x)
    x = x@w3.t() + b3
    x = F.relu(x)
    return x

3.定义梯度优化器及损失函数设置

代码如下：

.CrossEntropyLoss()：损失采用交叉熵损失函数。
.SGD：采用随机梯度下降，并设置学习率。

#定义优化器，采用SGD随机梯度下降的方式对w1, b1, w2, b2, w3, b3进行优化
optimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)
#定义采用交叉熵作为损失函数
criteon = nn.CrossEntropyLoss()

4.完成程序设计

代码如下：

#设置迭代次数
for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        #将数据打平为（批次，高度*宽度），-1代表所有
        data = data.view(-1, 28*28)
		
		#将数据输入到网络中
        cal_data = forward(data)
        #将计算的数据与目标数据求误差损失
        loss = criteon(cal_data, target)
		
		#将梯度值初始化为0
        optimizer.zero_grad()
        #pytorch计算梯度值
        loss.backward()
        #更新梯度值
        optimizer.step()
		#每隔25*batcsize(200) = 5000 打印输出结果
        if batch_idx % 25 == 0:
            print('训练代数: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))

	#将测试误差及正确率清0
    test_loss = 0
    correct = 0
    #取测试集数据及目标数据
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        logits = forward(data)
        #误差累加
        test_loss += criteon(logits, target).item()
		#取出预测最大值的索引编号，即预测值
        pred = logits.data.argmax(dim=1)
        #统计正确预测的个数
        correct += pred.eq(target.data).sum()

    test_loss /= len(test_loader.dataset)
    #打印输出测试误差及准确率
    print('\n测试集: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

三、完整代码程序

因为我们自己随机生成的初始化 w1,w2,w3，达到的性能并不好。所以我们可以采用大神何凯明的初始化权重对w1，w2，w3 进行初始化赋值,准确率可以达到90%。小伙伴们可以尝试下，将初始化赋值代码屏蔽，对比查看效果。

代码如下：

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets,transforms

#MNIST 数据集
#设置训练的批次大小、学习率、及训练代数
batch_size=200
learning_rate=0.001
epochs=20

#下载数据集
train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=True, download=True,
                   transform=transforms.Compose([
                       transforms.ToTensor(),
                       transforms.Normalize((0.1307,), (0.3081,))
                   ])),
    batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=False, download=True, transform=transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])),
    batch_size=batch_size, shuffle=True)

#生成三层神经网络成，对应感知机分别为第一层100，第二成200，第三层10，即要分类的数目
w1, b1 = torch.randn(100, 784, requires_grad=True),\
         torch.zeros(100, requires_grad=True)
w2, b2 = torch.randn(200, 100, requires_grad=True),\
         torch.zeros(200, requires_grad=True)
w3, b3 = torch.randn(10, 200, requires_grad=True),\
         torch.zeros(10, requires_grad=True)

#采用何凯明大神的初始化权重，准确率更高，权重的合理初始化很重要
torch.nn.init.kaiming_normal_(w1)
torch.nn.init.kaiming_normal_(w2)
torch.nn.init.kaiming_normal_(w3)

#定义前向网络计算，每层神经网络输出后增加relu激活函数，确保网络的非线性，实现更好的分类效果
def forward(x):
    x = x@w1.t() + b1
    x = F.relu(x)
    x = x@w2.t() + b2
    x = F.relu(x)
    x = x@w3.t() + b3
    x = F.relu(x)
    return x

#定义优化器，采用SGD随机梯度下降的方式对w1, b1, w2, b2, w3, b3进行优化
optimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)
#定义采用交叉熵作为损失函数
criteon = nn.CrossEntropyLoss()

# 设置迭代次数
for epoch in range(epochs):

    for batch_idx, (data, target) in enumerate(train_loader):
        # 将数据打平为（批次，高度*宽度），-1代表所有
        data = data.view(-1, 28 * 28)

        # 将数据输入到网络中
        cal_data = forward(data)
        # 将计算的数据与目标数据求误差损失
        loss = criteon(cal_data, target)

        # 将梯度值初始化为0
        optimizer.zero_grad()
        # pytorch计算梯度值
        loss.backward()
        # 更新梯度值
        optimizer.step()
        # 每隔25*batcsize(200) = 5000 打印输出结果
        if batch_idx % 25 == 0:
            print('训练代数: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                epoch, batch_idx * len(data), len(train_loader.dataset),
                       100. * batch_idx / len(train_loader), loss.item()))

    # 将测试误差及正确率清0
    test_loss = 0
    correct = 0
    # 取测试集数据及目标数据
    for data, target in test_loader:
        data = data.view(-1, 28 * 28)
        logits = forward(data)
        # 误差累加
        test_loss += criteon(logits, target).item()
        # 取出预测最大值的索引编号，即预测值
        pred = logits.data.argmax(dim=1)
        # 统计正确预测的个数
        correct += pred.eq(target.data).sum()

    test_loss /= len(test_loader.dataset)
    # 打印输出测试误差及准确率
    print('\n测试集: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        100. * correct / len(test_loader.dataset)))

输出结果：
在这里插入图片描述

总结

这一节，我们从底层搭建了一个三层的感知机神经网络，对手写数字数据集MNIST进行训练和测试，达到了92%的正确率。权重的随机初始化，对结果是很重要的，但在torch更高层的API使用中提供了很好的初始化，会在下一节中进行讲解。最后劳烦小伙伴，动手点个赞吧，给予我爆发小宇宙的能量。

尘世俗人zZ
关注
  • 27
    点赞
  • 踩
  • 109
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
感知机算法实现(使用MNIST数据集)_Python环境
05-16
在Python环境下实现感知机算法(使用MNIST数据集)，代码有详细注释，使用的是感知机算法的原始形式
多层感知机用于MNIST手写数字数据集分类
Red_Lotus_的博客
10-19 3027
  1、获取MNIST数据集，每张图片像素为28 x 28   2、模型架构为包含两个隐含层的多层感知机模型   输入层维度: 28x28 = 784   第一层隐含单元数: 256   第二层隐含单元数: 256   输出层维度: 10 (MNIST数据集类别数，分别为0到9)   3、画出训练和测试过程的准确率随迭代次数变化图，画出训练和测试过程的损失随迭代次数变化图。(提交最终 分类精度、分类损失以及两张变化图)    from tensorflow.examples.tutorials.mnist
mnist——多层感知机
11-28 151
import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data mnist=input_data.read_data_sets("MNIST_data/", one_hot=True) sess=tf.InteractiveSession() in_units=784 h1...
利用主成分分析法和多层感知机(MLP)实现MNIST数据集分类
LittleCAIyuan的博客
01-06 1052
利用主成分分析法和多层感知机(MLP)实现MNIST数据集分类
多层感知机MLP的gluon版分类minist
weixin_33725272的博客
11-26 97
MLP_Gluon In[2]: import gluonbook as gb from mxnet import gluon, init from mxnet.gluon import loss as gloss,nn In[4]: net...
基于Pytorch实现MNIST手写数字数据集识别（源码+数据）.rar
05-06
1、资源内容：基于Pytorch实现MNIST手写数字数据集识别（源码+数据）.rar 2、适用人群：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业或毕业设计，作为“参考资料”使用。 3、更多仿真源码和数据集...
Variational-Autoencoder-in-Pytorch:Pytorch中针对MNIST数据集的VAE实现
04-14
Pytorch中针对MNIST数据集的VAE实现 嘿大家！ 在这里，我将展示我创建VAE来复制MNIST数据集的项目的所有代码 目录 基本信息 该项目的灵感来自Sovit Ranjan Rath的文章 技术领域 使用以下项目创建项目： Python版本...
用Pytorch实现MNIST数据集的手写数字识别介绍
03-29
我们将使用PyTorch来搭建一个简单的卷积神经网络（CNN）来对MNIST数据集进行分类。CNN是一种广泛应用于图像识别方面的深度学习网络类型，目前已经在很多领域取得了优秀的表现。 ### 步骤 1. 下载MNIST数据集 2. ...
pytorch:实现简单的GAN示例(MNIST数据集)
09-18
今天小编就为大家分享一篇pytorch:实现简单的GAN示例(MNIST数据集)，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Pytorch使用MNIST数据集实现基础GAN和DCGAN详解
09-18
今天小编就为大家分享一篇Pytorch使用MNIST数据集实现基础GAN和DCGAN详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
TensorFlow多层感知机实现MNIST数据分类
诚朴勇毅
10-17 406
Tensorflow中专门的函数可以帮助我们轻松的定义神经网络的连接层，例如我们定义一个包含一个隐层的神经网络 import tensorflow.contrib.layers as layers def multilayer_perceptron(x): fc1 = layers.fully_connected(x, n_hidden, activation_fn = tf.nn.relu, biases_initializer = tf.zeros_initializer(), scope
（pytorch-深度学习系列）pytorch实现多层感知机（手动定义模型）对Fashion-MNIST数据集进行分类-学习笔记
我亦是行人
10-14 1633
pytorch实现多层感知机对Fashion-MNIST数据集进行分类（手动定义模型） 多层感知机： 多层感知机在单层神经网络的基础上引入了一到多个隐藏层（hidden layer）。隐藏层位于输入层和输出层之间。 输入和输出个数分别为4和3，中间的隐藏层中包含了5个隐藏单元，输入层不涉及计算，多层感知机的层数为2，隐藏层中的神经元和输入层中各个输入完全连接，输出层中的神经元和隐藏层中的各个神经元也完全连接。因此，多层感知机中的隐藏层和输出层都是全连接层。 多层感知机就是含有至少一个隐藏层的由全连接层组成
感知机算法实现二分类和多分类（手写数字Minist）
m0_58058919的博客
08-16 2260
1、从Minist测试集中抽取1000张训练图片（前5000），200张测试图片（后5000），对应的数字是[8,4],同时将label转化为[1,-1]2.2、更新权值w(这里是一张一张图片进行计算，并不是每次计算都会更新权值，只有当yi*（w*x+b）...
Pytorch使用多层感知机完成MNIST手写数字识别（更新：LeNet实现Fashion-MNIST识别）
qq_43858783的博客
06-16 2416
利用Pytorch使用多层感知机完成MNIST手写数字识别
多层感知机实现mnist识别（tensorflow 1.x）
weixin_49732545的博客
09-12 319
模型 代码 import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("MNIST_data",one_hot="True") # 超参数 learning_rate=0.1 num_steps = 500 batch_size = 128 display_step = 100 #神经网络参数 n_hidden_1 = 256 #
多层感知器的数据分类的过程
li1103192570的专栏
04-09 7390
多层感知器就是我们称的BP哇刚落
多层感知器实现MNIST数据集手写字体识别
lyuecheng的博客
01-17 615
多层感知器实现MNIST数据集手写字体识别
机器学习一 基于感知机模型实现对mnist数据集的分类
凌阳的博客
03-25 1537
原理分析 ①感知机 原理 设输入空间（特征空间）为 X ⊆ R ,输出空间为Y = { − 1 , + 1 } ，输入 x ∈ X为实例的特征向量 输出 y ∈ Y为实例的类别，由输入空间到输出空间的如下函数称为感知机 f(x) = sign(wx+b) 其中w和b为模型参数，w ∈ R n 称为权值，b ∈ R b称为偏置。sign是符号函数。 感知机模型有直观的几何解释：线性方程 w x + b = 0对应于分离超平面S,其中w为S...
[动手学深度学习(PyTorch)]——多层感知机
weixin_42067873的博客
03-14 2887
之前不会的一个知识点： (2条消息) python----引用其他py文件中的函数_qq_41978536的博客-CSDN博客_python引用其他py文件的函数 一、感知机 1、单层感知机 给定输入x，权重w，和偏移b，感知机输出。相比线性回归加入了激活函数。 感知机是一个二分类的模型 可以解决线性分类问题，但是感知机不能拟合XOR问题，因为他只能产生线性分割面 2、多层感知机 多层感知机引入了隐藏层。多层感知机的层数是去除输入层后的层数。 隐藏层的大小是超参数 激活函数：激
多层感知机mnist手写数字数据集分类
最新发布
10-18
好的，针对您的问题，我可以给出以下的解答： 多层感知机（Multilayer Perceptron，MLP）是一种前馈神经网络，常用于分类和回归问题。MNIST手写数字数据集是一个常用的分类问题数据集，包含了60,000个训练样本和10,000个测试样本，每个样本都是一个28x28像素的灰度图像，代表了0到9中的一个数字。 在使用多层感知机对MNIST数据集进行分类时，可以将每个像素点作为一个特征输入到神经网络中。一般来说，可以使用两个或多个隐藏层来提高模型的性能。在训练过程中，可以使用交叉熵损失函数和反向传播算法来更新神经网络的权重和偏置。 以下是一个使用PyTorch实现的简单的多层感知机模型： ```python import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms # 定义超参数 batch_size = 64 learning_rate = 0.01 num_epochs = 10 # 加载MNIST数据集 train_dataset = datasets.MNIST(root='./data', train=True, transform=transforms.ToTensor(), download=True) test_dataset = datasets.MNIST(root='./data', train=False, transform=transforms.ToTensor()) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False) # 定义多层感知机模型 class MLP(nn.Module): def __init__(self): super(MLP, self).__init__() self.fc1 = nn.Linear(28*28, 256) self.fc2 = nn.Linear(256, 128) self.fc3 = nn.Linear(128, 10) self.relu = nn.ReLU() def forward(self, x): x = x.view(-1, 28*28) x = self.relu(self.fc1(x)) x = self.relu(self.fc2(x)) x = self.fc3(x) return x # 定义损失函数和优化器 model = MLP() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=learning_rate) # 训练模型 for epoch in range(num_epochs): for i, (images, labels) in enumerate(train_loader): images = images.reshape(-1, 28*28) outputs = model(images) loss = criterion(outputs, labels) optimizer.zero_grad() loss.backward() optimizer.step() if (i+1) % 100 == 0: print('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, i+1, len(train_loader), loss.item())) # 测试模型 with torch.no_grad(): correct = 0 total = 0 for images, labels in test_loader: images = images.reshape(-1, 28*28) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the model on the 10000 test images: {} %'.format(100 * correct / total)) ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值