1. Python技术站首页
  2. Python开发

使用cnn,bpnn,lstm实现mnist数据集的分类

• Python开发

1.cnn

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

# 设置随机数种子
torch.manual_seed(0)

# 超参数
EPOCH = 1  # 训练整批数据的次数
BATCH_SIZE = 50
DOWNLOAD_MNIST = False  # 表示还没有下载数据集，如果数据集下载好了就写False

# 加载 MNIST 数据集
train_dataset = datasets.MNIST(
    root="./mnist",
    train=True,#True表示是训练集
    transform=transforms.ToTensor(),
    download=False)
test_dataset = datasets.MNIST(
    root="./mnist",
    train=False,#Flase表示测试集
    transform=transforms.ToTensor(),
    download=False)

# 将数据集放入 DataLoader 中
train_loader = torch.utils.data.DataLoader(
    dataset=train_dataset,
    batch_size=100,#每个批次读取的数据样本数
    shuffle=True)#是否将数据打乱，在这种情况下为True，表示每次读取的数据是随机的
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_dataset.test_data, dim=1).type(torch.FloatTensor)[
         :2000] / 255.  # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_dataset.test_labels[:2000]

# 定义卷积神经网络模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(#输入图像的大小为（28,28,1）
            in_channels=1,#当前输入特征图的个数
            out_channels=32,#输出特征图的个数
            kernel_size=3,#卷积核大小，在一个3*3空间里对当前输入的特征图像进行特征提取
            stride=1,#步长：卷积窗口每隔一个单位滑动一次
            padding=1)#如果希望卷积后大小跟原来一样，需要设置padding=(kernel_size-1)/2
        #第一层结束后图像大小为（28,28,32）32是输出图像个数，28计算方法为（h-k+2p)/s+1=(28-3+2*1)/1 +1=28
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)#可以缩小输入图像的尺寸，同时也可以防止过拟合
        #通过池化层之后图像大小变为（14,14,32）
        self.conv2 = nn.Conv2d(#输入图像大小为（14,14,32）
            in_channels=32,#第一层的输出特征图的个数当做第二层的输入特征图的个数
            out_channels=64,
            kernel_size=3,
            stride=1,
            padding=1)#二层卷积之后图像大小为（14,14,64)

        self.fc = nn.Linear(64 * 7 * 7, 10)#10表示最终输出的

    # 下面定义x的传播路线
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))# x先通过conv1
        x = self.pool(F.relu(self.conv2(x)))# 再通过conv2
        x = x.view(-1, 64 * 7 * 7)
        x = self.fc(x)
        return x

# 实例化卷积神经网络模型
model = CNN()

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
#lr（学习率）是控制每次更新的参数的大小的超参数
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(1):
    for i, (images, labels) in enumerate(train_loader):
        outputs = model(images)  # 先将数据放到cnn中计算output
        loss = criterion(outputs, labels)# 输出和真实标签的loss，二者位置不可颠倒
        optimizer.zero_grad()# 清除之前学到的梯度的参数
        loss.backward()  # 反向传播，计算梯度
        optimizer.step()#应用梯度
        if i % 50 == 0:
            data_all = model(test_x)#不分开写就会出现ValueError: too many values to unpack (expected 2)
            last_layer = data_all
            test_output = data_all
            pred_y = torch.max(test_output, 1)[1].data.numpy()
            accuracy = float((pred_y == test_y.data.numpy()).astype(int).sum()) / float(test_y.size(0))
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.numpy(), '| test accuracy: %.4f' % accuracy)

# print 10 predictions from test data
data_all1 = model(test_x[:10])
test_output = data_all1
_ = data_all1
pred_y = torch.max(test_output, 1)[1].data.numpy()
print(pred_y, 'prediction number')
print(test_y[:10].numpy(), 'real number')

2.bpnn

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import torchvision
DOWNLOAD_MNIST = False  # 表示还没有下载数据集，如果数据集下载好了就写False
BATCH_SIZE = 50
LR = 0.01  # 学习率
# 下载mnist手写数据集
train_loader = torchvision.datasets.MNIST(
    root='./mnist/',  # 保存或提取的位置  会放在当前文件夹中
    train=True,  # true说明是用于训练的数据，false说明是用于测试的数据
    transform=torchvision.transforms.ToTensor(),  # 转换PIL.Image or numpy.ndarray

    download=DOWNLOAD_MNIST,  # 已经下载了就不需要下载了
)

test_loader = torchvision.datasets.MNIST(
    root='./mnist/',
    train=False  # 表明是测试集
)
train_data = torch.utils.data.DataLoader(dataset=train_loader, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_loader.test_data, dim=1).type(torch.FloatTensor)[
         :2000] / 255.  # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_loader.test_labels[:2000]

# 定义模型
class BPNN(nn.Module):
    def __init__(self):
        super(BPNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 512)#定义了一个全连接层fc1，该层的输入是28 * 28个数字，输出是512个数字
        self.fc2 = nn.Linear(512, 512)
        self.fc3 = nn.Linear(512, 10)

    def forward(self, x):#x是输入的图像
        x = x.view(-1, 28 * 28)#将输入x的形状转换为二维，分别是batch_size和28 * 28
        x = F.relu(self.fc1(x))#将x通过第1个全连接层fc1进行计算，并将结果通过ReLU激活函数处理
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        #Softmax函数是一种分类模型中常用的激活函数，它能将输入数据映射到(0,1)范围内，并且满足所有元素的和为1
        return F.log_softmax(x, dim=1)#dim=1表示对每一行的数据进行运算

# 初始化模型
bpnn = BPNN()
print(bpnn)
# 定义损失函数和优化器
optimizer = torch.optim.Adam(bpnn.parameters(), lr=LR)  # optimize all parameters
loss_func = nn.CrossEntropyLoss()  # the target label is not one-hotted
#
# criterion = nn.NLLLoss()
# optimizer = optim.SGD(bpnn.parameters(), lr=0.01, momentum=0.5)

# 训练模型
for epoch in range(1):
    for step, (b_x,b_y) in enumerate(train_data):
        b_x = b_x.view(-1, 28, 28)  # reshape x to (batch, time_step, input_size)

        output = bpnn(b_x)
        loss = loss_func(output, b_y)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        if step % 50 == 0:
            test_x = test_x.view(-1, 28, 28)
            test_output = bpnn(test_x)
            pred_y = torch.max(test_output, 1)[1].data.squeeze()
            acc = (pred_y == test_y).sum().float() / test_y.size(0)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy())

test_output = bpnn(test_x[:10].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')
# # 评估模型
# bpnn.eval()
# correct = 0
# with torch.no_grad():
#     for data, target in test_loader:
#         output = bpnn(data)
#         pred = output.argmax(dim=1, keepdim=True)
#         correct += pred.eq(target.view_as(pred)).sum().item()
#
# print('Test accuracy:', correct / len(test_loader.dataset))

3.lstm

import torch
from torch import nn
import torchvision.datasets as dsets
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

torch.manual_seed(1)  # reproducible

# Hyper Parameters
EPOCH = 1  # 训练整批数据多少次, 为了节约时间, 我们只训练一次
BATCH_SIZE = 64
TIME_STEP = 28  # rnn 时间步数 / 图片高度
INPUT_SIZE = 28  # rnn 每步输入值 / 图片每行像素
LR = 0.01  # learning rate
DOWNLOAD_MNIST = False  # 如果你已经下载好了mnist数据就写上 Fasle

# Mnist 手写数字
train_data = dsets.MNIST(
    root='./mnist/',  # 保存或者提取位置
    train=True,  # this is training data
    transform=transforms.ToTensor(),  # 转换 PIL.Image or numpy.ndarray 成
    # torch.FloatTensor (C x H x W), 训练的时候 normalize 成 [0.0, 1.0] 区间
    download=DOWNLOAD_MNIST,  # 没下载就下载, 下载了就不用再下了
)

test_data = dsets.MNIST(root='./mnist/', train=False)

# 批训练 50samples, 1 channel, 28x28 (50, 1, 28, 28)
train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)

# 为了节约时间, 我们测试时只测试前2000个
test_x = torch.unsqueeze(test_data.test_data, dim=1).type(torch.FloatTensor)[
         :2000] / 255.  # shape from (2000, 28, 28) to (2000, 1, 28, 28), value in range(0,1)
test_y = test_data.test_labels[:2000]

#LSTM默认input(seq_len,batch,feature)
class Lstm(nn.Module):
    def __init__(self):
        super(Lstm, self).__init__()

        self.Lstm = nn.LSTM(  # LSTM 效果要比 nn.RNN() 好多了
            input_size=28,  # 图片每行的数据像素点,输入特征的大小
            hidden_size=64,  # lstm模块的数量相当于bp网络影藏层神经元的个数
            num_layers=1,  # 隐藏层的层数
            batch_first=True,  # input & output 会是以 batch size 为第一维度的特征集 e.g. (batch, time_step, input_size)
        )

        self.out = nn.Linear(64, 10)  # 输出层，接入线性层

    def forward(self, x):  # 必须有这个方法
        # x shape (batch, time_step, input_size)
        # r_out shape (batch, time_step, output_size)包含每个序列的输出结果
        # h_n shape (n_layers, batch, hidden_size)只包含最后一个序列的输出结果，LSTM 有两个 hidden states, h_n 是分线, h_c 是主线
        # h_c shape (n_layers, batch, hidden_size)只包含最后一个序列的输出结果
        r_out, (h_n, h_c) = self.Lstm(x, None)  # None 表示 hidden state 会用全0的 state
        # 当RNN运行结束时刻，(h_n, h_c)表示最后的一组hidden states，这里用不到

        # 选取最后一个时间点的 r_out 输出
        # 这里 r_out[:, -1, :] 的值也是 h_n 的值
        out = self.out(r_out[:, -1, :])  # (batch_size, time step, input)，这里time step选择最后一个时刻
        # output_np = out.detach().numpy()  # 可以使用numpy的sciview监视每次结果
        return out


Lstm = Lstm()
print(Lstm)

optimizer = torch.optim.Adam(Lstm.parameters(), lr=LR)  # optimize all parameters
loss_func = nn.CrossEntropyLoss()  # the target label is not one-hotted

# training and testing
for epoch in range(EPOCH):
    for step, (x, b_y) in enumerate(train_loader):  # gives batch data
        b_x = x.view(-1, 28, 28)  # reshape x to (batch, time_step, input_size)

        output = Lstm(b_x)  # rnn output
        loss = loss_func(output, b_y)  # cross entropy loss
        optimizer.zero_grad()  # clear gradients for this training step
        loss.backward()  # backpropagation, compute gradients
        optimizer.step()  # apply gradients

        # output_np = output.detach().numpy()

        if step % 50 == 0:
            test_x = test_x.view(-1, 28, 28)
            test_output = Lstm(test_x)
            pred_y = torch.max(test_output, 1)[1].data.squeeze()
            acc = (pred_y == test_y).sum().float() / test_y.size(0)
            print('Epoch: ', epoch, '| train loss: %.4f' % loss.data.float(), 'test acc: ', acc.numpy())

test_output = Lstm(test_x[:10].view(-1, 28, 28))
pred_y = torch.max(test_output, 1)[1].data.numpy().squeeze()
print(pred_y, 'prediction number')
print(test_y[:10], 'real number')

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：使用cnn,bpnn,lstm实现mnist数据集的分类 - Python技术站

赞 (0)
0 0 打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
上一篇 2023年3月31日
下一篇 2023年3月31日

相关文章

  • 机器学习实战-Logistic回归 Python开发

    机器学习实战-Logistic回归

    1.基于 Logistic 回归和 Sigmoid 函数的分类 逻辑回归适合于01情况的分类就是描述一个问题是或者不是，所以就引入sigmoid函数，因为这个函数可以将所有值变成0-1之间的一个值，这样就方便算概率首先我们可以先看看Sigmoid函数(又叫Logistic函数)将任意的输入映射到了[0,1]区间我们在线性回归中可以得到一个预测值，再将该值映射…

    2023年4月2日
    00
  • 机器学习实战-决策树 Python开发

    机器学习实战-决策树

    1.决策树的构造 1.1优缺点 优点: 计算复杂度不高：以ID3为例，每次运算都是基于某一列特征，特征计算完后，下次计算不考虑该最有特征，并且通过适当剪枝可以简化复杂度 输出结果易于理解：因为输出的是一个树的结构，树的走向一目了然 对中间值的缺失不敏感 可以处理不相关特 征数据：是基于每列特征来计算，不考虑特征之间的依赖关系 缺点:可能会产生过度匹配问题。适…

    2023年4月2日
    00
  • knn算法详解 Python开发

    knn算法详解

    1.什么是knn算法 俗话说：物以类聚，人以群分。看一个人什么样，看他身边的朋友什么样就知道了(这里并没歧视谁，只是大概率是这样) 对于判断下图绿色的球是哪种数据类型的方法就是根据寻找他最近的k个数据，根据k的值来推测新数据的类型。 比如下图离绿球最近的红三角有两个，蓝方块有一个，因此推测绿色的球为红色的三角，这就是knn算法的思想 2.算法原理 2.1通用…

    2023年4月2日
    00
  • 机器学习实战-朴素贝叶斯 Python开发

    机器学习实战-朴素贝叶斯

    1.优缺点 优点: 在数据较少的情况下仍然有效， 可以处理多类别问题。 缺点: 对于输入数据的准备方式较为敏感。 适用数据类型:标称型数据 2.朴素贝叶斯的一般过程 (1) 收集数据:可以使用任何方法。本章使用RSS源。(2) 准备数据:需要数值型或者布尔型数据。(3) 分析数据:有大量特征时，绘制特征作用不大，此时使用直方图效果更好。(4) 训练算法:计算…

    2023年4月2日
    00
  • 机器学习实战-支持向量机 Python开发

    机器学习实战-支持向量机

    1.支持向量机简介 英文名为Support Vector Machine简称为SVM，是一种二分类模型 线性可分支持向量机：如下图就可以通过一条红色的直线将蓝色的球和红色的球完全区分开，该直线被称为线性分类器，如果是高维的，就可以通过一个超平面将三维立体空间里的样本点给分开。通过硬间隔最大化，学习一个线性分类器。 线性支持向量机：如下图有一个红色的点无论怎么…

    2023年4月2日
    00
  • 使用gensim框架和随机文本训练Word2Vector模型 Python开发

    使用gensim框架和随机文本训练Word2Vector模型

    1.gensim的安装 可以使用如下命令安装gensim conda install -i https://pypi.tuna.tsinghua.edu.cn/simple gensim==3.8.2 2.生成分词列表 这一步已经有生成好的分词列表可以忽略项目列表： 点击查看代码 # coding:utf-8 from gensim.models impor…

    2023年3月31日
    00
  • Python爬虫详解 Python开发

    Python爬虫详解

    1、任务介绍 需求分析爬取豆瓣电影Top250的基本信息，包括电影的名称，豆瓣评分，评价数，电影概况，电影链接等。 https://movie.douban.com/top250 2、基本流程 2.1、准备工作 通过浏览器查看分析目标网页，学习编程基础规范与Java的一些区别，Python没有主函数，需要自己去定义并判断 def main():#所有程序从这…

    2023年4月2日
    00
  • 机器学习实战-AdaBoost Python开发

    机器学习实战-AdaBoost

    1.概念 从若学习算法出发，反复学恶习得到一系列弱分类器(又称基本分类器)，然后组合这些弱分类器构成一个强分类器。简单说就是假如有一堆数据data，不管是采用逻辑回归还是SVM算法对当前数据集通过分类器data进行分类，假如一些数据经过第一个分类器之后发现是对的，而另一堆数据经过第一个分类器之后发现数据分类错了，在进行下一轮之前就可以对这些数据进行修改权值的…

    2023年4月2日
    00
合作推广
合作推广
分享本页
返回顶部