基于BP神经网络实现mnist手写数字识别

最新推荐文章于 2024-05-25 11:03:57 发布
最新推荐文章于 2024-05-25 11:03:57 发布
阅读量1.5k 收藏 39
点赞数 18
文章标签： 神经网络 人工智能 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78700076/article/details/134984900
版权

特点：

  • 实现模型保存与加载，训练结果不丢失
  • 实现数据可视化
  • 测试过程可交互，可以选择测试哪一条数据

Step1：准备数据。

(1)数据集介绍

MNIST数据集包含60000个训练集和10000测试数据集。分为图片和标签，图片是28*28的像素矩阵，标签为0~9共10个数字。

# 导包 与参数保存路径设置
import paddle
from paddle.vision.transforms import ToTensor
import os
import paddle.nn as nn
import paddle.nn.functional as F
import matplotlib.pyplot as plt
modelpath,optpath="linear_net.pdparams","adam.pdopt"

# # 加载数据函数
def getdata():
    print("data loading",end="\r")
    # 加载数据集
    train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
    test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
    # 用 DataLoader 实现数据加载
    train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)
    # 加载测试数据集
    test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)
    print("data loaded ")
    return train_loader, test_loader

#   train_loader, test_loader=getdata()

    # 加载数据集
    train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
    test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())

#让我们一起看看数据集中的图片是什么样子的
train_data0, train_label_0 = test_dataset[5][0],test_dataset[5][1]
train_data0 = train_data0.reshape([28,28])
plt.figure(figsize=(2,2))
print(plt.imshow(train_data0, cmap=plt.cm.binary))
print('train_data0 的标签为: ' + str(train_label_0))
AxesImage(25,22;155x154)
train_data0 的标签为: [1]


 

#让我们再来看看数据样子是什么样的吧
print(train_data0)
 

Tensor(shape=[28, 28], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
       [[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.30196080, 0.99607849,
         0.41960788, 0.01176471, 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.07450981, 0.89019614, 0.99607849,
         0.99607849, 0.03529412, 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.31764707, 0.99607849, 0.99607849,
         0.64705884, 0.00392157, 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.02745098, 0.79607850, 0.99607849, 0.99607849,
         0.28627452, 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.20784315, 0.99607849, 0.99607849, 0.98039222,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.52549022, 0.99607849, 0.99607849, 0.70588237,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.76862752, 0.99607849, 0.97254908, 0.18823531,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.22745100, 0.99607849, 0.99607849, 0.92941183, 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.43529415, 0.99607849, 0.99607849, 0.51764709, 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.63921571, 0.99607849, 0.93333340, 0.10980393, 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.23529413, 0.98823535, 0.99607849, 0.87450987, 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.30980393, 0.99607849, 0.99607849, 0.60392159, 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.63921571, 0.99607849, 0.93333340, 0.20784315, 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.10980393, 0.98823535, 0.99607849, 0.82352948, 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.33725491, 0.99607849, 0.99607849, 0.51372552, 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.41176474, 0.99607849, 0.91764712, 0.07843138, 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.68627453, 0.99607849, 0.80000007, 0.01960784, 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.01960784, 0.82745105, 0.99607849, 0.76862752, 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.01176471, 0.61960787, 0.99607849, 0.62745100, 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.10196079, 0.61568630, 0.41960788, 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,
         0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])

 

 

    # 用 DataLoader 实现数据加载
    train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)
    # 加载测试数据集
    test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)
    print("data loaded ")
 

data loaded 

 

 

# 显示图像函数
def showimg(img):
    plt.figure("Image") # 图像窗口名称
    plt.imshow(img, cmap=plt.cm.binary)
    plt.axis('on') # 关掉坐标轴为 off
    plt.title('image') # 图像题目
    plt.show()
 

 

# # 保存和加载参数函数
# def savemodel(layer,adam):
#     # save 
#     print("saving model",end="\r")
#     paddle.save(layer.state_dict(),modelpath )
#     paddle.save(adam.state_dict(),optpath )
#     print("saved model ")
# def loadmodel(layer,adam):
#     # load
#     if os.path.isfile(modelpath) and os.path.isfile(optpath):
#         print("not first train,loading para",end="\r")
#         layer_state_dict = paddle.load(modelpath)
#         layer.set_state_dict(layer_state_dict)
#         opt_state_dict = paddle.load(optpath)
#         adam.set_state_dict(opt_state_dict)
#         print("not first train,loaded para ")
#     else:
#         print("first train!")
 

 

# 保存和加载参数函数
def savemodel(layer):
    # save 
    print("saving model",end="\r")
    paddle.save(layer.state_dict(),modelpath )
    # paddle.save(adam.state_dict(),optpath )
    print("saved model ")
def loadmodel(layer):
    # load
    if os.path.isfile(modelpath):
        print("not first train,loading para",end="\r")
        layer_state_dict = paddle.load(modelpath)
        layer.set_state_dict(layer_state_dict)
        # opt_state_dict = paddle.load(optpath)
        # adam.set_state_dict(opt_state_dict)
        print("not first train,loaded para ")
    else:
        print("first train!")
 

Step2.网络配置
 

以下的代码判断就是定义一个简单的多层感知器，一共有三层，两个大小为100的隐层和一个大小为10的输出层，因为MNIST数据集是手写0到9的灰度图像，类别有10个，所以最后的输出大小是10。最后输出层的激活函数是Softmax，所以最后的输出层相当于一个分类器。加上一个输入层的话，多层感知器的结构是：输入层-->>隐层-->>隐层-->>输出层。
 

 

 

 

# 定义多层感知器 
#动态图定义多层感知器
class DNN(paddle.nn.Layer):
    def __init__(self):
        super(DNN,self).__init__()
        self.fc1 = paddle.nn.Linear(in_features =28*28, out_features =100)#输入层 
        self.fc2 = paddle.nn.Linear(in_features =100, out_features =100)#隐藏层设置100个神经元
        self.fc3 = paddle.nn.Linear(in_features =100, out_features =10)#输出层 10个神经元对应10种数字

    def forward(self, input_):
        x = paddle.reshape(input_, [input_.shape[0], -1])
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.relu(x)
        x = self.fc3(x)
        y = F.softmax(x)
        return y
 

 

#BP 网络结构函数
class Mnist(paddle.nn.Layer):
    def __init__(self):
        super(Mnist, self).__init__()
        self.flatten = paddle.nn.Flatten()
        self.linear_1 = paddle.nn.Linear(784, 512)#隐藏层512个神经源
        self.linear_2 = paddle.nn.Linear(512, 10)
        self.relu = paddle.nn.ReLU()
        self.dropout = paddle.nn.Dropout(0.2)

    def forward(self, inputs):
        y = self.flatten(inputs)
        y = self.linear_1(y)
        y = self.relu(y)
        y = self.dropout(y)
        y = self.linear_2(y)
        return y
 

Step3.自己搭建一个BP神经网络
 

参考上面两个网络的搭建方法，搭建自己的网络，将代码写到下面code框中， 并进行后续训练、评估和测试
 

 

class Mnist1(paddle.nn.Layer):
    def __init__(self):
        super(Mnist1, self).__init__()
        self.flatten = paddle.nn.Flatten()
        self.linear_1 = paddle.nn.Linear(784, 512)#隐藏层512个神经源
        self.linear_2 = paddle.nn.Linear(512, 256)#隐藏层256个神经源
        self.linear_3 = paddle.nn.Linear(256, 128)#隐藏层128个神经源
        self.linear_4 = paddle.nn.Linear(128, 10)#分为10类
        self.relu = paddle.nn.ReLU()
        self.dropout = paddle.nn.Dropout(0.2)

    def forward(self, inputs):
        y = self.flatten(inputs)
        y = self.linear_1(y)
        y = self.relu(y)
        y = self.dropout(y)
        y = self.linear_2(y)
        y = self.relu(y)
        y = self.dropout(y)
        y = self.linear_3(y)
        y = self.relu(y)
        y = self.dropout(y)
        y = self.linear_4(y)
        return y
 

Step4.训练
 

 

# 训练函数--输入 网络、训练数据、epoch、优化器、损失函数 训练
def train(mnist,train_loader,epochs,optim,loss_fn):
    print("train begin")

    mnist.train()

    for epoch in range(epochs):
        for batch_id, data in enumerate(train_loader()):

            x_data = data[0]            # 训练数据
            y_data = data[1]            # 训练数据标签
            predicts = mnist(x_data)    # 预测结果

            # 计算损失 等价于 prepare 中loss的设置
            loss = loss_fn(predicts, y_data)

            # 计算准确率 等价于 prepare 中metrics的设置
            acc = paddle.metric.accuracy(predicts, y_data)

            # 下面的反向传播、打印训练信息、更新参数、梯度清零都被封装到 Model.fit() 中

            # 反向传播
            loss.backward()

            if (batch_id+1) % 900 == 0:
                print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id+1, loss.numpy(), acc.numpy()))

            # 更新参数
            optim.step()

            # 梯度清零
            optim.clear_grad()
    if epochs>0:savemodel(mnist)
 

 

    #BP
    # mnist=Mnist()
    #DNN
    mnist = Mnist1()
    optim = paddle.optimizer.Adam(parameters=mnist.parameters()) # 设置优化器
    loadmodel(mnist)
    loss_fn = paddle.nn.CrossEntropyLoss() # 设置损失函数

 

not first train,loaded para 

 

 

    epochs = int(input("train times:")) # 设置迭代次数
    train(mnist,train_loader,epochs,optim,loss_fn)
 

train times: 3

 

train begin
epoch: 0, batch_id: 900, loss is: [0.09206763], acc is: [0.984375]
epoch: 1, batch_id: 900, loss is: [0.05399161], acc is: [0.984375]
epoch: 2, batch_id: 900, loss is: [0.11109874], acc is: [0.984375]
saved model 

 

Step5.评估
 

 

# 评估函数
def eval(mnist,test_loader,loss_fn):
    mnist.eval()
    for batch_id, data in enumerate(test_loader()):

        x_data = data[0]            # 测试数据
        y_data = data[1]            # 测试数据标签
        predicts = mnist(x_data)    # 预测结果

        # 计算损失与精度
        loss = loss_fn(predicts, y_data)
        acc = paddle.metric.accuracy(predicts, y_data)

        # 打印信息
        if (batch_id+1) % 30 == 0:
            print("batch_id: {}, loss is: {}, acc is: {}".format(batch_id+1, loss.numpy(), acc.numpy()))
 

 

eval(mnist,test_loader,loss_fn)
 

batch_id: 30, loss is: [0.09358358], acc is: [0.984375]
batch_id: 60, loss is: [0.27202883], acc is: [0.9375]
batch_id: 90, loss is: [0.03672048], acc is: [0.984375]
batch_id: 120, loss is: [3.5817196e-05], acc is: [1.]
batch_id: 150, loss is: [0.07554816], acc is: [0.984375]

 

Step6.测试
 

 

# 测试函数 输入大于等于10000或小于0的数字会停止测试 退出程序
def test(mnist,test_loader):
    mnist.eval()
    alldata={}
    allpredicts={}
    alllabel={}
    for batch_id, data in enumerate(test_loader()):
        x_data = data[0]
        y_data = data[1]
        predicts = mnist(x_data)
        allpredicts[batch_id]=predicts
        alllabel[batch_id]=y_data
        alldata[batch_id]=x_data
    i=0
    while i<10000 and i>=0:
        batch_id=i//64
        id=i%64
        print("predict:",allpredicts[batch_id][id].argmax().numpy().tolist(),
            "label:",alllabel[batch_id][id].numpy().tolist())
        print("network output:",allpredicts[batch_id][id].numpy().tolist())
        img=(alldata[batch_id][id][0]).numpy()
        showimg(img)
        i=int(input("predict which line:"))
    print("predict finished")
 

 

test(mnist,test_loader)
 

predict: [7] label: [7]
network output: [-9.719499588012695, -3.4801108837127686, -0.651482880115509, 0.385851114988327, -2.0601513385772705, -7.415570259094238, -16.08660888671875, 16.32851791381836, -4.776862621307373, -3.5384793281555176]

 

 

<Figure size 640x480 with 1 Axes>
 

predict which line: 1

 

predict: [2] label: [2]
network output: [-6.095338821411133, 1.228253960609436, 19.041542053222656, 0.19300922751426697, -6.705218315124512, -6.877689838409424, -7.77207612991333, -2.713935613632202, 1.3736858367919922, -16.818513870239258]

 

 

<Figure size 640x480 with 1 Axes>
 

predict which line: 2

 

predict: [1] label: [1]
network output: [-6.339268207550049, 17.581079483032227, -1.0753511190414429, -9.902815818786621, -4.157736301422119, -9.313263893127441, -3.4409077167510986, 2.3445217609405518, -3.7683358192443848, -10.679972648620605]

 

 

<Figure size 640x480 with 1 Axes>
 

predict which line: 3

 

predict: [0] label: [0]
network output: [13.701967239379883, -6.619961261749268, 0.19982996582984924, -2.923210382461548, -5.800919532775879, -2.6428065299987793, 0.7682965397834778, -8.163551330566406, -6.404813289642334, -1.3585065603256226]

 

 

<Figure size 640x480 with 1 Axes>

 

 


def main():
    train_loader, test_loader=getdata()
    mnist=Mnist()
    optim = paddle.optimizer.Adam(parameters=mnist.parameters()) # 设置优化器
    loadmodel(mnist)
    loss_fn = paddle.nn.CrossEntropyLoss() # 设置损失函数
    epochs = int(input("train times:")) # 设置迭代次数
    train(mnist,train_loader,epochs,optim,loss_fn)
    eval(mnist,test_loader,loss_fn)
    test(mnist,test_loader)
main()
 

data loading

 

data loaded 
not first train,loaded para 

 

train times: 2

 

train begin
epoch: 0, batch_id: 900, loss is: [0.06289747], acc is: [0.984375]
epoch: 1, batch_id: 900, loss is: [0.01734219], acc is: [1.]
saved model 
batch_id: 30, loss is: [0.1096139], acc is: [0.96875]
batch_id: 60, loss is: [0.14677176], acc is: [0.953125]
batch_id: 90, loss is: [0.05241321], acc is: [0.96875]
batch_id: 120, loss is: [0.00182047], acc is: [1.]
batch_id: 150, loss is: [0.07601856], acc is: [0.984375]
predict: [7] label: [7]
network output: [-7.678086280822754, -5.868976593017578, -4.243804454803467, -1.5573679208755493, -12.051778793334961, -5.38519811630249, -11.370020866394043, 8.172942161560059, -7.072317123413086, -3.1511974334716797]

 

 

<Figure size 640x480 with 1 Axes>
 

predict which line: 5

 

predict: [1] label: [1]
network output: [-7.677154541015625, 5.846972465515137, -5.342567443847656, -5.321855545043945, -4.9580302238464355, -9.511335372924805, -6.31016206741333, -1.8860419988632202, -4.507370948791504, -9.752077102661133]

 

 

<Figure size 640x480 with 1 Axes>
 

predict which line: 1

 

predict: [2] label: [2]
network output: [-8.478514671325684, -2.1858773231506348, 8.671475410461426, -1.963241457939148, -14.843521118164062, -9.429603576660156, -7.946425914764404, -9.69050121307373, -3.7265031337738037, -15.485095024108887]

 

 

<Figure size 640x480 with 1 Axes>
 

predict which line: q


                

        

        

    




    

      

        

            

              
                
                  2301_78700076
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    18
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    39
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
BP神经网络手写数字的识别

				
			

			

				

					09-17
				

			

		

		

			
				
BP神经网络手写数字的识别

			
		

	



                

              
                



	

		

			

				
					
基于BP神经网络和卷积神经网络的MNIST手写数字识别

				
			

			

				

					01-22
				

			

		

		

			
				
本基于BP神经网络和卷积神经网络对手写数字识别进行研究，使用10000张已标注的大小为28*28的手写数字图片进行训练和测试，从所有图片中随机选出9000张作为训练样本对网络进行训练，另外1000张作为测试样本用于测试...

			
		

	



                


  
              

                


	

		

			

				
					
基于Python实现的神经网络的手写数字识别

				
			

			

				

					毕业作品网站
				

				

					06-10
					
					4823
					
				

			

		

		

			
				
在最后手写数字的识别实验部分，一开始识别效果很差。经过检查，发现是裁剪数字部分时，没有在数字四周留出空余部分，导致每次识别效果很差。最后在裁剪时留出了较大的空余部分，得到了很棒的识别效果。在最后手写数字的识别实验部分，一开始识别效果很差。经过检查，发现是裁剪数字部分时，没有在数字四周留出空余部分，导致每次识别效果很差。最后在裁剪时留出了较大的空余部分，得到了很棒的识别效果。在神经网络训练部分，超参数的选择对于模型有着很大的影响。在神经网络训练部分，超参数的选择对于模型有着很大的影响。

			
		

	





	

		

			

				
					
基于Matlab实现BP神经网络的手写数字识别

				
			

			

				

					2301_79809972的博客
				

				

					05-25
					
					665
					
				

			

		

		

			
				
一、项目背景与意义手写数字识别是计算机视觉和模式识别领域的一个经典问题，具有广泛的应用场景，如邮政编码识别、银行表单处理、手写笔记识别等。BP（Backpropagation）神经网络是一种常用的前馈神经网络，通过反向传播算法调整网络参数，以实现输入到输出的映射。本项目旨在利用Matlab编程环境，结合BP神经网络算法，实现手写数字识别系统，从而深入理解和应用BP神经网络的基本原理和技巧。二、项目目标。

			
		

	



		

			
		



	

		

			

				
					
【机器学习】神经网络识别手写数字（附python源码）

				
			

			

				

					watermelon_c的博客
				

				

					02-12
					
					7619
					
				

			

		

		

			
				
神经网络

			
		

	





	

		

			

				
					
机器学习实验——BP神经网络之手写数字识别

				
			

			

				

					m0_56543373的博客
				

				

					10-14
					
					4467
					
				

			

		

		

			
				
机器学习实验——BP神经网络之手写数字识别

			
		

	





	

		

			

				
					
【机器学习】实验四  用python实现BP算法识别MNIST数据集手写数字

				
			

			

				

					青春不言败
				

				

					12-17
					
					8671
					
				

			

		

		

			
				
文章目录代码解读：一、初始化1、`np.random.randn(y, x)`2、 `zip(sizes[:-1], sizes[1:])`3、 神奇的for循环4、终于看懂了一句代码5、偏移初始化二、其他函数的简单说明

代码

# python3
 
import numpy as np
import random
import os, struct
from array import arr...

			
		

	





	

		

			

				
					
基于BP算法的手写数字识别

				
			

			

				

					pied_piperG的博客
				

				

					05-20
					
					2117
					
				

			

		

		

			
				
本文为学校机器智能实践课的实验报告，想直接看代码可以跳到最后源码展示一块；具体细节在算法设计中有详解。

			
		

	





	

		

			

				
					
BP神经网络mnist手写数字识别Python实现

				
			

			

				

					weixin_45652815的博客
				

				

					05-12
					
					4723
					
				

			

		

		

			
				
1、创建一个BP神经网络类，定义其中的输入数据个数，隐藏层个数，输出层个数，输入层学习率，隐藏层学习率
2、查询是否有训练好的文件，如果不存在则进行训练，如果存在则进行识别
在这里插入代码片
def run():


    # 神经网络配置参数
    in_count = 28 * 28
    hiden_count = 6
    out_count = 10
    in_rate = 0.1
    hiden_rate = 0.1
    bpnn = BPNetwork(in_count, 

			
		

	





	

		

			

				
					
BP神经网络实现手写数字识别

				
			

			

				

					weixin_44823313的博客
				

				

					01-10
					
					7391
					
				

			

		

		

			
				
BP神经网络实现手写数字识别
完整代码在最后
1.导入包
import numpy as np
from sklearn.datasets import load_digits
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report,confusion_matri

			
		

	





	

		

			

				
					
BP神经网络手写数字识别_手写数字识别_BP神经网络_

				
			

			

				

					10-02
				

			

		

		

			
				
该代码用于神经网络初学者尝试手写数字识别代码

			
		

	





	

		

			

				
					
使用BP神经网络识别手写数字

				
			

			

				

					12-31
				

			

		

		

			
				
NIST提供的是28 * 28的图片，因此输入层是754维的向量。隐层输出层为10维向量

公式定义：

输出层：01 ... 01
隐层：Y1 ... YN
输入层：X1 ... XM
输入层与隐层间的权值$ V_ {ij} $
隐层与输出层之间的权值$ W_ {jk} $
使用函数$ F（X）= \压裂{1} {1个+ E ^ { - X}} $
准确值D1 ... DL
学习率ETA
隐层与输出层间误差$ \ delta ^ o_k =（d_k - O_k）O_k（1-O_k）$
输入层与隐层间误差$ \ delta ^ y_j =（\ sum ^ {l} {k = 1} \ delta ^ o_kW {jk}）y_j（1-y_j）$
误差反传时$ \ Delta W_ {jk} = \ eta（d_k-O_k）O_k（1-O_k）* y_j $
$ \ Delta V_ {ij} = \ eta（\ sum ^ {l} {k = 1} \ delta ^ o_kW {jk}）y_j（1-y_j）X_i $
每次计算时先从输入层计算到输出层，然后算出三层间的两个误差，然后更新网络间的权值

			
		

	





	

		

			

				
					
利用BP神经网络实现手写体数字识别

				
			

			

				

					03-12
				

			

		

		

			
				
利用MATLAB实现的手写数字识别

			
		

	





	

		

			

				
					
基于BP神经网络的手写数字识别系统，Matlab

				
			

			

				

					06-20
				

			

		

		

			
				
基于BP神经网络的手写数字识别系统，基于Matlab开发，实现手写输入板功能，特征提取，模型训练，手写识别等功能。详细使用方法在readme说明文档中。

			
		

	





	

		

			

				
					
神经网络bp算法实现手写数字识别

				
			

			

				

					04-23
				

			

		

		

			
				
本次练习所用的数据集有5000个训练样本，每个样本对应于20x20大小的灰度图像。这些训练样本包括了9-0共十个数字的手写图像。这些样本中每个像素都用浮点数表示。加载得到的数据中，每幅图像都被展开为一个400维的向量，构成了数据矩阵中的一行。完整的训练数据是一个5000x400的矩阵，其每一行为一个训练样本（数字的手写图像）。数据中，对应于数字"0"的图像被标记为"10"，而数字"1"到"9"按照其自然顺序被分别标记为"1"到"9"。数据集保存在NN_data.mat. 

			
		

	





	

		

			

				
					
基于BP神经网络mnist手写数字识别Python实现源码（期末大作业）

					
最新发布

				
			

			

				

					06-25
				

			

		

		

			
				
基于BP神经网络mnist手写数字识别Python实现源码（期末大作业）本项目是一套成熟的大作业项目系统，获取98分，主要针对计算机相关专业的正在做大作业的学生和需要项目实战练习的学习者，可作为课程设计、期末大作业...

			
		

	





	

		

			

				
					
基于BP神经网络的手写数字识别.zip

				
			

			

				

					07-09
				

			

		

		

			
				
**基于BP神经网络的手写数字识别**  手写数字识别是一种广泛应用的人工智能技术，它能够自动解析和识别手写的数字图像。在现实生活中，这项技术常用于邮政编码自动读取、移动银行签名验证以及各种光学字符识别（OCR...

			
		

	





	

		

			

				
					
C语言-三层BP网络（隐层一层）实现mnist手写数字识别

				
			

			

				

					11-17
				

			

		

		

			
				
C语言-三层BP网络（隐层一层）实现mnist手写数字识别。cpp文件可直接运行，mnist手写数字识别请自行下载，和cpp文件放到同一个路径文件夹下就可以了。成功率达93.49；高斯分布初始化参数。 训练参数的代码文件是BP-...

			
		

	





	

		

			

				
					
基于BP神经网络的MATLAB手写数字识别实战与理论详解

				
			

			

				

					
				

			

		

		

			
				
本实验旨在通过基于BP神经网络的手写体数字识别来深入理解计算智能中的神经网络理论和应用。首先，实验目标包括：  1. 熟悉与掌握BP神经网络：参与者将学习到BP神经网络的基本模型，如其层次结构（输入层、隐藏层和...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值