手写数字识别--神经网络实验

这篇具有很好参考价值的文章主要介绍了手写数字识别--神经网络实验。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

实验源码自取:

 我自己搞的代码,预测精度才94%

神经网络实验报告源码.zip - 蓝奏云

 老师给的实验源码答案和资料,预测精度高达99%

深度学习实验报告.zip - 蓝奏云

上深度学习的课程,老师布置了一个经典的实验报告,我做了好久才搞懂,所以把实验报告放到CSDN保存,自己忘了方便查阅,也为其他人提供借鉴

由于本人是小白,刚入门炼丹,有写地方搞不懂,实验报告有错误的在所难免,请及时指出错误的地方

前馈神经网络的设计

一、实验目标及要求

1.掌握python编程

2.掌握神经网络原理

3. 掌握numpy库的基本使用方法

4. 掌握pytorch的基本使用

前馈神经网络是学习神经网络的基础。本实验针对MNIST手写数字识别数据集,设计实现一个基本的前馈神经网络模型,要求如下:

1. 在PyCharm平台上,分别基于numpy库和PyTorch实现两个版本的模型。

2. 网络包含一个输入层、一个输出层,以及k个隐藏层(1≤k≤3手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别 )。

3. 每个版本的项目文件夹里面有一个文件夹以及三个文件,文件夹名为data,存放MNIST数据集,三个文件为: main.py、network.py、 data_loader.py。main为主文件,通过运行main启动手写数字识别程序;network.py存放神经网络类定义及相关函数;data_loader.py存放负责读入数据的相关方法。

4. 原训练集重新划分为训练集(5万样本)、验证集(1万样本),原测试集(1万样本)作为测试集。

5. 模型中使用交叉熵代价函数和L2正则化项。

6. 在每一个epoch(假设为第i个epoch)中,用训练数据训练网络后,首先用验证集数据进行评估,假设验证集的历史最佳准确率为p手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别 ,本次epoch得到的准确率为pi手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别 ,如果pi>p手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别 ,则用测试集评估模型性能,并把p更新为pi手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别 ;否则不评估并且p不更新手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别 ,进行第i+1个epoch的训练。

7. 假设学习率固定为0.01,通过实验,评估不同的隐藏层个数k,以及隐藏层神经元个数m对模型性能的影响,找到你认为最好的k和m。

二、实验过程(含错误调试)

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

1.基于numpy库的模型

打开并统计数据集,发现训练集有50000个,验证集有10000个,测试集有10000个

对训练集输入的28x28图像矩阵转成784x1的列形状,把目标转成长度为10的列向量

对测试集和验证集输入的28x28图像矩阵转成784x1的列形状,目标保持不变

把数据传进模型,进行训练和测试

根据实验要求,定义Network类,实现初始化网络、前向传播、反向传播,更新参数,验证模型,测试模型,继续迭代,寻找最优参数。

import random
import numpy as np

# https://zhuanlan.zhihu.com/p/148102828

class Network(object):
    def __init__(self, sizes):
        self.num_layers = len(sizes)
        self.sizes = sizes
        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]  # randn,随机正态分布
        self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]
        self.lmbda = 0.1  # L2正则化参数

    def feedforward(self, a):
        for b, w in zip(self.biases, self.weights):
            a = sigmoid(np.dot(w, a) + b)
        return a

        # 重复训练epochs次,训练集mini_batch_size个一包,学习率步长
    def SGD(self, training_data, epochs, mini_batch_size, eta, val_data,test_data=None):
        n_test = len(test_data)
        n = len(training_data)
        n_val = len(val_data)
        best_accuracy = 0
        for j in range(epochs):  # 重复训练的次数
            random.shuffle(training_data)  # 随机打乱训练集顺序
            mini_batches = [
                training_data[k:k + mini_batch_size]  # 切分成每批10个一组
                for k in range(0, n, mini_batch_size)]

            for mini_batch in mini_batches:
                self.update_mini_batch(mini_batch, eta)  # TODO

            # 一次训练完毕
            val_accuracy = self.evaluate(val_data) / n_val  # 进行验证
            # if j==1:
            #     print(f"参数m={m}训练第二次时,验证集精度{val_accuracy * 100}% ")

            if val_accuracy > best_accuracy:
                best_accuracy = val_accuracy
                test_num = self.evaluate(test_data) # 进行测试

                print(f"迭代次数: {j + 1},验证集精度{best_accuracy * 100}% ,测试集预测准确率: {(test_num / n_test) * 100}%")

            else:
                print(f'迭代次数:{j + 1},验证精度比前面那个小了,不进行测试')
        # return val_accuracy

    def update_mini_batch(self, mini_batch, eta):
        m = len(mini_batch)
        x_matrix = np.zeros((784, m))
        y_matrix = np.zeros((10, m))
        for i in range(m):  # 初始化矩阵为输入的10个x,一次计算
            x_matrix[:, i] = mini_batch[i][0].flatten()  # 将多维数组转换为一维数组
            y_matrix[:, i] = mini_batch[i][1].flatten()
        self.backprop_matrix(x_matrix, y_matrix, m, eta)

    def backprop_matrix(self, x, y, m, eta):
        # 生成梯度矩阵,初始为全零
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        # 前向传播
        activation = x
        activations = [x]  # 各层的激活值矩阵
        zs = []  # 各层的带权输入矩阵
        for w, b in zip(self.weights, self.biases):
            z = np.dot(w, activation) + b
            activation = sigmoid(z)
            zs.append(z)
            activations.append(activation)

        # 后向传播
        # 计算输出层误差, # 加上L2正则化
        delta = (self.cross_entropy_cost_derivative(activations[-1], y) +
                 self.L2_regularization(self.weights[-1], m)) * sigmoid_prime(zs[-1])
        # 计算输出层的偏置、权重梯度
        nabla_b[-1] = np.array([np.mean(delta, axis=1)]).transpose()
        nabla_w[-1] = (np.dot(delta, activations[-2].transpose()) / m)
        # 反向传播误差,并计算梯度
        for l in range(2, self.num_layers):
            z = zs[-l]
            sp = sigmoid_prime(z)
            delta = np.dot(self.weights[-l + 1].transpose(), delta) * sp
            nabla_b[-l] = np.array([np.mean(delta, axis=1)]).transpose()
            nabla_w[-l] = np.dot(delta, activations[-l - 1].transpose()) / m
        for l in range(1, self.num_layers):
            self.biases[-l] = self.biases[-l] - eta * nabla_b[-l]
            self.weights[-l] = self.weights[-l] - eta * nabla_w[-l]

    def evaluate(self, test_data):
        test_results = [(np.argmax(self.feedforward(x)), y)  # argmax()找到数组中最大值的索引
                        for (x, y) in test_data]
        return sum(int(x == y) for (x, y) in test_results)

    def L2_regularization(self, weights, m):
        return (self.lmbda / (m * 2)) * np.sum(np.square(weights))

    def cross_entropy_cost_derivative(self, a, y):
        # a是预测值矩阵,y是真实值矩阵
        epsilon = 1e-7
        a = a + epsilon  # 防止除0错误
        dc = -y / a  # 交叉熵代价函数的导数
        return dc


def sigmoid(z):
    if np.all(z >= 0):  # 对sigmoid函数优化,避免出现极大的数据溢出
        return 1.0 / (1.0 + np.exp(-z))
    else:
        return np.exp(z) / (1 + np.exp(z))

# 求导sigmoid函数
def sigmoid_prime(z):
    return sigmoid(z) * (1 - sigmoid(z))


# def cross_entropy_cost(a, y):
#     # a是预测值矩阵,y是真实值矩阵
#     n = a.shape[1]  # 样本数量
#     return -np.sum(y * np.log(a)) / n  # 交叉熵代价函数
#
#
# def relu(z):
#     return np.maximum(0, z)
#
#
# def relu_prime(z):
#     # return np.array(x > 0, dtype=x.dtype)
#     return (z > 0).astype(int)  # relu函数的导数

# # 交叉熵代价函数和L2正则化项  -(self.lmbda / m) * self.weights[-1]  # 加入L2正则化项
#
# def cost_function(output_activations, y):
#     return np.sum(np.nan_to_num(-y * np.log(output_activations) - (1 - y) * np.log(1 - output_activations)))
# def L2_regularization(self, lmbda, weights):
#     return lmbda * np.sum(np.square(weights)) / 2.0
#
# def cost_function_with_regularization(output_activations, y, weights, lmbda):
#     return cost_function(output_activations, y) + L2_regularization(lmbda, weights)

在交叉熵代价函数求导后加上L2正则化,先衰减偏置,再衰减权重,防止过拟合

# 后向传播
# 计算输出层误差, # 加上L2正则化
delta = (self.cross_entropy_cost_derivative(activations[-1], y) + 
         self.L2_regularization(self.weights[-1], m)) * sigmoid_prime(zs[-1])
# 计算输出层的偏置、权重梯度
nabla_b[-1] = np.array([np.mean(delta, axis=1)]).transpose()
nabla_w[-1] = (np.dot(delta, activations[-2].transpose()) / m)

在大范围的改变学习率时,运行报错,

RuntimeWarning: overflow encountered in exp return 1.0 / (1 + np.exp(-x))

参照网上的做法,对sigmoid函数的x做判断,if np.all(x>=0): #对sigmoid函数优化,避免出现极大的数据溢出

        return 1.0 / (1 + np.exp(-x))

    else:

        return np.exp(x)/(1+np.exp(x))

写交叉熵代价函数的导数时出现除0错误,于是对a加上很小的数

def cross_entropy_cost_derivative(self, a, y):
    # a是预测值矩阵,y是真实值矩阵
    epsilon = 1e-7
    a = a + epsilon  # 防止除0错误
    dc = -y / a  # 交叉熵代价函数的导数
    return dc

2.基于PyTorch模型

打开并统计数据集,发现训练集有50000个,验证集有10000个,测试集有10000个

对数据集的图像矩阵转成浮点型的张量,对目标转成长整型的张量

把图像张量和目标张量一一对应放到 TensorDataset()函数转成数据对象,然后调用DataLoader()函数分批打包数据,生成迭代器对象

把数据传进模型,进行训练和测试

定义Net类,继承Model类,实现初始化网络、定义网络每一层的对象放入列表,前向传播、把输入传进每一层对象、最后一层调用log_softmax()函数进行归一化; 输入训练数据进行前向传播,把结果放进交叉熵损失函数、后向传播计算梯度,更新参数,验证模型,测试模型,继续迭代,寻找最优参数

处理数据集的时候把图像和目标都转成浮点张量torch.Tensor(),然后报错,网上找原因,需要把目标转成 长整型的张量,因为使用交叉熵损失函数进行训练时,需要将标签转换为整数编码。y=LongTensor(y),以便进行后续的计算,而模型中并没有使用y=LongTensor(y)函数,则需要提前将目标转成长整型张量

train_images, train_labels = torch.tensor(tr_d[0], dtype=torch.float32), torch.tensor(tr_d[1], dtype=torch.long)

在处理数据集的时候,直接把张量放到DataLoader()里,然后报错了,查了书本后发现DataLoader()要传入dataset对象,需要把张量对应传入TensorDataset()函数生成dataset对象

train_dataset = TensorDataset(train_images, train_labels)
  • 三、对实验中参数和结果的分析

1.基于numpy库的模型

当使用默认参数:sizes=[784,30,10] ,epochs=30,mini_batch_size=10,

Lmbda=0.1 ,eta=1.3

测试最高精度是94.3%

运行时间79s

根据实验要求,分析不同隐藏层个数k和隐藏层神经元个数m对模型性能的影响:

由于我的电脑不太行,训练不同隐藏层个数k和隐藏层神经元个数m对模型性能的影响的时候需要很多时间,因此只训练2次出结果,结果可能会有偶然性。

当epochs=2,mini_batch_size=10,

Lmbda=0.1 ,eta=0.01,当只用一层隐藏层时,测试不同的神经元m对模型精度的影响,代码和结果如下

# 当隐藏层k=1时
accuracy_list=[]
for m in range(10,784):
    net = Network([784,m, 10])
    accuracy=net.SGD(training_data, 2, 10, 0.01, validation_data,m,test_data=test_data)
    accuracy_list.append(accuracy)

x = range(10, 784)
max_acc=max(accuracy_list)
max_index = accuracy_list.index(max_acc)
print(f"当神经元m={10+max_index} 时,验证精度最大值为:{max_acc}")
plt.plot(x, accuracy_list)
plt.xlabel('m')
plt.ylabel('val_accuracy')
plt.show()

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

当运行到m=297 时,就卡住了,因此只讨论10到297个神经元的结果:

当只用一层隐藏层,神经元个数为138时,验证集精度最高,为77.92%

当用两层隐藏层时,测试不同的神经元m对模型精度的影响,由于组合次数太多,不可能每个神经元都训练,因此固定第一个隐藏层为138,神经元个数逐层递减进行训练,代码和结果如下

......

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

当有两层隐藏层,[784,138,m,10],神经元个数为124时,验证集精度最高,为77.38%

当用三层隐藏层时,测试不同的神经元m对模型精度的影响,由于组合次数太多,不可能每个神经元都训练,因此固定第一个隐藏层为138,神经元个数逐层递减进行训练,代码和结果如下

........

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

当有三层隐藏层,[784,138,124,m,10],神经元个数为118时,验证集精度最高,为76.18%

根据以上结果,当学习率固定为0.01时,我认为模型最好的k是1 ,m是138,精度77.92%,因为增加层数后验证集精度并没有多大提升,反而浪费了时间, 有点奇怪,也可能是模型有点问题

            

学习率固定为0.01,可能学习率小,步长小,迭代30次精度才77%左右,当学习率为默认的1.3时,精度才快速到94%

2.基于PyTorch模型

当使用默认参数:layers=[784,30,10] ,epochs=30,mini_batch_size=10,

,lr=0.01weight_decay=0.0001时

测试最高精度是93.17%

运行时间171s

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

根据实验要求,分析不同隐藏层个数k和隐藏层神经元个数m对模型性能的影响:

由于我的电脑不太行,训练不同隐藏层个数k和隐藏层神经元个数m对模型性能的影响的时候需要很多时间,因此只训练2次出结果,结果可能会有偶然性。

当epochs=2,mini_batch_size=10,

lr=0.01,weight_decay=0.0001时,当只用一层隐藏层时,测试不同的神经元m对模型精度的影响,代码和结果如下

# 当隐藏层k=1时
accuracy_list=[]
for m in range(10,298):
    net = Net([784,m, 10])
    accuracy=train_and_test_net(net,training_data,validation_data,test_data,2,0.01,0.0001,m)
    accuracy_list.append(accuracy)

x = range(10,298)
max_acc=max(accuracy_list)
max_index = accuracy_list.index(max_acc)
print(f"当神经元m={10+max_index} 时,验证精度最大值为:{max_acc}")
plt.plot(x, accuracy_list)
plt.xlabel('m')
plt.ylabel('val_accuracy')
plt.show()

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

结果:当只用一层隐藏层,神经元个数为247时,验证集精度最高,为93.51%

当用两层隐藏层时,测试不同的神经元m对模型精度的影响,由于组合次数太多,不可能每个神经元都训练,因此固定第一个隐藏层为138,神经元个数逐层递减进行训练,代码和结果如下

......

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

结果: 当有两层隐藏层,[784,247,m,10],神经元个数为19时,验证集精度最高,为93.34%

当用三层隐藏层时,测试不同的神经元m对模型精度的影响,由于组合次数太多,不可能每个神经元都训练,因此固定第一个隐藏层为138,神经元个数逐层递减进行训练,代码和结果如下

.......

手写数字识别--神经网络实验,pytorch,深度学习,神经网络,手写数字识别

结果:当有三层隐藏层,[784,247,19,m,10],神经元个数为14时,验证集精度最高,为83.91%

根据以上结果,当学习率固定为0.01时,我认为模型最好的k是1 ,m是247,精度93.51%,因为增加层数后验证集精度并没有多大提升,反而浪费了时间和内存

            

四、两个模型的对比

基于numpy库的模型:

当使用默认参数:sizes=[784,30,10] ,epochs=30,mini_batch_size=10,

Lmbda=0.1 ,eta=1.3时

迭代30次后测试集最高精度是94.3%

运行时间79s

基于PyTorch模型

当使用默认参数:layers=[784,30,10] ,epochs=30,mini_batch_size=10,

,lr=0.01,weight_decay=0.0001时

测试最高精度是93.17%

运行时间171s

由此可见基于numpy库训练的模型比基于PyTorch的模型好,测试精度高,用的时间也少

基于numpy库的模型比较偏向底层,实现难,代码复杂,但运行速度快;基于PyTorch模型实现方式比较简单,代码比较简洁,但底层比较复杂,运行速度慢

训练神经网络模型首选PyTorch框架

五、总结

学会了很多,收获了很多,普通电脑只能训练小模型,以后遇到中模型肯定要用各大云平台的算力进行训练。

........................

下次做的深度学习实验:

手写数字识别加法器--深度学习实验-CSDN博客文章来源地址https://www.toymoban.com/news/detail-739058.html

到了这里,关于手写数字识别--神经网络实验的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 在树莓派上实现numpy的LSTM长短期记忆神经网络做图像分类,加载pytorch的模型参数,推理mnist手写数字识别

    这几天又在玩树莓派,先是搞了个物联网,又在尝试在树莓派上搞一些简单的神经网络,这次搞得是LSTM识别mnist手写数字识别 训练代码在电脑上,cpu就能训练,很快的: 然后需要自己在dataset里导出一些图片:我保存在了mnist_pi文件夹下,“_”后面的是标签,主要是在pc端导出

    2024年02月07日
    浏览(42)
  • pytorch-神经网络-手写数字分类任务

    Mnist分类任务: 网络基本构建与训练方法,常用函数解析 torch.nn.functional模块 nn.Module模块 读取Mnist数据集 会自动进行下载 注意数据需转换成tensor才能参与后续建模训练 torch.nn.functional 很多层和函数在这里都会见到 torch.nn.functional中有很多功能,后续会常用的。那什么时候使

    2024年02月09日
    浏览(36)
  • 神经网络基础-手写数字识别

    基本原理 图像本质上被认为是一个矩阵,每个像素点都是一个对应的像素值,相当于在多维数据上进行相关的归类或者其他操作。 线性函数 线性函数的一个从输入到输出的映射,用于给目标一个每个类别对应的得分。 图像 ( 32 ∗ 32 ∗ 3 ) → f ( x , W ) Y 图像(32*32*3) stackrel{

    2024年02月02日
    浏览(37)
  • 手写数字识别-基于卷积神经网络

    🌞欢迎来到机器学习的世界  🌈博客主页:卿云阁  💌欢迎关注🎉点赞👍收藏⭐️留言📝 🌟本文由卿云阁原创! 🌠本阶段属于练气阶段,希望各位仙友顺利完成突破 📆首发时间:🌹2021年6月5日🌹 ✉️希望可以和大家一起完成进阶之路! 🙏作者水平很有限,如果发

    2024年02月10日
    浏览(42)
  • 【深度学习】2-4 神经网络-手写数字识别

    在实现对手写数字图像的分类,可以先假设学习已经全部结束,我们使用学习到的参数,先实现神经网络的“推理处理”。该处理也称为神经网络的 前向传播 。 和求解机器学习问题的步骤(分成学习和推理两个阶段进行)一样 使用神经网络解决问题时,也需要 首先使用训练数

    2024年02月09日
    浏览(58)
  • 在树莓派上实现numpy的conv2d卷积神经网络做图像分类,加载pytorch的模型参数,推理mnist手写数字识别,并使用多进程加速

    这几天又在玩树莓派,先是搞了个物联网,又在尝试在树莓派上搞一些简单的神经网络,这次搞得是卷积识别mnist手写数字识别 训练代码在电脑上,cpu就能训练,很快的: 然后需要自己在dataset里导出一些图片:我保存在了mnist_pi文件夹下,“_”后面的是标签,主要是在pc端导

    2024年02月07日
    浏览(33)
  • 用C语言构建一个手写数字识别神经网络

    (原理和程序基本框架请参见前一篇 \\\"用C语言构建了一个简单的神经网路\\\") 1.准备训练和测试数据集 从http://yann.lecun.com/exdb/mnist/下载手写数字训练数据集, 包括图像数据train-images-idx3-ubyte.gz 和标签数据 train-labels-idx1-ubyte.gz. 分别将他们解压后放在本地文件夹中,解压后文件名

    2024年02月14日
    浏览(35)
  • CNN卷积神经网络实现手写数字识别(基于tensorflow)

    卷积网络的 核心思想 是将: 局部感受野 权值共享(或者权值复制) 时间或空间亚采样 卷积神经网络 (Convolutional Neural Networks,简称: CNN )是深度学习当中一个非常重要的神经网络结构。它主要用于用在 图像图片处理 , 视频处理 , 音频处理 以及 自然语言处理 等等。

    2024年02月11日
    浏览(41)
  • pytorch学习——如何构建一个神经网络——以手写数字识别为例

    目录 一.概念介绍 1.1神经网络核心组件 1.2神经网络结构示意图 1.3使用pytorch构建神经网络的主要工具 二、实现手写数字识别 2.1环境 2.2主要步骤 2.3神经网络结构 2.4准备数据 2.4.1导入模块 2.4.2定义一些超参数 2.4.3下载数据并对数据进行预处理 2.4.4可视化数据集中部分元素  2

    2024年02月14日
    浏览(31)
  • 卷积神经网络(CNN)入门:使用Python实现手写数字识别

    在上一篇文章中,我们介绍了如何使用Python实现一个简单的前馈神经网络。本文将重点介绍卷积神经网络(CNN),这是一种在计算机视觉任务中表现优异的深度学习模型。我们将从卷积神经网络的基本原理开始,介绍卷积层、池化层和全连接层等概念,然后使用Python和Keras库

    2023年04月15日
    浏览(51)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包