2.神经网络的实现

news2024/11/25 4:47:25

创建神经网络类

import numpy
# scipy.special包含S函数expit(x)
import scipy.special
# 打包模块
import pickle

# 激活函数
def activation_func(x):
    return scipy.special.expit(x)

# 用于创建、 训练和查询3层神经网络
class neuralNetwork:
    # 初始化神经网络
    def __init__(self, inputnodes, hiddennodes, outputnodes, learningrate):
        # 设置 输入层, 隐藏层, 输出层 结点个数
        self.inodes = inputnodes
        self.hnodes = hiddennodes
        self.onodes = outputnodes
        # 两个链接权重矩阵 wih, who
        # w11 w21
        # w12 w22 etc
        self.wih = numpy.random.normal(0.0, pow(self.hnodes, -0.5), (self.hnodes, self.inodes))
        self.who = numpy.random.normal(0.0, pow(self.onodes, -0.5), (self.onodes, self.hnodes))
        # 学习率
        self.lr = learningrate
        # 激活函数是S函数，使用lambda定义函数
        # self.activation_function = lambda x: scipy.special.expit(x)
        # 使用lambda定义函数时无法打包保存神经网络对象

        self.activation_function = activation_func
        pass

    # 训练神经网络
    def train(self, inputs_list, targets_list):
        # 使用完全相同的方式从输入层前馈信号到最终输出层,因此代码几乎与query()相同
        inputs = numpy.array(inputs_list, ndmin=2).T
        # 使用包含期望值训练样本来训练网络
        targets = numpy.array(targets_list, ndmin=2).T
        hidden_inputs = numpy.dot(self.wih, inputs)
        hidden_outputs = self.activation_function(hidden_inputs)
        final_inputs = numpy.dot(self.who, hidden_outputs)
        # 此处的final_outputs和上面的hidden_outputs都经过了激活函数,后面更新权重时不需要再代入了
        final_outputs = self.activation_function(final_inputs)

        # 期望矩阵和输出矩阵相减获得误差矩阵
        output_errors = targets - final_outputs
        # 根据所连接的权重分割误差，为每个隐藏层结点重组这些误差
        hidden_errors = numpy.dot(self.who.T, output_errors)
        # 应用更新权重的矩阵形式表达式
        # 学习率*误差Ek*sigmoid(输出Ok)*(1-sigmoid(Ok))·前一层输出OjT
        self.who += self.lr * numpy.dot((output_errors * final_outputs * (1.0 - final_outputs)), numpy.transpose(hidden_outputs))
        self.wih += self.lr * numpy.dot((hidden_errors * hidden_outputs * (1.0 - hidden_outputs)), numpy.transpose(inputs))
        pass

    # 查询神经网络,接受输入,返回输出
    def query(self, inputs_list):
        # 将输入列表转换成二维列表,保证计算类型正确
        inputs = numpy.array(inputs_list, ndmin=2).T
        # 输入层-隐藏层权重矩阵 点乘 输入矩阵 = 隐藏层输入
        hidden_inputs = numpy.dot(self.wih, inputs)
        # 隐藏层输入应用激活函数
        hidden_outputs = self.activation_function(hidden_inputs)
        # 隐藏层-输出层权重矩阵 点乘 输隐藏层输出矩阵 = 输出层输入
        final_inputs = numpy.dot(self.who, hidden_outputs)
        # 输出层输入应用激活函数
        final_outputs = self.activation_function(final_inputs)
        return final_outputs

数据集采用在人工智能领域流行的手写数字的MNIST数据库，MNIST数据库的格式不容易使用， 因此其他人已经创建了相对简单的数据文件格式——CSV文件，其纯文本中的每一个值都是由逗号分
隔的。

训练集是用来训练神经网络的60 000个标记样本集。标记是指输入与期望的输出匹配，也就是答案应该是多少。
可以使用较小的只有10 000个样本的测试集来测试我们的想法或算法工作的好坏程度。 由于这也包含了正确的标记， 因此可以观察神经网络是否得到正确的答案。

在文本中， 这些记录或这些行的内容很容易理解：
第一个值是标签， 即书写者实际希望表示的数字， 如“7”或“9”。 这是我们希望神经网络学习得到的正确答案。随后的值，由逗号分隔，是手写体数字的像素值。像素数组的尺寸是28乘以28，因此在标签后有784个值。

# 读取并显示数据集数据表示的含义
import numpy
import matplotlib.pyplot as plt
# %matplotlib inline


data_file = open(".../mnist_train_100.csv", 'r')
data_list = data_file.readlines()
data_file.close()
print(len(data_list))

# 显示第一个
all_values = data_list[0].split(',')
# 将文本字符串转换成实数, .reshape((28,28))可以确保数字列表每28个元素折返一次,形成28乘28的方形矩阵
image_array = numpy.asfarray(all_values[1:]).reshape((28, 28))
# 对图像做处理
plt.imshow(image_array, cmap='Greys', interpolation='None')
# 显示图像
plt.show()

在将数据抛给神经网络之前需要准备数据

我们先前看到，如果输入数据和输出值， 形状正好适合， 这样它们就可以待在网络节点激活函数的舒适区域内，那么神经网络的工作会更出色。

我们需要做的第一件事情是将输入颜色值从较大的0到255的范围，缩放至较小的0.01 到 1.0的范围。 我们刻意选择0.01作为范围最低点，是为了避免先前观察到的0值输入最终会人为地造成权重更新失败。我们没有选择0.99作为输入的上限值， 是因为不需要避免输入1.0会造成这个问题。 我们只需要避免输出值为1.0。

将在0到255范围内的原始输入值除以255，就可以得到0到1范围的输入值。

然后，需要将所得到的输入乘以0.99，把它们的范围变成0.0 到0.99。接下来，加上0.01，将这些值整体偏移到所需的范围0.01到1.00。

scaled_input = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01

现在， 我们需要思考神经网络的输出。 先前， 我们看到输出值应该匹配激活函数可以输出值的范围。 我们使用的逻辑函数不能输出如 -2.0 或 255 这样的数字，能输出的范围为0.0到1.0，事实上不能达到0.0或1.0，这是逻辑函数的极限值，逻辑函数仅接近这两个极限，但不能真正到达那里。因此，看起来在训练时必须调整目标值。

我们要求神经网络对图像进行分类， 分配正确的标签。 这些标签是0到9共10个数字中的一个。 这意味着神经网络应该有10个输出层节点， 每个节点对应一个可能的答案或标签。 如果答案是“0”， 输出层第一个节点激发， 而其余的输出节点则保持抑制状态。

image-20230827200941222

依照这种方向，我们可以构建目标矩阵

onodes = 10
targets = numpy.zeros(onodes) + 0.01
targets[int(all_values[0])] = 0.99

# 训练网络
def train_network(network, output_nodes, train_path, epochs):

    # 加载MNIST训练数据集
    training_data_file = open(train_path, 'r')
    training_data_list = training_data_file.readlines()
    training_data_file.close()
    # 训练世代,即训练几次
    for e in range(epochs):
        # 遍历读取的训练集
        for record in training_data_list:
            all_values = record.split(',')
            # 将文本字符串转换成实数,并将输入颜色值从0~255缩小为0.01~1.0，保证输入
            inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
            # 目标数组
            targets = numpy.zeros(output_nodes) + 0.01
            # 设置目标数字对应的数组内容为0.99
            targets[int(all_values[0])] = 0.99
            network.train(inputs, targets)
            pass
        pass

# 测试单个输入
def query_network_one_input(network, img_data):
    # 设置输入
    inputs = (numpy.asfarray(img_data[:]) / 255.0 * 0.99) + 0.01
    # 查询网络
    outputs = network.query(inputs)
    # 取出输出数组中的最高值对应的下标
    label = numpy.argmax(outputs)
    return label


# 测试文件，文件中有多条数据
def query_network(network, test_path):
    # 读取测试数据
    test_data_file = open(test_path, 'r')
    test_data_list = test_data_file.readlines()
    test_data_file.close()

    # 评分表,回答正确添加一个1
    scorecard = []

    for record in test_data_list:
        all_values = record.split(',')
        # 取出目标数字
        correct_label = int(all_values[0])
        print("aim=", correct_label, end="")
        # 设置输入
        inputs = (numpy.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
        # 查询网络
        outputs = network.query(inputs)
        # 取出输出数组中的最高值对应的下标
        label = numpy.argmax(outputs)
        print("ans=", label)
        # 设置评分表
        if (label == correct_label):
            scorecard.append(1)
        else:
            scorecard.append(0)
            pass
        pass

    # 计算正确率
    scorecard_array = numpy.asarray(scorecard)
    print("performance = ", scorecard_array.sum() / scorecard_array.size)


# 保存神经网络对象
def save_network(path, network):
    with open(path, 'wb') as f:
        pickle.dump(network, f)


# 加载神经网络对象
def load_network(path):
    with open(path, 'rb') as f:
        network = pickle.load(f)
    return network

改进网络

调整学习率

学习率是影响梯度下降发生速度的重要参数。

image-20230827201853904

多次运行

通过提供更多爬下斜坡的机会， 有助于在梯度下降过程中进行权重更新

image-20230827201945500

结果呈现出不可预测性。 在大约5或7个世代时， 有一个甜蜜点。 在此之后， 性能会下降， 这可能是过度拟合的效果。 性能在6个世代的情况下下降， 这可能是运行中出了问题， 导致网络在梯度下降过程中被卡在了一个局部的最小值中。 事实上， 由于没有对每个数据点进行多次实验， 无法减
小随机过程的影响，

image-20230827202727930

直观上， 如果你打算使用更长的时间（多个世代） 探索梯度下降， 那么你可以承受采用较短的步长（学习率） ， 并且在总体上可以找到更好的路径， 这是有道理的。 确实， 对于MNIST学习任务， 我们的神经网络的甜蜜点看起来是5个世代。 请再次记住， 我们在使用一种相当不科学的方式来进行实验。 要正确、 科学地做到这一点， 就必须为每个学习率和世代组合进行多次实验， 尽量减少在梯度下降过程中随机性的影响。

改变网络形状

随着增加隐藏层节点的数量， 结果有所改善， 但是不显著。 由于增加一个隐藏层节点意味着增加了到前后层的每个节点的新网络链接， 这一切都会产生额外较多的计算， 因此训练网络所用的时间也显著增加了！ 因此， 必须在可容忍的运行时间内选择某个数目的隐藏层节点。

手写数字

import imageio.v2 as imageio
import neuralNetwork
import splitimg

# 分割图片保存目录
test = ".../test/"

# 分析含有多个数字的图片
def parse_img_numbers(img_path, network):
    result = 0
    number = splitimg.split_img(img_path, test)
    for i in range(0, number):
        img_array = imageio.imread(test + '%d.jpg' % i, pilmode='L')
        img_data = 255.0 - img_array.reshape(784)
        label = neuralNetwork.query_network_one_input(network, img_data)
        result += label * pow(10, number-1)
        number -= 1
    print(result)

# 分析只有一个数字的图片
def parse_img(img_path, network):
    img_array = imageio.imread(img_path, pilmode='L')
    img_data = 255.0 - img_array.reshape(784)
    label = neuralNetwork.query_network_one_input(network, img_data)
    return label

# 按数字分割图片
import cv2
import numpy as np

P_A = 10


def split_img(source_path, temp_save_path):

    # 图像resize
    dsize = 28
    img = cv2.imread(source_path)
    data = np.array(img)
    height = data.shape[0]
    width = data.shape[1]
    # 设置最小的文字像素高度
    min_val = 10

    start_i = -1
    end_i = -1
    # 存放每行的起止坐标
    rowinfo = []

    # 行分割
    for i in range(height):

        # 行中有字相关信息
        if (not data[i].all()):
            end_i = i
            if (start_i < 0):
                start_i = i
                pass
        # 行中无字相关信息
        elif (data[i].all() and start_i >= 0):
            if (end_i - start_i >= min_val):
                rowinfo.append((start_i, end_i))
                pass
            start_i, end_i = -1, -1

    # 列分割
    start_j = -1
    end_j = -1
    # 最小文字像素宽度
    min_val_word = 5
    # 分割后保存编号
    number = 0
    for start, end in rowinfo:
        for j in range(width):
            # 列中有字相关信息
            if (not data[start: end, j].all()):
                end_j = j
                if (start_j < 0):
                    start_j = j
                    pass
            # 列中无字信息
            elif (data[start: end, j].all() and start_j >= 0):
                if (end_j - start_j >= min_val_word):
                    img = data[start:end, start_j: end_j]
                    im2save = cv2.resize(cv2.copyMakeBorder(
                        img, P_A, P_A, P_A, P_A, cv2.BORDER_CONSTANT, value=(255, 255, 255)), (28, 28))  # 归一化处理
                    cv2.imwrite(temp_save_path + '%d.jpg' % number, im2save)
                    number += 1
                    pass
                start_j, end_j = -1, -1

    return number

让我们来看看是否可以到神经网络内部一探究竟， 是否能够理解神经网络所学习到的知识， 将神经网络通过训练搜集到的知识可视化。

我们可以观察权重， 这毕竟是神经网络学习的内容。 但是， 权重不太可能告诉我们太多信息。 特别是， 神经网络的工作方式是将学习分布到不同的链接权重中。 这种方式使得神经网络对损坏具有了弹性， 这就像是生物大脑的运行方式。 删除一个节点甚至相当多的节点， 都不太可能彻底破坏神经网络良好的工作能力。

向后查询

image-20230827203530166

https://github.com/makeyourownneuralnetwork/makeyourownneuralnetwork/blob/master/part3_neural_network_mnist_backquery.ipynb

上面是反向查询神经网络的代码

为了学习多样的变化类型，我们可以通过旋转图像创建新的训练数据

# create rotated variations
# rotated anticlockwise by 10 degrees
inputs_plus10_img = scipy.ndimage.interpolation.rotate(scaled_input.reshape(28,28), 10,cval=0.01, reshape=False)
# rotated clockwise by 10 degrees
inputs_minus10_img=scipy.ndimage.interpolation.rotate(scaled_input.reshape(28,28), -10,cval=0.01, reshape=False)

image-20230827203949024

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/937385.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

JUC的常见类

JUC的常见类

Callable interfacce 也是一种创建线程的方式 Runnable 能表示一个任务(run方法),返回void Callable 也能表示一个任务(call方法),返回一个具体的值,类型可以通过泛型参数来指定(object) 如果进行多线程操作,如果你只是关心多线程的执行过程,使用Runnable即可,如果是关心多线程…
阅读更多...
Lottery抽奖项目第二章第二节：搭建DDD四层结构

Lottery抽奖项目第二章第二节：搭建DDD四层结构

搭建DDD四层结构 DDD&#xff1a;Domain Driven Design 描述&#xff1a;基于DDD架构构建&#xff0c;初始化搭建工程结构 本节是陆续搭建系统和编码的开始&#xff0c;我们会优先完成一个基础工程的创建。一般在互联网企业这部分工作可能不需要反复处理&#xff0c;只需要在…
阅读更多...
自然语言处理(二)：近似训练

自然语言处理(二)：近似训练

近似训练 近似训练&#xff08;Approximate Training&#xff09;是指在机器学习中使用近似的方法来训练模型&#xff0c;以降低计算复杂度或提高训练效率。这种方法通常用于处理大规模数据集或复杂模型&#xff0c;其中精确的训练算法可能过于耗时或计算资源不足。 近似训练…
阅读更多...
14张图带你了解Android14中的酷炫的功能

14张图带你了解Android14中的酷炫的功能

14张图带你了解Android14中的酷炫的功能 在近期的几次更新中&#xff0c;Android系统经历了重要的升级。Android 12通过Material UI改变了外观&#xff0c;使界面更加优化。随后&#xff0c;Android 13在Android 12的基础上进一步提升了用户体验&#xff0c;使系统更加流畅。现…
阅读更多...
自己的第一个小程序《我们一起记账吧》

自己的第一个小程序《我们一起记账吧》

一&#xff0c;想法 为了控制自己不要乱花钱&#xff0c;曾经一段时间每天记账&#xff0c;当时用的是市面上比较受欢迎的一些记账工具&#xff0c;但大多数都是以个人角度来记账的&#xff0c;几乎没有以家庭为单位的多人协同记账类软件&#xff0c;虽然也有多人记账小程序&a…
阅读更多...
7.11 SpringBoot实战 全局异常处理 - 深入细节详解

7.11 SpringBoot实战 全局异常处理 - 深入细节详解

文章目录 前言一、异常分类1.1 业务异常1.2 参数校验异常1.3 通用异常兜底 二、保留异常现场2.1 请求地址2.2 请求header2.3 请求参数body2.4 构建异常上下文消息 最后 前言 全局异常处理, 你真的学会了吗&#xff1f; 学完上文&#xff0c;你有思考和动手实践吗&#xff1f;…
阅读更多...
pytorch实验室实用入门指南

pytorch实验室实用入门指南

module继承
阅读更多...
stm32之25.FLASH闪存

stm32之25.FLASH闪存

打开标准库 源码--- int main(void) {uint32_t d;Led_init();key_init();/* 初始化串口1波特率为115200bps&#xff0c;若发送/接收数据有乱码&#xff0c;请检查PLL */usart1_init(115200);printf("this is flash test\r\n");/* 解锁FLASH&#xff08;闪存&#xf…
阅读更多...
腾讯云服务器搭建网站详细教程_2023更新

腾讯云服务器搭建网站详细教程_2023更新

使用腾讯云服务器搭建网站全流程&#xff0c;包括轻量应用服务器和云服务器CVM建站教程&#xff0c;轻量可以使用应用镜像一键建站&#xff0c;云服务器CVM可以通过安装宝塔面板的方式来搭建网站&#xff0c;腾讯云服务器网分享使用腾讯云服务器建站教程&#xff0c;新手站长搭…
阅读更多...
系统架构设计高级技能 · Web架构

系统架构设计高级技能 · Web架构

现在的一切都是为将来的梦想编织翅膀&#xff0c;让梦想在现实中展翅高飞。 Now everything is for the future of dream weaving wings, let the dream fly in reality. 点击进入系列文章目录 系统架构设计高级技能 Web架构 一、Web架构介绍1.1 Web架构涉及技术1.2 单台服务…
阅读更多...
几个nlp的小任务（生成任务(摘要生成)）

几个nlp的小任务（生成任务(摘要生成)）

几个nlp的小任务生成任务——摘要生成 安装库选择模型加载数据集展示数据集数据预处理 tokenizer注意特殊的 token处理组成预处理函数调用map，对数据集进行预处理微调模型，设置参数设置数据收集器，将处理好的数据喂给模型封装测评方法将参数传给 trainer，开始训练安装库 选…
阅读更多...
交叉熵的简单理解：真实分布与非真实分布的交叉，完全对应，熵为0

交叉熵的简单理解：真实分布与非真实分布的交叉，完全对应，熵为0

目录 交叉熵的简单理解&#xff1a;真实分布与非真实分布的交叉&#xff0c;完全对应&#xff0c;熵为0 交叉熵的简单理解&#xff1a;真实分布与非真实分布的交叉&#xff0c;完全对应&#xff0c;熵为0 这个式子就是熵的表达式. 简单来说, 其意义就是在最优化策略下, 猜到颜…
阅读更多...
哪些自主品牌「霸榜」30万元向上战场？硬派越野/MPV再助力

哪些自主品牌「霸榜」30万元向上战场？硬派越野/MPV再助力

占乘用车市场不到20%份额的30万元以上价位&#xff0c;一直以来都是合资品牌的天下。现在&#xff0c;三家中国本土自主品牌已经率先突围。 高工智能汽车研究院监测数据显示&#xff0c;2023年1-7月&#xff0c;理想、比亚迪、蔚来进入30万元以上价位新车交付量TOP10&#xff…
阅读更多...
c++系列之指针

c++系列之指针

今天不是做题系列&#xff0c;是知识系列啦。 说到指针&#xff0c;我们初学这一定会气的牙痒痒把&#xff0c;笔者也是&#xff0c;这么我好久而不得呀&#xff0c;今天来让我们聊聊指针。 其一 首先&#xff0c;我们明确的知道&#xff0c;假如我们开一个变量&#xff0c;…
阅读更多...
Android studio 软件git使用

Android studio 软件git使用

在 test 分支添加的方法 , 现在切换到 master分支 总共 2 个分支 , 当前的分支是 test 出现了 先试一下 force checkout , 尝试之后发现 , 你更改没有带过来 , 以为哪个类在master分支没有 , 所以这边也没有 , 切回分支 test 发现之前的跟改没有 , 这样即可以找回 继续切换…
阅读更多...
SE5 - BM1684 人工智能边缘开发板入门指南 -- 模型转换、交叉编译、yolov5、目标追踪

SE5 - BM1684 人工智能边缘开发板入门指南 -- 模型转换、交叉编译、yolov5、目标追踪

介绍 我们属于SoC模式&#xff0c;即我们在x86主机上基于tpu-nntc和libsophon完成模型的编译量化与程序的交叉编译&#xff0c;部署时将编译好的程序拷贝至SoC平台&#xff08;1684开发板/SE微服务器/SM模组&#xff09;中执行。 注&#xff1a;以下都是在Ubuntu20.04系统上操…
阅读更多...
element-plus指定el-date-picker的弹出框位置

element-plus指定el-date-picker的弹出框位置

此处记录一下,通过popper-options指定popper出现的位置
阅读更多...
Presto之Driver个数

Presto之Driver个数

一. 前言 在Presto的Stage Performace中&#xff0c;每个Operator中都会有Driver个数的显示&#xff0c;如下图所示。本文主要介绍Presto中是如何决定Driver的个数的。 二. Driver个数 在Presto中&#xff0c;一个pipeline中启动多少个Driver&#xff0c;是由此Pipeline处理的S…
阅读更多...
tidb数据库5.4.3和6.5.3版本性能测试对比

tidb数据库5.4.3和6.5.3版本性能测试对比

作者&#xff1a; qizhining 原文来源&#xff1a; https://tidb.net/blog/5454621f 一、测试需求&#xff1a; 基于历史原因&#xff0c;我们的业务数据库一直使用5.4.3&#xff0c;最近由于研发提出需求&#xff1a;需要升级到6.5.3版本&#xff0c;基于版本不同&#x…
阅读更多...
sql：SQL优化知识点记录（四）

sql：SQL优化知识点记录（四）

&#xff08;1&#xff09;explain之ref介绍 type下的ref是非唯一性索引扫描具体的一个值 ref属性 例如&#xff1a;ti表先加载&#xff0c;const是常量 t1.other_column是个t1表常量 test.t1.ID&#xff1a;test库t1表的ID字段 t1表引用了shared库的t2表的col1字段&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023