Python手写数字识别

已于 2023-06-08 13:57:13 修改
阅读量3.6k 收藏 81
点赞数 21
分类专栏： 神经网络 感知机 文章标签： python 深度学习 计算机视觉
于 2023-06-08 13:51:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TGYAO/article/details/131106173
版权

神经网络是手写数字识别中常用的机器学习模型。它由许多神经元组成，每个神经元接收输入并生成输出。在前向传递过程中，神经元计算一些权重和偏移量的线性组合，并将其输入到一个非线性的激活函数中，从而生成神经元的输出。输出层通常使用softmax函数，将神经网络的输出映射到每个数字类别的概率。训练神经网络通常使用反向传播算法，该算法用于计算网络中每个权重和偏移量的梯度，并用梯度下降算法调整这些参数以最小化损失函数。在训练完成后，手写数字图像可以通过前向传递神经网络来进行分类。梯度下降法是寻找损失函数最小值的常用方法，包括批量梯度下降、随机梯度下降和小批量梯度下降。选择哪种梯度下降法取决于具体的算法和任务需求

本项目的源代码已放在文章末尾，如果它对您有帮助，请点个赞或收藏支持一下哦~。

神经网络结构

一个完整的神经网络通常由多个基本的网络层堆叠而成。本项目中的三层全连接神经网络由三个全连接层构成，在每两个全连接层之间插入 ReLU 激活函数以引入非线性变换,最后使用 Softmax 层计算交叉熵损失，如图所示。因此本项目中使用的基本单元包括全连接层、ReLU 激活函数、Softmax 损失函数
在这里插入图片描述

MINIST数据集

MNIST数据集是一个手写数字图像数据集，由60,000个训练图像和10,000个测试图像组成。每个图像都是28x28像素的灰度图像，表示0到9之间的一个数字。该数据集常用于机器学习中的图像分类任务。

获取MNIST数据集的步骤如下：

  1. 访问MNIST官方网站：http://yann.lecun.com/exdb/mnist/
  2. 点击“Download”链接，下载四个压缩文件：train-images-idx3-ubyte.gz、train-labels-idx1-ubyte.gz、t10k-images-idx3-ubyte.gz和t10k-labels-idx1-ubyte.gz。
  3. 解压缩这四个文件，得到四个二进制文件。
  4. 使用Python等编程语言读取这四个文件，将其转换为图像和标签数据。可以使用第三方库，如numpy和scikit-learn，来读取和处理数据。

代码解读

mian.py

# coding=utf-8
import numpy as np
import struct
import os
import time
import matplotlib.pyplot as plt

from layers_1 import FullyConnectedLayer, ReLULayer, SoftmaxLossLayer

# 画图时的中文支持
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号

# 定义了 MNIST 数据集的存储路径和文件名
MNIST_DIR = "./mnist_data"
TRAIN_DATA = "train-images-idx3-ubyte"
TRAIN_LABEL = "train-labels-idx1-ubyte"
TEST_DATA = "t10k-images-idx3-ubyte"
TEST_LABEL = "t10k-labels-idx1-ubyte"


# 显示矩阵的形状和均值和标准差
def show_matrix(mat, name):
    # print(name + str(mat.shape) + ' mean %f, std %f' % (mat.mean(), mat.std()))
    pass


# 该类包括多个函数，用于加载数据集、建立模型、初始化模型、训练和评估
# 定义一个类名为 MNIST_MLP，表示一个多层感知机（Multilayer Perceptron）模型
class MNIST_MLP(object):
    # 初始化函数，传入了多个参数用于初始化神经网络
    def __init__(self, batch_size=90, input_size=784, hidden1=32, hidden2=16, out_classes=10, lr=0.01, max_epoch=2,
                 print_iter=100):
        self.batch_size = batch_size  # 每次训练迭代所使用的数据批次大小
        self.input_size = input_size  # 输入层神经元数量（即MNIST图像大小）
        self.hidden1 = hidden1  # 第一层隐藏层神经元数量
        self.hidden2 = hidden2  # 第二层隐藏层神经元数量
        self.out_classes = out_classes  # 输出层神经元数量（即分类数量）
        self.lr = lr  # 学习率，用于控制模型训练时每次参数的更新幅度
        self.max_epoch = max_epoch  # 最大训练轮数
        self.print_iter = print_iter  # 训练过程中每隔print_iter次输出一次日志信息
        self.accuracy_list = []  # 存储每次迭代的准确率
        self.loss_list = []  # 存储每次迭代损失

    # 该函数用于读取 MNIST 数据集的图像和标记，并将其存储为 numpy 数组，其中 is_images 参数为 True 表示读取图像，为 False 表示读取标记
    # 定义一个函数来读取mnist数据集
    def load_mnist(self, file_dir, is_images='True'):
        # 打开二进制文件并读取其中的数据
        bin_file = open(file_dir, 'rb')
        bin_data = bin_file.read()
        bin_file.close()
        # 解析文件头
        if is_images:
            # 如果是图像数据集，读取图像格式的文件头
            fmt_header = '>iiii'
            magic, num_images, num_rows, num_cols = struct.unpack_from(fmt_header, bin_data, 0)
        else:
            # 如果是标签数据集，读取标签格式的文件头
            fmt_header = '>ii'
            magic, num_images = struct.unpack_from(fmt_header, bin_data, 0)
            num_rows, num_cols = 1, 1
        # 计算数据的大小
        data_size = num_images * num_rows * num_cols
        # 解析数据
        mat_data = struct.unpack_from('>' + str(data_size) + 'B', bin_data, struct.calcsize(fmt_header))
        # 将数据重塑为一个矩阵
        mat_data = np.reshape(mat_data, [num_images, num_rows * num_cols])
        # 打印读取数据的相关信息
        print('Load images from %s, number: %d, data shape: %s' % (file_dir, num_images, str(mat_data.shape)))
        # 返回读取到的数据
        return mat_data

    # 调用 load_mnist 函数读取和存储 MNIST 中训练数据和测试数据的图像和标记
    def load_data(self):
        # 调用函数 load_mnist 读取和预处理 MNIST 中训练数据和测试数据的图像和标记
        # print('Loading MNIST data from files...')
        print('加载 MNIST 数据集 ...')
        train_images = self.load_mnist(os.path.join(MNIST_DIR, TRAIN_DATA), True)
        train_labels = self.load_mnist(os.path.join(MNIST_DIR, TRAIN_LABEL), False)
        test_images = self.load_mnist(os.path.join(MNIST_DIR, TEST_DATA), True)
        test_labels = self.load_mnist(os.path.join(MNIST_DIR, TEST_LABEL), False)
        self.train_data = np.append(train_images, train_labels, axis=1)
        self.test_data = np.append(test_images, test_labels, axis=1)
        # print(train_images.shape)
        # print(train_labels.shape)
        # print(test_images.shape)
        # print(test_labels.shape)

    # 将训练数据集打乱，以便更好地训练
    def shuffle_data(self):
        print('随机混洗 MNIST 数据...')
        np.random.shuffle(self.train_data)

    # 建立多层感知机神经网络，并定义各层的数量及其之间的连接关系
    def build_model(self):  # 建立网络结构
        print('构建多层感知机模型...')
        self.fc1 = FullyConnectedLayer(self.input_size, self.hidden1)
        self.relu1 = ReLULayer()
        self.fc2 = FullyConnectedLayer(self.hidden1, self.hidden2)
        self.relu2 = ReLULayer()
        self.fc3 = FullyConnectedLayer(self.hidden2, self.out_classes)
        self.softmax = SoftmaxLossLayer()
        self.update_layer_list = [self.fc1, self.fc2, self.fc3]

    # 初始化神经网络参数
    def init_model(self):
        # print('Initializing parameters of each layer in MLP...')
        print('初始化各层参数权值...')

        for layer in self.update_layer_list:
            layer.init_param()

    # 从文件加载神经网络参数（即权重和偏差）
    def load_model(self, param_dir):  # 加载神经网络权值
        print('从文件加载参数权值：' + param_dir)
        params = np.load(param_dir, allow_pickle=True).item()
        self.fc1.load_param(params['w1'], params['b1'])
        self.fc2.load_param(params['w2'], params['b2'])
        self.fc3.load_param(params['w3'], params['b3'])

    # 将神经网络的参数（即权重和偏差）保存到文件中以备后续调用
    def save_model(self, param_dir):
        print('保存权值和偏置到： ' + param_dir)
        params = {}
        params['w1'], params['b1'] = self.fc1.save_param()
        params['w2'], params['b2'] = self.fc2.save_param()
        params['w3'], params['b3'] = self.fc3.save_param()
        np.save(param_dir, params)

    # 神经网络的前向传播，即将输入数据通过神经网络传递，得出预测结果
    def forward(self, input):  # 神经网络的前向传播
        h1 = self.fc1.forward(input)
        h1 = self.relu1.forward(h1)
        h2 = self.fc2.forward(h1)
        h2 = self.relu2.forward(h2)
        h3 = self.fc3.forward(h2)
        prob = self.softmax.forward(h3)
        return prob

    # 神经网络的反向传播，即求解梯度，调整神经网络参数
    def backward(self):  # 神经网络的反向传播
        # TODO：神经网络的反向传播
        dloss = self.softmax.backward()
        dh3 = self.fc3.backward(dloss)
        dh2 = self.relu2.backward(dh3)
        dh2 = self.fc2.backward(dh2)
        dh1 = self.relu1.backward(dh2)
        dh1 = self.fc1.backward(dh1)

    # 根据梯度和学习率更新神经网络参数
    def update(self, lr):  # 神经网络的参数更新
        for layer in self.update_layer_list:
            layer.update_param(lr)

    # 使用反向传播和梯度下降训练多层感知机神经网络，使其逐渐适应数据集
    def train(self):
        # 计算每个batch中的样本数
        max_batch = self.train_data.shape[0] // self.batch_size  # [0]表示数据集的第一维，也就是数据集中样本的数量
        print('开始训练...')
        # 对于每个epoch
        for idx_epoch in range(3):
            # 将训练数据集随机打乱
            self.shuffle_data()
            # 对于每个batch
            for idx_batch in range(max_batch):
                # 从训练数据中取出当前batch的图片和标签
                batch_images = self.train_data[idx_batch * self.batch_size:(idx_batch + 1) * self.batch_size, :-1]
                batch_labels = self.train_data[idx_batch * self.batch_size:(idx_batch + 1) * self.batch_size, -1]
                # 使用前向传播算法计算预测概率
                prob = self.forward(batch_images)
                # 使用Softmax交叉熵函数计算损失
                loss = self.softmax.get_loss(batch_labels)
                # 使用反向传播算法进行梯度下降更新模型参数
                self.backward()
                self.update(self.lr)
                # 如果当前batch的序号可以整除打印迭代步数的间隔，打印该batch的损失
                if idx_batch % self.print_iter == 0:
                    print('Epoch %d, iter %d, loss: %.6f' % (idx_epoch, idx_batch, loss))
                    #  计算当前batch的预测准确率并存储下来
                    pred_results = np.zeros([batch_labels.shape[0]])
                    for idx in range(batch_labels.shape[0] // self.batch_size):
                        # 从当前batch中取出样本进行预测
                        batch_images_temp = batch_images[idx * self.batch_size:(idx + 1) * self.batch_size, :]
                        prob = self.forward(batch_images_temp)
                        pred_labels = np.argmax(prob, axis=1)
                        pred_results[idx * self.batch_size:(idx + 1) * self.batch_size] = pred_labels
                    # 计算准确率
                    acc = np.mean(pred_results == batch_labels)
                    self.accuracy_list.append(acc)  # 存储当前batch的预测准确率
                    self.loss_list.append(loss)  # 存储当前batch的预测准确率

    # 在测试数据集上对神经网络进行推断，并计算分类准确率
    def evaluate(self):  # 推断函数
        pred_results = np.zeros([self.test_data.shape[0]])
        start_time = time.time()
        for idx in range(self.test_data.shape[0] // self.batch_size):
            batch_images = self.test_data[idx * self.batch_size:(idx + 1) * self.batch_size, :-1]
            prob = self.forward(batch_images)
            end = time.time()
            # print(prob.shape)
            pred_labels = np.argmax(prob, axis=1)
            pred_results[idx * self.batch_size:(idx + 1) * self.batch_size] = pred_labels
        print("测试总时间: %f" % (time.time() - start_time))
        accuracy = np.mean(pred_results == self.test_data[:, -1])
        print('测试集准确率: %f' % accuracy)

        plt.plot(range(len(self.accuracy_list)), self.accuracy_list)
        plt.xlabel('迭代次数')
        plt.ylabel('准确率')
        plt.title('训练过程中准确率变化')
        plt.show()

        plt.plot(range(len(self.loss_list)), self.loss_list)
        plt.xlabel('迭代次数')
        plt.ylabel('准确率')
        plt.title('训练过程中损失变化')
        plt.show()


# 创建 MNIST_MLP 类的实例，并对参数进行初始化、加载数据、建立模型、初始化模型、训练、保存模型、加载模型和评估的一系列操作
if __name__ == '__main__':
    h1, h2, e = 32, 16, 1
    mlp = MNIST_MLP(hidden1=h1, hidden2=h2, max_epoch=e)
    mlp.load_data()
    mlp.build_model()
    mlp.init_model()
    start_time = time.time()
    mlp.train()
    print("训练总时间: %f" % (time.time() - start_time))
    mlp.save_model('mlp-%d-%d-%depoch.npy' % (h1, h2, e))
    mlp.load_model('mlp-%d-%d-%depoch.npy' % (h1, h2, e))
    mlp.evaluate()

这是一个使用多层感知机（MLP）进行手写数字分类的Python代码。

  1. 定义常量：定义了 MNIST 数据集的存储路径和文件名。
  2. 函数 load_mnist：该函数用于读取 MNIST 数据集的图像和标记，并将其存储为 numpy 数组，其中 is_images 参数为 True 表示读取图像，为 False 表示读取标记。
  3. 函数 show_matrix：显示矩阵的形状和均值和标准差。
  4. 类 MNIST_MLP：该类包括多个函数，用于加载数据集、建立模型、初始化模型、训练和评估。
  5. 函数 load_data：调用 load_mnist 函数读取和存储 MNIST 中训练数据和测试数据的图像和标记。
  6. 函数 shuffle_data：将训练数据集打乱，以便更好地训练。
  7. 函数 build_model：建立多层感知机神经网络，并定义各层的数量及其之间的连接关系。
  8. 函数 init_model：初始化神经网络参数。
  9. 函数 load_model：从文件加载神经网络参数（即权重和偏差）。
  10. 函数 save_model：将神经网络的参数（即权重和偏差）保存到文件中以备后续调用。
  11. 函数 forward：神经网络的前向传播，即将输入数据通过神经网络传递，得出预测结果。
  12. 函数 backward：神经网络的反向传播，即求解梯度，调整神经网络参数。
  13. 函数 update：根据梯度和学习率更新神经网络参数。
  14. 函数 train：使用反向传播和梯度下降训练多层感知机神经网络，使其逐渐适应数据集。
  15. 函数 evaluate：在测试数据集上对神经网络进行推断，并计算分类准确率。
  16. 在 main 函数中，创建 MNIST_MLP 类的实例，并对参数进行初始化、加载数据、建立模型、初始化模型、训练、保存模型、加载模型和评估的一系列操作。
# coding=utf-8    # 代码文件编码方式

import numpy as np   # 引入numpy库
import struct        # 引入struct库
import os            # 引入os库
import time          # 引入time库

# 实现了一个全连接层类，num_input是输入维度，num_output是输出维度
class FullyConnectedLayer(object):
    def __init__(self, num_input, num_output):
        self.num_input = num_input
        self.num_output = num_output
        print('\tFully connected layer with input %d, output %d.' % (self.num_input, self.num_output))

    # 初始化参数，std是初始化参数的标准差
    def init_param(self, std=0.01):
        self.weight = np.random.normal(loc=0.0, scale=std, size=(self.num_input, self.num_output))
        self.bias = np.zeros([1, self.num_output])

    # 前向传播计算, input是输入
    def forward(self, input):
        start_time = time.time()
        self.input = input
        # 全连接层的前向传播，计算输出结果
        self.output = np.dot(self.input, self.weight) + self.bias
        return self.output

    # 反向传播计算，top_diff是损失函数对输出的导数
    def backward(self, top_diff):
        # 计算参数梯度和本层损失
        self.d_weight = np.dot(self.input.T, top_diff)
        self.d_bias = np.sum(top_diff, axis=0, keepdims=True)
        bottom_diff = np.dot(top_diff, self.weight.T)
        return bottom_diff

    # 利用参数进行参数更新，lr是学习率
    def update_param(self, lr):
        self.weight -= lr * self.d_weight
        self.bias -= lr * self.d_bias

    # 加载参数，用于重新加载模型
    def load_param(self, weight, bias):
        assert self.weight.shape == weight.shape
        assert self.bias.shape == bias.shape
        self.weight = weight
        self.bias = bias

    # 用于保存参数，方便模型重新训练
    def save_param(self):
        return self.weight, self.bias

# 实现了一个ReLU激活函数层类
class ReLULayer(object):
    def __init__(self):
        print('\tReLU layer.')

    # 计算前向传播的输出结果
    def forward(self, input):
        start_time = time.time()
        self.input = input
        # ReLU层的前向传播，计算输出结果
        output = np.maximum(0, input)
        return output

    # 计算反向传播输出的损失结果
    def backward(self, top_diff):
        # ReLU层的反向传播，计算本层损失
        bottom_diff = top_diff.copy()
        bottom_diff[self.input<0] = 0
        return bottom_diff

# 实现了一个softmax激活函数层类
class SoftmaxLossLayer(object):
    def __init__(self):
        print('\tSoftmax loss layer.')

    # 计算前向传播的输出结果
    def forward(self, input):
        # softmax 损失层的前向传播，计算输出结果
        input_max = np.max(input, axis=1, keepdims=True)
        input_exp = np.exp(input - input_max)
        self.prob = input_exp / np.sum(input_exp, axis=1, keepdims=True)
        return self.prob

    # 计算损失
    def get_loss(self, label):
        self.batch_size = self.prob.shape[0]
        self.label_onehot = np.zeros_like(self.prob)
        self.label_onehot[np.arange(self.batch_size), label] = 1.0
        loss = -np.sum(np.log(self.prob) * self.label_onehot) / self.batch_size
        return loss

    # 计算反向传播输出的损失结果
    def backward(self):
        # softmax 损失层的反向传播，计算本层损失
        bottom_diff = (self.prob - self.label_onehot) / self.batch_size
        return bottom_diff

这段代码实现了一个简单的神经网络，包括全连接层、ReLU激活函数层和softmax损失函数层。其中，全连接层用于将输入数据进行线性变换，ReLU激活函数层用于增加网络的非线性能力，softmax损失函数层用于计算分类问题中的损失函数。代码中实现了前向传播和反向传播的计算，并且提供了参数初始化、参数更新、参数加载和保存等功能，方便模型的重新训练。

项目源码： https://gitee.com/TGY1817/handwritten-digit-recognition

浩茫
关注
专栏目录
python实现手写数字识别
weixin_42590539的博客
02-09 1373
手写数字识别是机器学习中的一个常见任务，使用 Python 实现不难。常用的方法包括使用神经网络模型，如卷积神经网络(Convolutional Neural Network, CNN)或循环神经网络(Recurrent Neural Network, RNN)。 首先，你需要准备训练数据，一般使用 MNIST 数据集。其次，你需要选择合适的神经网络模型，并使用 TensorFlow、Keras ...
Python手写体数字识别
01-25
基于sklearn的手写体数字识别
Python代码实现简单的MNIST手写数字识别（适合初学者看）
热门推荐
zugexiaodui的博客
08-12 5万+
补充：由于很多同学找我要原数据集和代码，所以我上传到了资源里，https://download.csdn.net/download/zugexiaodui/10913834 初学机器学习，第一步是做一个简单的手写数字识别，我选用的是MNIST数据集（用其他数据集也可以，原理都差不多），算法是KNN（下载库直接调用函数，算法的具体实现没有过多关心）。在网上也看到过MNIST数据集的Python代码...
PyTorch——手写数字识别
原谅我这一生不羁放纵爱自由
08-29 9185
目录PyTorch 学习 —— 手写数字识别Ⅰ. 数据读取器1. 训练集2. 验证集和测试集Ⅱ. 搭建网络Ⅲ. 模型训练1. 开始训练2. 模型验证Ⅲ. 模型测试Ⅳ. 绘制图像Ⅴ. 完整代码 PyTorch 学习 —— 手写数字识别   MNIST 数据集，其包含70000 个28×28 的手写数字的数据集，其中又分为60000 个训练样本与10000 个测试样本。 Ⅰ. 数据读取器 import torch from torch import nn from torch import optim fro
Python知识点：如何使用Python实现手写数字识别
最新发布
码农超哥的博客
09-04 868
要在 Python 中实现手写数字识别，可以使用深度学习库，例如 TensorFlow 或 PyTorch，结合经典的 MNIST 数据集。MNIST 数据集包含 28x28 像素的灰度手写数字图像及其对应的标签（0 到 9），是用于图像分类任务的标准数据集。
Python实现手写数字的识别
janestan的博客
09-29 9618
输入层(input layer)是由训练集的实例特征向量传入，经过连接结点的权重(weight)传入下一层，一层的输出是下一层的输入，隐藏层的个数可以是任意的，输入层有一层，输出层有一层，每个单元(unit)也可以被称作神经结点,根据生物学来源定义，一层中加权的求和，然后根据非线性方程转化输出。多层向前神经网络由以下部分组成：输入层(input layer),隐藏层(hidden layers),输入层(output layers)，每层由单元(units)组成。（1）通过迭代性的来处理训练集中的实例。
Python 手写数字识别的实现(pytorch框架) 超详细版本-jupyter notebook
weixin_43718786的博客
03-28 2万+
本文详细介绍了如何构建LeNet-5神经网络用于手写数字识别。 文中大量的代码解释包含在代码行后的注释中，请注意查看。 下面的代码在谷歌云盘的colab上运行，也可以在jupyter notebook上运行
用python实现手写数字识别
ducanwang的博客
02-19 1776
然后，它定义了一个简单的卷积神经网络模型，该模型包含两个卷积层、一个最大池化层、两个全连接层，并使用Dropout进行正则化。模型使用Adadelta优化器和分类交叉熵损失函数进行编译，并在训练过程中监视准确性。在这个问题中，我们通常会使用深度学习库，如TensorFlow或PyTorch，来构建一个卷积神经网络（CNN）来解决这个问题。这里，我将使用TensorFlow和Keras库来演示如何创建一个简单的手写数字识别模型。我们将使用MNIST数据集，这是一个广泛使用的手写数字数据集。
Python实战：手写数字识别
oandy0的博客
04-12 1882
手写数字识别是机器学习中的一个经典问题，它涉及到图像处理、特征提取和模式识别等多个领域。在这个项目中，我们将使用Python和一些开源库来构建一个简单的神经网络，用于识别手写数字。
Python手写数字识别代码-手写板
03-02
使用Python基于TensorFlow 卷积神经网络设计手写数字识别算法，并编程实现GUI 界面，构建手写数字识别系统。本系统界面设计友好，功能完善。通过测试，本识别系统对于较规范的手写体数字的识别达到了很好的识别效果...
Python手写数字识别系统完整工程文件
12-06
Python手写数字识别系统是一个基于图像处理和机器学习技术的应用，它允许用户通过手写输入数字，然后由系统自动识别并转换为对应的数字。在这个完整的工程文件中，包含了手写板程序、训练程序、测试程序以及训练模型...
手写数字识别（ＣＮＮ）的ｐｙｔｈｏｎ实现
12-31
卷积神经网络（Convolutional Neural Networks, CNN）是一类包含卷积计算且具有深度结构的前馈神经网络（Feedforward Neural Networks），是深度学习（deep learning）的代表算法之一 [1-2] 。卷积神经网络具有表征学习（representation learning）能力，能够按其阶层结构对输入信息进行平移不变分类（shift-invariant classification），因此也被称为“平移不变人工神经网络（Shift-Invariant Artificial Neural Networks, SIANN）” [3] 。
手写数字识别 python
06-27
基于knn的手写数字识别，利用python实现， 能够运行，测试集和训练集都有
基于卷积神经网络的手写数字识别python代码实现
04-20
基于卷积神经网络的手写数字识别python代码实现 卷积神经网络（Convolutional Neural Network,CNN）中，卷积层的神经元只与前一层的部分神经元节点相连，即它的神经元间的连接是非全连接的，且同一层中某些神经元之间的连接的权重 w 和偏移 b 是共享的（即相同的），这样大量地减少了需要训练参数的数量。
python实现识别手写数字 python图像识别算法
12-23
写在前面 这一段的内容可以说是最难的一部分之一了，因为是识别图像，所以涉及到的算法会相比之前的来说比较困难，所以我尽量会讲得清楚一点。 而且因为在编写的过程中，把前面的一些逻辑也修改了一些，将其变得更完善了，所以一切以本篇的为准。当然，如果想要直接看代码，代码全部放在我的GitHub中，所以这篇文章主要负责讲解，如需代码请自行前往GitHub。 本次大纲 上一次写到了数据库的建立，我们能够实时的将更新的训练图片存入CSV文件中。所以这次继续往下走，该轮到识别图片的内容了。 首先我们需要从文件夹中提取出需要被识别的图片test.png，并且把它经过与训练图片相同的处理得到1×10000大小的向量
Python手写数字识别带手写板GUI界面 Pytorch代码 含训练模型
06-07
# Python手写数字识别带手写板GUI界面 Pytorch代码 含训练模型 1. 使用Pytorch实现手写数字识别的神经网络，包含卷积层和全连接层； 2. 训练代码可自行训练，同时也包含训练了140epoch的pth模型，可直接使用； 3. ...
基于Python实现的手写数字识别系统.zip
06-21
手写数字的识别可以分成两大板块：一、手写数字模型的训练；二、手写数字的识别。其中最为关键的环节是手写数字模型的训练。本次选取使用的模型是多元线性回归模型。手写数字有 10 中，分别是 0~9，所以可以将该问题...
c语言实现手写数字识别代码,python手写数字识别代码,C,C++
09-10
标题中的"C语言实现手写数字识别代码,python手写数字识别代码,C,C++"表明我们将讨论的是关于手写数字识别的技术实现，主要集中在C、Python和C++这三种编程语言中。手写数字识别是一种模式识别技术，常用于OCR（光学...
基于Python实现手写数字识别
需要远程指导仿真实验、代码有问题的，请后台私信或者关注公众号
07-03 911
利用python及Keras建立神经网络对手写数字识别
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

浩茫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值