深度学习入门(4)【深度学习实战】无框架实现两层神经网络的搭建与训练过程

简介: 深度学习入门(4)【深度学习实战】无框架实现两层神经网络的搭建与训练过程

上一篇文章《深度学习入门(3)神经网络参数梯度的计算方式》主要介绍神经网络中的参数梯度是如何计算的。本文将直接使用之前公众号介绍过损失函数、激活函数以及梯度计算直接手动实现一个两层的神经网络训练过程。


也许有人会说使用pytorch或者tensorflow框架,几行代码就可以搭建一个神经网络,为什么要自己手动去实现呢?我觉得使用现成框架确实很容易搭建一个神经网络,但是对于其中的计算原理如果不了解的话,那始终只会停在使用框架的基础上,如果能够自己亲手去了解其中的工作原理,手动去实现一下,也许能够对其有更深刻的理解,这也能够为后续自己去更好的优化一个神经网络提供基础。


本文将介绍一个两层神经网络的搭建过程,并且以手写体数字集Mnist对所搭建的神经网络进行训练。

神经网络的训练过程

20201129225408441.png

20201129225441738.png


神经网络的学习按照上面4个步骤进行。这个方法通过梯度下降法更新参数,不过因为这里使用的数据是随机选择的mini batch数据,所以又称为随机梯度下降法( stochastic gradient descent)—SGD。“随机”指的是“随机选择的”的意思,因此,随机梯度下降法是“对随机选择的数据进行的梯度下降法”。深度学习的很多框架中,随机梯度下降法一般由一个名为SGD的函数来实现。SGD来源于随机梯度下降法的英文名称的首字母。


构建辅助函数


首先我们先将之前文章中的损失函数激活函数以及梯度计算的代码给弄过来,用于辅助神经网络的构建。如果对于这几个函数不太清楚可以点击相应链接,看之前写过的文章。


def sigmoid(x):
    # sigmoid激活函数
    return 1 / (1 + np.exp(-x))
def sigmoid_grad(x):
    # 计算sigmoid激活函数的梯度
    return (1.0 - sigmoid(x)) * sigmoid(x)
def softmax(x):
    # softmax激活函数,用于输出层
    if x.ndim == 2:
        x = x.T
        x = x - np.max(x, axis=0)
        y = np.exp(x) / np.sum(np.exp(x), axis=0)
        return y.T
    x = x - np.max(x) # 溢出对策
    return np.exp(x) / np.sum(np.exp(x))
def cross_entropy_error(y, t):
    # 损失函数使用交叉熵函数
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)
    # 监督数据是one-hot-vector的情况下,转换为正确解标签的索引
    if t.size == y.size:
        t = t.argmax(axis=1)
    batch_size = y.shape[0]
    return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size
def numerical_gradient(f, x):
    # 计算损失函数f的参数x的梯度
    h = 1e-4  # 0.0001
    grad = np.zeros_like(x)
    it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
    while not it.finished:
        idx = it.multi_index
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x)  # f(x+h)
        x[idx] = tmp_val - h
        fxh2 = f(x)  # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2 * h)
        x[idx] = tmp_val  # 还原值
        it.iternext()
    return grad


二层神经网络的搭建


class TwoLayerNet:
    def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):
        # 初始化权重
        self.params = {}
        # 先用高斯分布进行权重参数的初始化,然后对其进行训练
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size)
        self.params['b2'] = np.zeros(output_size)
    def predict(self, x):
        # 对输入x进行预测,并输出预测值y
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        return y
    # x:输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        # 使用交叉熵误差作为目标损失函数
        return cross_entropy_error(y, t)
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        t = np.argmax(t, axis=1)
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
    # x:输入数据, t:监督数据
    def numerical_gradient(self, x, t):
        # 使用数值微分来计算梯度
        # loss_W为损失函数
        loss_W = lambda W: self.loss(x, t)
        grads = {}
        # 计算各个参数的梯度
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        return grads
    def gradient(self, x, t):
        # 使用误差的反向传播来计算梯度
        W1, W2 = self.params['W1'], self.params['W2']
        b1, b2 = self.params['b1'], self.params['b2']
        grads = {}
        batch_num = x.shape[0]
        # forward
        a1 = np.dot(x, W1) + b1
        z1 = sigmoid(a1)
        a2 = np.dot(z1, W2) + b2
        y = softmax(a2)
        # backward
        dy = (y - t) / batch_num
        grads['W2'] = np.dot(z1.T, dy)
        grads['b2'] = np.sum(dy, axis=0)
        da1 = np.dot(dy, W2.T)
        dz1 = sigmoid_grad(a1) * da1
        grads['W1'] = np.dot(x.T, dz1)
        grads['b1'] = np.sum(dz1, axis=0)
        return grads


各个参数说明如下:


20201129225528325.png

20201129225554135.png

该代码中包含两种参数梯度的计算方式numerical_gradient与gradient,其中numerical_gradient是使用的之前文章讲过的数值微分的方式计算参数梯度值的,而gradient则是使用的误差的反向传播来计算梯度值的,这种计算方式比微分方式计算梯度值更加快速。因此,在使用神经网络梯度计算通常会使用误差的反向传播来计算梯度。这个后续文章会进行详细讲解。


神经网络的训练


以上两层的神将网络已经搭建好了,下面我们以经典的手写体数字识别mnist数字集,使用上述神经网络进行训练,过程如下:


# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)
x_train = x_train[:5000] #仅选择前5000个数据进行训练测试
x_test = x_test[:5000]
train_loss_list = [] # 记录误差的变化情况
# 超参数
iters_num = 6000  # 设定迭代的次数
train_size = x_train.shape[0]
batch_size = 100 # 每一批取100个样本
learning_rate = 0.1
# 设置输入层784, 隐藏层50,层50
network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)
iter_per_epoch = max(train_size / batch_size, 1)
for i in range(iters_num):
    # 获取mini-batch
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    # 计算梯度
    #数值方式计算梯度
    # grad = network.net_numerical_gradient(x_batch, t_batch) 
    # 误差的反向传播方式计算梯度
    grad = network.gradient(x_batch, t_batch)
    # 通过梯度更新每组参数
    for key in ('W1', 'b1', 'W2', 'b2'):
        network.params[key] -= learning_rate * grad[key]
    # 记录学习过程
    loss = network.loss(x_batch, t_batch)
    train_loss_list.append(loss)
    if i % iter_per_epoch == 0:
        print("train loss," + str(loss))
# 将每一步训练的结果得到的损失函数值打印出来
x = np.arange(len(train_loss_list))
plt.plot(x, train_loss_list, label='train loss')
plt.xlabel("iteration")
plt.ylabel("loss")
plt.show()


上述得到损失函数值随训练的推移如下:


2020112922591614.png

由上图可以发现随着学习的进行,损失函数的值在不断减小。说明神经网络的权重参数在逐渐拟合数据,并逐渐向最优参数靠近。

然后使用训练得到的神经网络,即可对未知的数据集进行预测。下一篇文章会介绍对神经网络的评估过程。

目录
打赏
0
0
0
0
110
分享
相关文章
基于Python深度学习的眼疾识别系统实现~人工智能+卷积网络算法
眼疾识别系统,本系统使用Python作为主要开发语言,基于TensorFlow搭建卷积神经网络算法,并收集了4种常见的眼疾图像数据集(白内障、糖尿病性视网膜病变、青光眼和正常眼睛) 再使用通过搭建的算法模型对数据集进行训练得到一个识别精度较高的模型,然后保存为为本地h5格式文件。最后使用Django框架搭建了一个Web网页平台可视化操作界面,实现用户上传一张眼疾图片识别其名称。
74 4
基于Python深度学习的眼疾识别系统实现~人工智能+卷积网络算法
猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
宠物识别系统使用Python和TensorFlow搭建卷积神经网络,基于37种常见猫狗数据集训练高精度模型,并保存为h5格式。通过Django框架搭建Web平台,用户上传宠物图片即可识别其名称,提供便捷的宠物识别服务。
288 55
基于yolov4深度学习网络的排队人数统计系统matlab仿真,带GUI界面
本项目基于YOLOv4深度学习网络,利用MATLAB 2022a实现排队人数统计的算法仿真。通过先进的计算机视觉技术,系统能自动、准确地检测和统计监控画面中的人数,适用于银行、车站等场景,优化资源分配和服务管理。核心程序包含多个回调函数,用于处理用户输入及界面交互,确保系统的高效运行。仿真结果无水印,操作步骤详见配套视频。
41 18
基于yolov4深度学习网络的公共场所人流密度检测系统matlab仿真,带GUI界面
本项目使用 MATLAB 2022a 进行 YOLOv4 算法仿真,实现公共场所人流密度检测。通过卷积神经网络提取图像特征,将图像划分为多个网格进行目标检测和识别,最终计算人流密度。核心程序包括图像和视频读取、处理和显示功能。仿真结果展示了算法的有效性和准确性。
68 31
基于图神经网络的大语言模型检索增强生成框架研究:面向知识图谱推理的优化与扩展
本文探讨了图神经网络(GNN)与大型语言模型(LLM)结合在知识图谱问答中的应用。研究首先基于G-Retriever构建了探索性模型,然后深入分析了GNN-RAG架构,通过敏感性研究和架构改进,显著提升了模型的推理能力和答案质量。实验结果表明,改进后的模型在多个评估指标上取得了显著提升,特别是在精确率和召回率方面。最后,文章提出了反思机制和教师网络的概念,进一步增强了模型的推理能力。
67 4
基于图神经网络的大语言模型检索增强生成框架研究:面向知识图谱推理的优化与扩展
鸿蒙应用开发从入门到入行 - 篇7:http网络请求
在本篇文章里,您将掌握鸿蒙开发工具DevEco的基本使用、ArkUI里的基础组件,并通过制作一个简单界面掌握使用
76 8
图卷积网络入门:数学基础与架构设计
本文系统地阐述了图卷积网络的架构原理。通过简化数学表述并聚焦于矩阵运算的核心概念,详细解析了GCN的工作机制。
126 3
图卷积网络入门:数学基础与架构设计
基于GoogleNet深度学习网络的手语识别算法matlab仿真
本项目展示了基于GoogleNet的深度学习手语识别算法,使用Matlab2022a实现。通过卷积神经网络(CNN)识别手语手势,如"How are you"、"I am fine"、"I love you"等。核心在于Inception模块,通过多尺度处理和1x1卷积减少计算量,提高效率。项目附带完整代码及操作视频。
网络编程懒人入门(十六):手把手教你使用网络编程抓包神器Wireshark
Wireshark是一款开源和跨平台的抓包工具。它通过调用操作系统底层的API,直接捕获网卡上的数据包,因此捕获的数据包详细、功能强大。但Wireshark本身稍显复杂,本文将以用抓包实例,手把手带你一步步用好Wireshark,并真正理解抓到的数据包的各项含义。
111 2
基于深度学习网络的宝石类型识别算法matlab仿真
本项目利用GoogLeNet深度学习网络进行宝石类型识别,实验包括收集多类宝石图像数据集并按7:1:2比例划分。使用Matlab2022a实现算法,提供含中文注释的完整代码及操作视频。GoogLeNet通过其独特的Inception模块,结合数据增强、学习率调整和正则化等优化手段,有效提升了宝石识别的准确性和效率。

热门文章

最新文章

AI助理

你好,我是AI助理

可以解答问题、推荐解决方案等