快速搭建CNN（卷积神经网络），实现分类MINST数据集（学习笔记三）

最新推荐文章于 2024-09-02 20:00:48 发布
最新推荐文章于 2024-09-02 20:00:48 发布
阅读量3.5k 收藏 23
点赞数 5
分类专栏： 计算机 文章标签： cnn 分类 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39909808/article/details/121280509
版权

1. 加载MINST数据集

如果还没有安装torch以及torchvision的，请看文章：Torch安装
安装完成之后，详细的python代码如下：

from torchvision import  datasets
from torchvision.transforms import ToTensor, Lambda, Compose
import matplotlib.pyplot as plt
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
# load train data
train_data = datasets.MNIST(
    root='data', # save in the directory data
    train=True, # True means train data, False means test data
    download=True,
    transform=ToTensor() # (0, 255) to (0, 1)
)
# load test data
test_data = datasets.MNIST(
    root='data',
    train=False, #True means train data, False means test data
    download=True,
    transform=ToTensor()
)

下载成功结果：
在这里插入图片描述
添加下列代码显示其中一条数据：

print(train_data.data.size())
print(train_data.targets.size())
plt.imshow(train_data.data[130].numpy(), cmap='gray')
plt.title('%i' % train_data.targets[130])
plt.show()

数据如下图所示：
在这里插入图片描述

2. 快速构建CNN网络

python代码：

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1, # size of input channels
                out_channels=16, # size of input channels
                kernel_size=(5, 5), # size of filter
                stride=(1, 1), # step of filter
                padding=2, # padding num
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, (5, 5), (1, 1), 2),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.flat = nn.Flatten() # flattern the result
        self.out = nn.Linear(32 * 7 * 7, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.flat(x)
        out = self.out(x)
        return out

如果打印一下网络的架构，使用语句：

model = CNN()
print(model)

显示的结构如下所示：

CNN(
  (conv1): Sequential(
    (0): Conv2d(1, 16, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (conv2): Sequential(
    (0): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
    (1): ReLU()
    (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  )
  (flat): Flatten(start_dim=1, end_dim=-1)
  (out): Linear(in_features=1568, out_features=10, bias=True)
)

3. 整体代码（CPU版本）

python代码：

import torch
import torchvision
import torch.nn as nn
import torch.utils.data as Data
import matplotlib.pyplot as plt
import numpy as np
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"

# Hyper parameters
EPOCH = 1
BATCH_SIZE = 50
LR = 0.001
DOWNLOAD_MINST = True
# Download training data
train_data = torchvision.datasets.MNIST(
    root='./mnist',
    train=True,
    transform=torchvision.transforms.ToTensor(),
    download=DOWNLOAD_MINST
)
#print(train_data.data.size())
#print(train_data.targets.size())
#plt.imshow(train_data.data[130].numpy(), cmap='gray')
#plt.title('%i' % train_data.targets[130])
#plt.show()
#
train_loader = Data.DataLoader(
    dataset=train_data,
    batch_size=BATCH_SIZE,
    shuffle=False,
    num_workers=4
)

# Download testing data
test_data = torchvision.datasets.MNIST(
    root='./mnist',
    train=False,
)
test_x = torch.unsqueeze(test_data.data, dim=1).type(torch.FloatTensor)[:2000] / 255
test_y = test_data.targets[:2000]


class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,
                out_channels=16,
                kernel_size=(5, 5),
                stride=(1, 1),
                padding=2
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, (5, 5), (1, 1), 2),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.flat = nn.Flatten()
        self.out = nn.Linear(32 * 7 * 7, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.flat(x)
        output = self.out(x)

        return output


cnn = CNN()
optimizer = torch.optim.Adam(cnn.parameters(), lr=LR)
loss_fuction = nn.CrossEntropyLoss()

if __name__ == '__main__':
    for epoch in range(EPOCH):
        for step, (batch_x, batch_y) in enumerate(train_loader):
            prediction = cnn(batch_x)
            loss = loss_fuction(prediction, batch_y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            if step % 50 == 0:
                test_output = cnn(test_x)
                pred_y = torch.max(test_output, 1)[1].data.numpy()
                accuracy = (sum(pred_y == np.array(test_y.data)).item()) / test_y.size(0)
                print('Epoch:%d' % epoch, end='||')
                print('train loss:%.4f' % loss.item(), end='||')
                print('test accuracy:%.4f' % accuracy)
    test_output = cnn(test_x[:10])
    pred_y = torch.max(test_output, 1)[1].data.numpy()
    print(pred_y, 'prediction number')
    print(test_y[:10].numpy(), 'real number')

运行结果：

Epoch:0||train loss:2.3074||test accuracy:0.2195
Epoch:0||train loss:0.2392||test accuracy:0.7895
Epoch:0||train loss:0.3036||test accuracy:0.8910
Epoch:0||train loss:0.2483||test accuracy:0.9140
Epoch:0||train loss:0.3289||test accuracy:0.9045
Epoch:0||train loss:0.1809||test accuracy:0.9275
Epoch:0||train loss:0.0711||test accuracy:0.9480
Epoch:0||train loss:0.1408||test accuracy:0.9480
Epoch:0||train loss:0.2358||test accuracy:0.9600
Epoch:0||train loss:0.2181||test accuracy:0.9445
Epoch:0||train loss:0.0309||test accuracy:0.9675
Epoch:0||train loss:0.1352||test accuracy:0.9575
Epoch:0||train loss:0.1682||test accuracy:0.9725
Epoch:0||train loss:0.0470||test accuracy:0.9735
Epoch:0||train loss:0.0341||test accuracy:0.9710
Epoch:0||train loss:0.1404||test accuracy:0.9680
Epoch:0||train loss:0.1307||test accuracy:0.9670
Epoch:0||train loss:0.1597||test accuracy:0.9720
Epoch:0||train loss:0.0743||test accuracy:0.9735
Epoch:0||train loss:0.0263||test accuracy:0.9765
Epoch:0||train loss:0.0135||test accuracy:0.9735
Epoch:0||train loss:0.0150||test accuracy:0.9770
Epoch:0||train loss:0.0122||test accuracy:0.9765
Epoch:0||train loss:0.0241||test accuracy:0.9760
[7 2 1 0 4 1 4 9 5 9] prediction number
[7 2 1 0 4 1 4 9 5 9] real number

4. 整体代码（GPU版本）

python代码：

import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor

# hyper parameters
LR = 0.002
EPOCH = 5
BATCH_SIZE = 50

train_data = datasets.MNIST(
    root='data',
    train=True,
    download=True,
    transform=ToTensor()
)

test_data = datasets.MNIST(
    root= 'data',
    train=False,
    download=True,
    transform=ToTensor()
)

test_loader = DataLoader(
    dataset=test_data,
    batch_size=BATCH_SIZE,
    shuffle=False,
    num_workers=4,
)

train_loader = DataLoader(
    dataset=train_data,
    batch_size=BATCH_SIZE,
    shuffle=False,
    num_workers=4,
)


class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Sequential(
            nn.Conv2d(
                in_channels=1,
                out_channels=16,
                kernel_size=(5, 5),
                stride=(1, 1),
                padding=2,
            ),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2),
        )
        self.conv2 = nn.Sequential(
            nn.Conv2d(16, 32, (5, 5), (1, 1), 2),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.flat = nn.Flatten()
        self.out = nn.Linear(32 * 7 * 7, 10)

    def forward(self, x):
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.flat(x)
        out = self.out(x)
        return out


device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = CNN().to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=LR)
loss_function = torch.nn.CrossEntropyLoss()


def train(data_loader, model, loss_function, optimizer):
    size = len(data_loader.dataset)
    model.train()
    for batch, (X, y) in enumerate(data_loader):
        X, y = X.to(device), y.to(device)

        # Compute prediction error
        pred = model(X)
        loss = loss_function(pred, y)

        # Back propagation
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch % 100 == 0:
            loss, current = loss.item(), batch * len(X)
            print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")


def test(data_loader, model, loss_fn):
    size = len(data_loader.dataset)
    num_batches = len(data_loader)
    model.eval()
    test_loss, correct = 0, 0
    with torch.no_grad():
        for X, y in data_loader:
            X, y = X.to(device), y.to(device)
            pred = model(X)
            test_loss += loss_fn(pred, y).item()
            correct += (pred.argmax(1) == y).type(torch.float).sum().item()
    test_loss /= num_batches
    correct /= size
    print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
    torch.save(model.state_dict(), "model.pth")
	print("Saved PyTorch Model State to model.pth")


def call_model():
    for t in range(EPOCH):
        print(f"Epoch {t + 1}\n-------------------------------")
        train(train_loader, model, loss_function, optimizer)
        test(test_loader, model, loss_function)
    print("Done!")


if __name__ == '__main__':
    call_model()

结果展示：

Epoch 1
-------------------------------
loss: 2.319763  [    0/60000]
loss: 0.197887  [ 5000/60000]
loss: 0.231820  [10000/60000]
loss: 0.029967  [15000/60000]
loss: 0.193301  [20000/60000]
loss: 0.028721  [25000/60000]
loss: 0.230080  [30000/60000]
loss: 0.030196  [35000/60000]
loss: 0.088837  [40000/60000]
loss: 0.061477  [45000/60000]
loss: 0.021868  [50000/60000]
loss: 0.009769  [55000/60000]
Test Error: 
 Accuracy: 97.0%, Avg loss: 0.092558 

Epoch 2
-------------------------------
loss: 0.062530  [    0/60000]
loss: 0.037623  [ 5000/60000]
loss: 0.057986  [10000/60000]
loss: 0.003451  [15000/60000]
loss: 0.034381  [20000/60000]
loss: 0.005294  [25000/60000]
loss: 0.171846  [30000/60000]
loss: 0.042936  [35000/60000]
loss: 0.073527  [40000/60000]
loss: 0.039359  [45000/60000]
loss: 0.005118  [50000/60000]
loss: 0.003203  [55000/60000]
Test Error: 
 Accuracy: 98.6%, Avg loss: 0.041006 

Epoch 3
-------------------------------
loss: 0.018981  [    0/60000]
loss: 0.037027  [ 5000/60000]
loss: 0.030264  [10000/60000]
loss: 0.000278  [15000/60000]
loss: 0.024834  [20000/60000]
loss: 0.003731  [25000/60000]
loss: 0.117729  [30000/60000]
loss: 0.058137  [35000/60000]
loss: 0.068251  [40000/60000]
loss: 0.009537  [45000/60000]
loss: 0.015441  [50000/60000]
loss: 0.000517  [55000/60000]
Test Error: 
 Accuracy: 98.9%, Avg loss: 0.033202 

Epoch 4
-------------------------------
loss: 0.005696  [    0/60000]
loss: 0.011667  [ 5000/60000]
loss: 0.033686  [10000/60000]
loss: 0.000063  [15000/60000]
loss: 0.021328  [20000/60000]
loss: 0.001276  [25000/60000]
loss: 0.115446  [30000/60000]
loss: 0.013636  [35000/60000]
loss: 0.031956  [40000/60000]
loss: 0.006652  [45000/60000]
loss: 0.006096  [50000/60000]
loss: 0.001458  [55000/60000]
Test Error: 
 Accuracy: 98.9%, Avg loss: 0.034399 

Epoch 5
-------------------------------
loss: 0.001917  [    0/60000]
loss: 0.004953  [ 5000/60000]
loss: 0.039799  [10000/60000]
loss: 0.000086  [15000/60000]
loss: 0.087789  [20000/60000]
loss: 0.006337  [25000/60000]
loss: 0.046358  [30000/60000]
loss: 0.020176  [35000/60000]
loss: 0.009923  [40000/60000]
loss: 0.008083  [45000/60000]
loss: 0.007701  [50000/60000]
loss: 0.002184  [55000/60000]
Test Error: 
 Accuracy: 99.0%, Avg loss: 0.034642 

Done!
Saved PyTorch Model State to model.pth

5. 保存和加载模型

下面的代码是保存训练好的模型的参数：

torch.save(model.state_dict(), "model.pth")
print("Saved PyTorch Model State to model.pth")

而加载模型的语法则如下所示：

model = CNN()
model.load_state_dict(torch.load("model.pth"))

将训练好的模型去预测test数据集上的种类标签，完整代码如下所示：

def load_model():
    model = CNN()
    model.load_state_dict(torch.load("model.pth"))
    classes = [
        "T-shirt/top",
        "Trouser",
        "Pullover",
        "Dress",
        "Coat",
        "Sandal",
        "Shirt",
        "Sneaker",
        "Bag",
        "Ankle boot",
    ]
    model.eval()
    inputs, labels = next(iter(test_loader))
    with torch.no_grad():
        prediction = model(inputs)
        accuracy = 0
        for i in range(len(prediction)):
            predicted, actual = classes[prediction[i].argmax(0)], classes[labels[i]]
            print(f'Predicted: "{predicted}", Actual: "{actual}"')
            if predicted == actual:
                accuracy += 1
        print("accuracy:%.4f" % (accuracy / len(prediction)))


if __name__ == '__main__':
    load_model()

预测的结果如下所示，准确率为98%：

Predicted: "Sneaker", Actual: "Sneaker"
Predicted: "Pullover", Actual: "Pullover"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "T-shirt/top", Actual: "T-shirt/top"
Predicted: "Coat", Actual: "Coat"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Coat", Actual: "Coat"
Predicted: "Ankle boot", Actual: "Ankle boot"
Predicted: "Sandal", Actual: "Sandal"
Predicted: "Ankle boot", Actual: "Ankle boot"
Predicted: "T-shirt/top", Actual: "T-shirt/top"
Predicted: "Shirt", Actual: "Shirt"
Predicted: "Ankle boot", Actual: "Ankle boot"
Predicted: "T-shirt/top", Actual: "T-shirt/top"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Sandal", Actual: "Sandal"
Predicted: "Ankle boot", Actual: "Ankle boot"
Predicted: "Sneaker", Actual: "Sneaker"
Predicted: "Sandal", Actual: "Dress"
Predicted: "Coat", Actual: "Coat"
Predicted: "Ankle boot", Actual: "Ankle boot"
Predicted: "Shirt", Actual: "Shirt"
Predicted: "Shirt", Actual: "Shirt"
Predicted: "Sandal", Actual: "Sandal"
Predicted: "Coat", Actual: "Coat"
Predicted: "T-shirt/top", Actual: "T-shirt/top"
Predicted: "Sneaker", Actual: "Sneaker"
Predicted: "Coat", Actual: "Coat"
Predicted: "T-shirt/top", Actual: "T-shirt/top"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Dress", Actual: "Dress"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Dress", Actual: "Dress"
Predicted: "Coat", Actual: "Coat"
Predicted: "Sneaker", Actual: "Sneaker"
Predicted: "Pullover", Actual: "Pullover"
Predicted: "Sneaker", Actual: "Sneaker"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Pullover", Actual: "Pullover"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Sneaker", Actual: "Sneaker"
Predicted: "Coat", Actual: "Coat"
Predicted: "Pullover", Actual: "Pullover"
Predicted: "Dress", Actual: "Dress"
Predicted: "Sandal", Actual: "Sandal"
Predicted: "Trouser", Actual: "Trouser"
Predicted: "Pullover", Actual: "Pullover"
Predicted: "Coat", Actual: "Coat"
Predicted: "Coat", Actual: "Coat"
accuracy:0.9800

6. 测试全部测试集的内容

python代码：

def load_model():
    model = CNN()
    model.load_state_dict(torch.load("model.pth"))
    classes = [
        "T-shirt/top",
        "Trouser",
        "Pullover",
        "Dress",
        "Coat",
        "Sandal",
        "Shirt",
        "Sneaker",
        "Bag",
        "Ankle boot",
    ]
    model.eval()
    with torch.no_grad():
        accuracy = 0
        for (images, labels) in test_loader:
            predict = model(images)
            for i in range(len(predict)):
                predicted, actual = classes[predict[i].argmax(0)], classes[labels[i]]
                print(f'Predicted: "{predicted}", Actual: "{actual}"')
                if predicted == actual:
                    accuracy += 1
        print("accuracy:%.4f" % (accuracy / len(test_data.data)))
        print('num:%d' % accuracy)


if __name__ == '__main__':
    load_model()

测试结果：

...
accuracy:0.9708
num:9708

这里就不全部展开打印出来的结果了，因为总共有10000条数据，只展示最后的结果。

Zhang庆欢
关注
专栏目录
CNN学习----创建自己的数据集
cyrusgenie的博客
09-24 3620
学习的时候看了很多参考书和博客，调试了很多次，其实数据集lmdb格式转换很简单，需要更改的文件并不多 将自己的数据导入Ubuntu，这里作者省略步骤。导入linux之后就可以对数据集进行格式转换操作了 1. 将文件分为两类：训练文件和测试文件   这里我把两个文件夹放在了名为nuaa的文件夹中 对于train和val文件夹，每个文件夹中存放的是每个类别的子文件夹，这里作者做
使用pytorch和卷积神经网络对MINST数字图像进行分类，实战代码
weixin_42167712的博客
12-15 1008
文章目录导入包读取数据卷积网络模块构建设置评估标准为accuracy训练网络模型 导入包 import torch import torch.nn as nn import torch.optim as optim #神经网络反向传播后，要更新每个节点的权重参数，进行优化optimization import torch.nn.functional as F from torchvision import datasets,transforms import matplotlib.pyplot as pl
使用LeNet实现MINIST数据集的分类
weixin_46626325的博客
03-27 300
【代码】使用LeNet实现MINIST数据集的分类。
一文彻底搞懂CNN - 模型架构（Model Architecture）
最新发布
m0_59235245的博客
09-02 1232
由输入层、卷积层、池化层以及全连接层组成，通过卷积操作提取图像特征，并通过池化减少参数数量，最终通过全连接层进行分类或回归。输入层：接收原始图像数据，可能需要进行预处理，如归一化、尺寸调整等。卷积层：通过一系列可学习的卷积核（或称为滤波器）对输入图像进行卷积操作，以提取图像中的局部特征。每个卷积核都会生成一个特征图（feature map），这些特征图共同构成了卷积层的输出。池化层：通常位于卷积层之后，用于对特征图进行下采样，以减少数据的空间维度和参数数量，同时保留重要特征。
Tensorflow-快速搭建CNN
风吴痕的博客
09-16 611
快速搭建CNN#!/usr/bin/python3 # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np import matplotlib.pyplot as plt from tensorflow.contrib.layers.python.layers import fully_connected,convoluti
用CNN用来对自己的数据集分类
06-02
这个CNN工具箱只用改一两个地方就可以对自己的数据集分类了 比github上的deeplearning的工具箱里的CNN改动要简单
LeNet网络分类MINST数据集，附详细代码及注解和B站视频讲解
qq_43329946的博客
11-15 1901
目录LeNet网络结构输入层C1层S2层C3层S4层C5层F6和输出层LeNet代码附详细注解 LeNet网络结构 LeNet-5是一个较简单的卷积神经网络包含了深度学习的基本模块：卷积层，池化层，全连接层下图就是网络的基本流程图，接下来我们将逐层分析 输入层 首先是输入层INPUT,输入32*32大小的原始图像 C1层 接下来是C1层，第一个卷积层。卷积层的目的就是为了获取图像特征，获取 的方式就是通过卷积核实现。比如说，曲线卷积核就可以提取曲线这一图像特征。C1使用的卷积核大小是55，一共有六个卷积核
CNN卷积神经网络实现Mnist手写数字识别数据集.zip
03-07
这个压缩包“CNN卷积神经网络实现Mnist手写数字识别数据集.zip”显然包含了实现CNN模型以识别MNIST数据集的手写数字的代码和资源。 CNN的核心特点包括卷积层、池化层、激活函数和全连接层等。这些组件协同工作，...
使用pytorch搭建卷积网络分类MINST数据集，通过改变网络层数和卷积核大小观察对最终分类准确性的影响，并可视化实验结果
01-18
熟悉掌握卷积神经网络的定义，了解网络中卷积层，池化层等各层特点，并利用卷积神经网络对MINST数据集进行分类。 二、实验内容 MINST数据集为数据，实现MINST数据集分类的操作，其中MINST数据集有10类分别为0~9。 ...
人工智能原理课程设计（卷积神经网络分类MINST数据集）Pytorch
06-20
人工智能原理课程设计（卷积神经网络分类MINST数据集）Pytorch
利用tensorflow实现的卷积神经网络来进行MNIST手写数字图像的分类.py
03-18
利用tensorflow实现的卷积神经网络来进行MNIST手写数字图像的分类。 #导入numpy模块 import numpy as np #导入tensorflow模块，程序使用tensorflow来实现卷积神经网络 import tensorflow as tf #下载...
CNN分类数据集下载，动物十分类.zip
02-02
CNN分类数据集下载，动物十分类
用卷积神经网络实现MNIST数据集分类
Ftwhale的博客
04-07 8151
在这节的内容中，我们用之前讲述的内容来搭建一个比较简单的卷积神经网络，实现MNIST手写数字体数据集的图片分类。 我们给出本次实验的CNN网络参数配置如下： 原始数据：输入为[28,28]，输出为[1,10] 卷积核1：[5,5]，32个特征 -->282832 池化核1：[2,2]，最大池化 -->141432 卷积核2：[5,5]，2个特征 -->141464 池化核2：[2...
cnn实现minist数据集分类
ScapeD的博客
04-07 3781
对于minist数据集分类，相较于普通的全连接神经网络，CNN可以得到更高的准确率于更低的loss。在涉及图片的机器学习领域，CNN是目前最佳的解决方案。 CNN对minist数据集分类的代码: import keras from keras.datasets import mnist from keras.models import Sequential from keras.layers...
基于MINST数据集做分类的机器学习项目
weixin_42875283的博客
01-05 1603
机器学习实战 机器学习的基础知识（已完成） 端对端的机器学习项目（已完成） 训练深度神经网络 使用TensorFlow自定义模型和训练 使用TensorFlow加载和预处理数据 使用卷积神经网络的深度计算机视觉 使用RNN和CNN处理序列 使用RNN和注意力机制进行自然语言处理 使用自动编码器和GAN的表征学习和生成学习 强化学习 大规模训练和部署TensorFlow模型 文章目录机器学习实战前言一、MNIST二、训练二元分类器三、性能测量1、 使用交叉验证测量准确率2、 混淆矩阵3、精度和召回率4、
卷积神经网络（CNN）之MNIST手写数字数据集的实现
深度学习领域优质创作者，CSDN博客专家
12-31 1725
以MNIST数据集来测试CNN的正确率，在图像处理领域基本都会用到CNN，也让大家认识到卷积神经网络在深度学习中的重要性。
Fashion_mnist数据集 CNN分类
bucan804228552的博客
08-05 344
上一次CNN的作业，供大家参考 ```python ''' -*- coding: utf-8 -*- @Time : 2021/7/26 11:47 @Author : Small_Volcano @File : fashion_mnist-cnn.py.py ''' import copy import time import torch import torch.nn as nn import torch.utils.data as Data from torch.optim import Ad
cnn实现mnist数据集识别
weixin_35752645的博客
01-02 368
MNIST 数据集是一个用来识别手写数字的常见数据集。要使用 CNN 实现 MNIST 数据集的识别，需要执行以下步骤： 准备数据。MNIST 数据集包含 60000 张训练图像和 10000 张测试图像。图像是 28x28 的灰度图像，每张图像都有一个与之对应的标签(数字)。 构建 CNN 模型。CNN 通常由输入层、卷积层、池化层和全连接层组成。首先，输入层接受图像数据。然后，卷积层会使用...
CNN-中文文本分类-开源项目-自定义数据集
热门推荐
Syler
11-08 1万+
最近参加学校的一个数据分析比赛，因为自己前面自学了一些基本的机器学习算法，但其实还处于入门阶段，便参加了。选择了一道中文文本分类的题目。 今日头条用户画像 选题背景： 随着机器创作能力越来越强，今后社会媒体上将会产生越来越多的机器创作者自动生产的内容。有效识别出哪些是人类作者生产的内容，哪些是机器作者生产的内容（包括机器写作、机器翻译、机器自动摘要），对于媒体内容的审核、分发、推荐等，具有十分重...
利用卷积神经网络对minst数据集进行分类实验
07-16
### 回答1： 利用卷积神经网络对MINST数据集进行分类实验是一种常见和有效的图像识别方法。MINST数据集是一个手写数字图片集合，包括了60000个训练样本和10000个测试样本。 卷积神经网络（Convolutional Neural Network，CNN）是一种模拟人类视觉系统的深度学习模型，其在图像处理和模式识别任务中表现出色。使用CNN对MINST数据集进行分类实验的步骤如下： 1. 数据准备：首先，将MINST数据集加载到程序中，并进行标准化处理，将图像的像素值归一化到0到1之间。 2. 构建CNN模型：这里可以使用Python的深度学习框架，如TensorFlow、Keras或PyTorch来构建CNN模型。定义卷积层、池化层和全连接层，并设置合适的卷积核大小、池化窗口大小和激活函数。 3. 模型训练：将训练集输入到CNN模型中，进行反向传播优化算法，如随机梯度下降（SGD）、Adam或RMSprop来优化模型参数。根据训练集不断调整卷积核权重、偏置和全连接层权重、偏置，直到模型收敛。 4. 模型评估：使用测试集评估已经训练好的模型。将测试集输入到CNN模型中，计算分类准确率、精确度、召回率等指标来评估模型的性能。 5. 结果分析：分析模型在测试集上的性能表现，可以观察混淆矩阵、绘制准确率和损失函数变化曲线等。 通过这样的实验，我们可以了解CNN模型在MINST数据集上的分类效果。MINST数据集是一个较为简单的图像分类任务，对于CNN来说可以很好地处理。这个实验也可以作为学习和理解CNN模型的基础，为后续更复杂的图像分类任务打下基础。 ### 回答2： 卷积神经网络（Convolutional Neural Networks, CNN）是一种深度学习模型，特别适合处理图像数据。下面我将介绍如何使用CNN对MINST手写数字数据集进行分类实验。 MINST数据集是一个包含60000个训练样本和10000个测试样本的手写数字数据集。我们的目标是将这些手写数字图像正确地分类为0至9中的一个。 首先，我们需要导入所需的库和数据集。我们可以使用Python的TensorFlow库来实现卷积神经网络，并使用MINST数据集进行训练和测试。 接下来，我们定义一个CNN模型。一个典型的CNN模型由卷积层、池化层和全连接层组成。我们可以通过多次迭代来选择合适的参数和层数。 然后，我们将数据集分为训练集和测试集。训练集用于训练CNN的权重和参数，而测试集用于评估模型的性能。 接下来，我们进行训练和优化。我们使用训练集来训练CNN模型，并通过优化算法来调整权重和参数，以最小化损失函数。 在训练完成后，我们使用测试集来评估模型的性能。我们将模型应用于测试集中的图像，然后计算模型的准确率和损失。 最后，我们可以进行预测。我们可以将新的手写数字图像输入到CNN模型中，然后通过模型的输出确定该图像属于哪个数字类别。 通过上述步骤，我们可以使用CNN对MINST手写数字数据集进行分类实验。这种方法在图像分类问题中已经证明了其有效性，并且在许多实际应用中得到了广泛应用。 ### 回答3： 卷积神经网络（Convolutional Neural Network, CNN）是一种深度学习模型，特别适用于图像处理任务。MINST数据集是一个常用的手写数字识别数据集，由60000个训练样本和10000个测试样本组成。 利用卷积神经网络对MINST数据集进行分类实验的步骤如下： 1. 数据准备：首先需要下载MINST数据集，并将其分为训练集和测试集。MINST数据集提供了每个样本的数字标签和对应的图像数据。 2. 构建模型：使用深度学习框架如TensorFlow或PyTorch，搭建一个卷积神经网络模型。模型可以包含卷积层、池化层、全连接层等组件。可以选择不同的网络架构和超参数进行实验。 3. 数据预处理：在输入数据之前，进行一些预处理步骤，如将图像数据进行归一化、缩放和平衡处理等。这样可以提高模型的收敛速度和准确性。 4. 训练模型：将准备好的训练集输入模型，使用训练数据进行模型的训练。通过反向传播算法，不断调整模型的权重和偏差，使模型能够更好地拟合训练数据。 5. 测试模型：使用测试集对训练好的模型进行评估。将测试集的图像输入模型，得到输出的预测结果。计算预测结果与真实标签之间的差距，评估模型的准确性。 6. 调优和改进：根据测试结果分析模型的性能，可以进行一些调优和改进，如调整网络架构、增加层数、调整超参数等，以进一步提高模型的准确率。 通过以上步骤，可以利用卷积神经网络对MINST数据集进行分类实验。可以通过测量准确度、损失函数等指标来评估模型的性能。不断优化模型，提高准确率，是卷积神经网络在MINST数据集上进行分类实验的关键。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值