手写数字识别：CNN-AlexNet

最新推荐文章于 2024-02-21 10:49:57 发布
最新推荐文章于 2024-02-21 10:49:57 发布
阅读量3.9k 收藏 58
点赞数 3
文章标签： cnn 深度学习 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46443403/article/details/122916444
版权

  1. 作业要求：
    手写体数字识别
    数据集：MNIST
    数据集下载网址：http://yann.lecun.com/exdb/mnist/
    参考网址： https://zhuanlan.zhihu.com/p/101262336
    https://blog.csdn.net/panrenlong/article/details/81736754
    深度神经网络方法（任选）：CNN、RNN、GNN、LSTM、MM、GCN……
    典型结构（任选）：AlexNet、VGG、GoogleNet……
    目标：只有一个，让网络跑起来

  2. 数据理解与获取：
    MNIST数据集是由60000个训练样本和10000个测试样本组成，每个样本都是一张28 * 28像素的灰度手写数字图片。
    获取方法一：
    官方网站下载：http://yann.lecun.com/exdb/mnist/
    一共4个文件，训练集、训练集标签、测试集、测试集标签
    在这里插入图片描述
    获取方法二：
    使用TensorFlow中input_data.py脚本来读取数据及标签，使用这种方式时，可以不用事先下载好数据集，会自动下载并存放到指定的位置。

  3. 实现思路
    使用tensorflow编写卷积神经网络（CNN）代码进行MNIST数据集的手写数字识别，整体采用Alexnet网络架构搭建神经网络，由于MNIST影像大小为28 x 28，所以网络结构做了相应调整，从而适应数据。MNIST训练集数据用于模型训练，计算训练集准确率，训练好模型将其保存在model文件夹，使用MNIST测试集进行模型测试，计算测试集准确率，总体测试准确率在96%以上。

  4. 网络架构介绍——AlexNet
    Alexnet架构本质上与Lenet架构相同，Alexnet将CNN卷积神经网络的基本原理应用到更深，更宽的网络中。
    对比Lenet架构：
    ① 更大的池化窗口，使用最大池化层
    ② 更大的卷积核窗口和步长
    ③ 新加了三层卷积层，更多的输出通道
    Alexnet架构主要使用到的新技术如下：
    （1） 使用ReLu作为CNN的激活函数，标准的CNN模型采用tanh或sigmoid激活函数，但是在进行梯度下降时，神经元梯度会趋于饱和，参数更新速度慢，在进行梯度下降计算时，Relu函数的训练速度更快，错误率更低。
    （2） 训练时使用Dropout随机忽略一部分神经元，以避免模型过拟合，以0.5的概率对每个隐层神经元的输出设为0，那些“失活的”的神经元不再进行前向传播并且不参与反向传播。dropout在前两个全连接层中使用，非常有效避免了过拟合。
    （3） 在CNN中采用重叠的最大池化，此前CNN中普遍使用平均池化，Alexnet网络架构全部采用最大池化，避免平均池化的模糊化效果。并且Alexnet中提出让步长比池化核的尺寸小，这样池化层的输出之间会有重叠和覆盖，提升了特征的丰富性。
    （4） 提出了LRU层，对局部神经元的活动创建竞争机制，使得其中响应比较大的值变得相对更大，并抑制其他反馈较小的神经元，增强了模型的泛化能力。
    AlexNet网络架构示意图：
    在这里插入图片描述
    AlexNet网络架构各层处理细节示意图：
    在这里插入图片描述
    Alexnet网络架构层级处理流程图：
    在这里插入图片描述

  5. 运行结果截图
    测试集测试结果，输出测试准确率，整体在96%以上：
    在这里插入图片描述
    在这里插入图片描述

  6. 核心代码和说明
    （1） 定义的超参数
    在这里插入图片描述
    （2） 模型结构
     input-输入数据：MNIST
    数据集被分为两部分：60000行的训练数据集（mnist.train）和10000行的测试数据集（mnist.test），每张图片是28281，输入数字是1784的数据，经过reshape后，维度格式为[28,28,1]
     第1层卷积,卷积大小变化为28    28—>2828
     池化大小变化为28    28—>1414
     归一化大小变化为 14    14—>1414
     第2层卷积,卷积大小变化为14    14—>1414
     池化大小变化为14    14—>77
     归一化大小变化为 7    7—>77
     第3层卷积,卷积大小变化为 7    7—> 77
     第4层卷积,卷积大小变化为 7    7—> 77
     第5层卷积,卷积大小变化为 7    7—> 77
     池化大小变为 7    7—>44
     归一化大小为7    7—>77
     第1层全连接层 ‘wd1’: shape为4    4*256
     dropout丢弃层
     第2层全连接层
     dropout丢弃层
     output输出层

# 数据获取与各参数定义与设置
# 获取mnist数据集，进行one-hot编码，其为一位有效编码
mnist = input_data.read_data_sets("mnist_sets", one_hot=True)
print("数据下载完成！")
# 设置网络超参数
# 学习率
learning_rate = 0.0001
# 迭代次数，每个样本迭代20次
epochs = 20
# 每进行一次迭代选择128个样本
batch_size = 128
# 模型训练的步数
display_step = 10
# 设置网络参数，图片大小为28*28像素，即784，输入维度
n_input = 784
# 类别有0-9十种，输出维度
n_classes = 10
# 神经元丢弃概率，以0.5的概率对每个隐层神经元的输出设为0
dropout = 0.5

# 占位符，用placeholder先占地方，样本个数不确定为None
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])

weights = {
    # wc1 卷积核11*11*1*96，输入为28*28*1，所以in_channel=1,96代表卷积核个数，表示有96个11*11*1的卷积核，96即产生特征图的个数
    'wc1': weight_var('wc1', [11, 11, 1, 96]),
    # wc2 卷积核5*5*96*256，输入为14*14*96，所以in_channel=96,256代表卷积核个数，表示有256个14*14*96的卷积核，256即产生特征图的个数
    'wc2': weight_var('wc2', [5, 5, 96, 256]),
    # wc3 卷积核3*3*256*384， 输入为7*7*256，所以in_channels=256,384代表卷积核个数，表示有384个7*7*256的卷积核,384即产生特征图的个数
    'wc3': weight_var('wc3', [3, 3, 256, 384]),
    # wc4 卷积核3*3*384*384， 输入为4*4*384，所以in_channels=384,384代表卷积核个数，表示有384个3*3*384的卷积核，384即产生特征图的个数
    'wc4': weight_var('wc4', [3, 3, 384, 384]),
    # wc5 卷积核3*3*384*256， 输入为4*4*384，所以in_channels=384,256代表卷积核个数，表示有256个3*3*384的卷积核，256即产生特征图的个数
    'wc5': weight_var('wc5', [3, 3, 384, 256]),
    # wd1 2*2*256*4096， 输入为2*2*256，所以将其展平则为1*(2*2*256),4096表示全连接层神经元的个数
    'wd1': weight_var('wd1', [4 * 4 * 256, 4096]),
    # wd2 4096*4096， 输入为[2*2*256,4096]，4096表示有4096个神经元
    'wd2': weight_var('wd2', [4096, 4096]),
    # out 4096,10， 输入为[4096,4096]，10表示有10类—> 0-9
    'out_w': weight_var('out_w', [4096, 10])
}
# 设置偏移量
biases = {
    # 卷积层
    'bc1': bias_var('bc1', [96]),
    'bc2': bias_var('bc2', [256]),
    'bc3': bias_var('bc3', [384]),
    'bc4': bias_var('bc4', [384]),
    'bc5': bias_var('bc5', [256]),
    # 全连接层
    'bd1': bias_var('bd1', [4096]),
    'bd2': bias_var('bd2', [4096]),
    # 输出层
    'out_b': bias_var('out_b', [n_classes])
}

# 定义卷积，池化，归一化，参数设置操作
# 定义卷积过程，参数为：名字，输入，卷积核，偏移量，步长
# padding=‘SAME’表示在做卷积前需要对输入图像进行0填充使卷积后的图像与输入图像有相同的维度
# x为一个四维的张量，四个维度分别表示一批训练的图片数量，图片高度和宽度及图片的通道数
def conv2d(name, x, W, b, strides=1, padding='SAME'):
    # strides = [1, strides, strides, 1]表示每个维度做卷积的步幅
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding=padding)
    x = tf.nn.bias_add(x, b)
    # Alexnet架构使用relu作为激活函数
    return tf.nn.relu(x, name=name)

# 定义池化过程 3*3
def maxpool2d(name, x, k=3, s=2, padding='SAME'):
    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, s, s, 1], padding=padding, name=name)

# 局部响应归一化LRU，使得其中响应比较大的值相对更大，并抑制其他反馈较小的神经单元，提高模型泛化能力
def norm(name, l_input, lsize=5):
    return tf.nn.lrn(l_input, lsize, bias=1.0, alpha=0.0001, beta=0.75, name=name)

# 设置网络参数，卷积核参数与偏移量
def weight_var(name, shape):
    return tf.get_variable(name=name, shape=shape, initializer=tf.contrib.layers.xavier_initializer())

def bias_var(name, shape):
    return tf.get_variable(name=name, shape=shape, initializer=tf.constant_initializer(0))

# 构建神经网络结构，定义Alexnet网络结构
def alexnet(x, weights, biases, dropout):
    # 输入数字是1*784的数据，将其reshape成28*28的影像
    x = tf.reshape(x, shape=[-1, 28, 28, 1])

    # 1 conv 第1层卷积，卷积大小变化为28*28->28*28
    conv1 = conv2d('conv1', x, weights['wc1'], biases['bc1'], padding='SAME')
    # 池化大小变化为28*28->14*14
    pool1 = maxpool2d('pool1', conv1, k=3, s=2, padding='SAME')
    # 归一化大小变化为 14*14->14*14
    norm1 = norm('norm1', pool1, lsize=5)

    # 2 conv 第2层卷积，卷积大小变化为14*14->14*14
    conv2 = conv2d('conv2', norm1, weights['wc2'], biases['bc2'], padding='SAME')
    # 池化大小变化为14*14->7*7
    pool2 = maxpool2d('pool2', conv2, k=3, s=2, padding='SAME')
    # 归一化大小变化为 7*7->7*7
    norm2 = norm('norm2', pool2, lsize=5)

    # 3 conv 第3层卷积，卷积大小变化为 7*7—> 7*7
    conv3 = conv2d('conv3', norm2, weights['wc3'], biases['bc3'], padding='SAME')

    # 4 conv 第4层卷积，卷积大小变化为 7*7—> 7*7
    conv4 = conv2d('conv4', conv3, weights['wc4'], biases['bc4'], padding='SAME')

    # 5 conv 第5层卷积，卷积大小变化为 7*7—> 7*7
    conv5 = conv2d('conv5', conv4, weights['wc5'], biases['bc5'], padding='SAME')
    # 池化大小变为 7*7->4*4
    pool5 = maxpool2d('pool5', conv5, k=3, s=2, padding='SAME')
    # 归一化大小为7*7->7*7
    norm5 = norm('norm5', pool5, lsize=5)

    # 1 fc 第1层全连接层 'wd1': 形状大小为4*4*256
    fc1 = tf.reshape(norm5, [-1, weights['wd1'].get_shape().as_list()[0]])
    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
    fc1 = tf.nn.relu(fc1)

    # dropout丢弃层
    fc1 = tf.nn.dropout(fc1, dropout)

    # 2 fc 第2全连接层
    # fc2=tf.reshape(fc1,[-1,weights['wd2'].get_shape().as_list()[0]])
    fc2 = tf.add(tf.matmul(fc1, weights['wd2']), biases['bd2'])
    fc2 = tf.nn.relu(fc2)

    # dropout丢弃层
    fc2 = tf.nn.dropout(fc2, dropout)

    # output输出层
    out = tf.add(tf.matmul(fc2, weights['out_w']), biases['out_b'])
    return out

# 定义模型，损失函数和优化器
# 前向传播的预测值
pred = alexnet(x, weights, biases, dropout)
# 交叉熵损失函数，参数分别为预测值pred和实际label值y，reduce_mean为求平均loss
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
# 梯度下降优化器
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# tf.equal()对比预测值的索引和实际label的索引是否一样，一样返回True，不一样返回False
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# 将pred即True或False转换为1或0,并对所有的判断结果求均值
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# 训练和评估模型，获得训练集的训练结果与测试集的测试准确率
# 初始化变量
init = tf.global_variables_initializer()
# 定义一个Session
with tf.Session() as sess:
    # 在sess里run一下初始化操作
    sess.run(init)
    step = 1

    # epoch 逐代循环
    for epoch in range(epochs + 1):
        # 迭代
        for _ in range(mnist.train.num_examples // batch_size):
            step += 1
            # get x,y  逐个batch的去取数据
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            # 获取批数据
            sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
            # 展示损失和精确度  每display_step显示一次
            if step % display_step == 0:
				 # 计算损失值和精确度，并输出
                loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x, y: batch_y})
                print("Epoch " + str(epoch) + ", Minibatch Loss=" + \
                      "{:.6f}".format(loss) + ", Training Accuracy= " + \
                      "{:.5f}".format(acc))
    print("Optimizer Finished!")
    # 存储训练好的模型
    saver.save(sess, model + "/model.ckpt", global_step=epoch)

    # 测试准确率并对应输出
    for _ in range(mnist.test.num_examples // batch_size):
        batch_x, batch_y = mnist.test.next_batch(batch_size)
        print("Testing Accuracy:", sess.run(accuracy, feed_dict={x: batch_x, y: batch_y}))
  1. 完整代码
# 导入tensorflow包
import tensorflow as tf
import os
# 导入数据
from tensorflow.examples.tutorials.mnist import input_data
# 获取mnist数据集，进行one-hot编码，其为一位有效编码
mnist = input_data.read_data_sets("mnist_sets", one_hot=True)
print("数据下载完成！")
# 设置网络超参数
# 学习率
learning_rate = 0.0001
# 迭代次数，每个样本迭代20次
epochs = 20
# 每进行一次迭代选择128个样本
batch_size = 128
# 模型训练的步数
display_step = 10
# 设置网络参数，图片大小为28*28像素，即784，输入维度
n_input = 784
# 类别有0-9十种，输出维度
n_classes = 10
# 神经元丢弃概率，以0.5的概率对每个隐层神经元的输出设为0
dropout = 0.5

# 占位符，用placeholder先占地方，样本个数不确定为None
x = tf.placeholder(tf.float32, [None, n_input])
y = tf.placeholder(tf.float32, [None, n_classes])

# 定义卷积，池化，归一化，参数设置操作
# 定义卷积过程，参数为：名字，输入，卷积核，偏移量，步长
# padding=‘SAME’表示在做卷积前需要对输入图像进行0填充使卷积后的图像与输入图像有相同的维度
# x为一个四维的张量，四个维度分别表示一批训练的图片数量，图片高度和宽度及图片的通道数
def conv2d(name, x, W, b, strides=1, padding='SAME'):
    # strides = [1, strides, strides, 1]表示每个维度做卷积的步幅
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding=padding)
    x = tf.nn.bias_add(x, b)
    # Alexnet架构使用relu作为激活函数
    return tf.nn.relu(x, name=name)

# 定义池化过程 3*3
def maxpool2d(name, x, k=3, s=2, padding='SAME'):
    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, s, s, 1], padding=padding, name=name)

# 局部响应归一化LRU，使得其中响应比较大的值相对更大，并抑制其他反馈较小的神经单元，提高模型泛化能力
def norm(name, l_input, lsize=5):
    return tf.nn.lrn(l_input, lsize, bias=1.0, alpha=0.0001, beta=0.75, name=name)

# 设置网络参数，卷积核参数与偏移量
def weight_var(name, shape):
    return tf.get_variable(name=name, shape=shape, initializer=tf.contrib.layers.xavier_initializer())

def bias_var(name, shape):
    return tf.get_variable(name=name, shape=shape, initializer=tf.constant_initializer(0))

weights = {
    # wc1 卷积核11*11*1*96，输入为28*28*1，所以in_channel=1,96代表卷积核个数，表示有96个11*11*1的卷积核，96即产生特征图的个数
    'wc1': weight_var('wc1', [11, 11, 1, 96]),
    # wc2 卷积核5*5*96*256，输入为14*14*96，所以in_channel=96,256代表卷积核个数，表示有256个14*14*96的卷积核，256即产生特征图的个数
    'wc2': weight_var('wc2', [5, 5, 96, 256]),
    # wc3 卷积核3*3*256*384， 输入为7*7*256，所以in_channels=256,384代表卷积核个数，表示有384个7*7*256的卷积核,384即产生特征图的个数
    'wc3': weight_var('wc3', [3, 3, 256, 384]),
    # wc4 卷积核3*3*384*384， 输入为4*4*384，所以in_channels=384,384代表卷积核个数，表示有384个3*3*384的卷积核，384即产生特征图的个数
    'wc4': weight_var('wc4', [3, 3, 384, 384]),
    # wc5 卷积核3*3*384*256， 输入为4*4*384，所以in_channels=384,256代表卷积核个数，表示有256个3*3*384的卷积核，256即产生特征图的个数
    'wc5': weight_var('wc5', [3, 3, 384, 256]),
    # wd1 2*2*256*4096， 输入为2*2*256，所以将其展平则为1*(2*2*256),4096表示全连接层神经元的个数
    'wd1': weight_var('wd1', [4 * 4 * 256, 4096]),
    # wd2 4096*4096， 输入为[2*2*256,4096]，4096表示有4096个神经元
    'wd2': weight_var('wd2', [4096, 4096]),
    # out 4096,10， 输入为[4096,4096]，10表示有10类————> 0-9
    'out_w': weight_var('out_w', [4096, 10])
}
# 设置偏移量
biases = {
    # 卷积层
    'bc1': bias_var('bc1', [96]),
    'bc2': bias_var('bc2', [256]),
    'bc3': bias_var('bc3', [384]),
    'bc4': bias_var('bc4', [384]),
    'bc5': bias_var('bc5', [256]),
    # 全连接层
    'bd1': bias_var('bd1', [4096]),
    'bd2': bias_var('bd2', [4096]),
    # 输出层
    'out_b': bias_var('out_b', [n_classes])
}

# 构建神经网络结构，定义Alexnet网络结构
def alexnet(x, weights, biases, dropout):
    # 输入数字是1*784的数据，将其reshape成28*28的影像
    x = tf.reshape(x, shape=[-1, 28, 28, 1])

    # 1 conv 第1层卷积
    # 卷积大小变化为28*28->28*28
    conv1 = conv2d('conv1', x, weights['wc1'], biases['bc1'], padding='SAME')
    # 池化大小变化为28*28->14*14
    pool1 = maxpool2d('pool1', conv1, k=3, s=2, padding='SAME')
    # 归一化大小变化为 14*14->14*14
    norm1 = norm('norm1', pool1, lsize=5)

    # 2 conv 第2层卷积
    # 卷积大小变化为14*14->14*14
    conv2 = conv2d('conv2', norm1, weights['wc2'], biases['bc2'], padding='SAME')
    # 池化大小变化为14*14->7*7
    pool2 = maxpool2d('pool2', conv2, k=3, s=2, padding='SAME')
    # 归一化大小变化为 7*7->7*7
    norm2 = norm('norm2', pool2, lsize=5)

    # 3 conv 第3层卷积
    # 卷积大小变化为 7*7—> 7*7
    conv3 = conv2d('conv3', norm2, weights['wc3'], biases['bc3'], padding='SAME')

    # 4 conv 第4层卷积
    # 卷积大小变化为 7*7—> 7*7
    conv4 = conv2d('conv4', conv3, weights['wc4'], biases['bc4'], padding='SAME')

    # 5 conv 第5层卷积
    # 卷积大小变化为 7*7—> 7*7
    conv5 = conv2d('conv5', conv4, weights['wc5'], biases['bc5'], padding='SAME')
    # 池化大小变为 7*7->4*4
    pool5 = maxpool2d('pool5', conv5, k=3, s=2, padding='SAME')
    # 归一化大小为7*7->7*7
    norm5 = norm('norm5', pool5, lsize=5)

    # 1 fc 第1层全连接层 'wd1': shape为4*4*256
    fc1 = tf.reshape(norm5, [-1, weights['wd1'].get_shape().as_list()[0]])
    fc1 = tf.add(tf.matmul(fc1, weights['wd1']), biases['bd1'])
    fc1 = tf.nn.relu(fc1)

    # dropout丢弃层
    fc1 = tf.nn.dropout(fc1, dropout)

    # 2 fc 第2全连接层
    # fc2=tf.reshape(fc1,[-1,weights['wd2'].get_shape().as_list()[0]])
    fc2 = tf.add(tf.matmul(fc1, weights['wd2']), biases['bd2'])
    fc2 = tf.nn.relu(fc2)

    # dropout丢弃层
    fc2 = tf.nn.dropout(fc2, dropout)

    # output输出层
    out = tf.add(tf.matmul(fc2, weights['out_w']), biases['out_b'])
    return out


# 定义模型，损失函数和优化器
# 前向传播的预测值
pred = alexnet(x, weights, biases, dropout)
# # 交叉熵损失函数，参数分别为预测值pred和实际label值y，reduce_mean为求平均loss
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred, labels=y))
# 梯度下降优化器
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
# tf.equal()对比预测值的索引和实际label的索引是否一样，一样返回True，不一样返回False
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))
# 将pred即True或False转换为1或0,并对所有的判断结果求均值
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))

# 定义一个saver,用于存储训练好的模型
saver = tf.train.Saver()
# 定义存储路径
model = "./model"
if not os.path.exists(model):
    os.makedirs(model)

# 训练和评估模型，获得训练集的训练结果与测试集的测试准确率
# 初始化变量
init = tf.global_variables_initializer()
# 定义一个Session
with tf.Session() as sess:
    # 在sess里run一下初始化操作
    sess.run(init)
    step = 1

    # epoch 逐代循环
    for epoch in range(epochs + 1):
        # 迭代
        for _ in range(mnist.train.num_examples // batch_size):
            step += 1
            # get x,y  逐个batch的去取数据
            batch_x, batch_y = mnist.train.next_batch(batch_size)
            # 获取批数据
            sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
            # 展示损失和精确度  每display_step显示一次
            if step % display_step == 0:
                # 计算损失值和精确度，并输出
                loss, acc = sess.run([cost, accuracy], feed_dict={x: batch_x, y: batch_y})
                print("Epoch " + str(epoch) + ", Minibatch Loss=" + \
                      "{:.6f}".format(loss) + ", Training Accuracy= " + \
                      "{:.5f}".format(acc))

    print("Optimizer Finished!")
    # 存储训练好的模型
    saver.save(sess, model + "/model.ckpt", global_step=epoch)

    # 测试准确率
    for _ in range(mnist.test.num_examples // batch_size):
        batch_x, batch_y = mnist.test.next_batch(batch_size)
        print("Testing Accuracy:", sess.run(accuracy, feed_dict={x: batch_x, y: batch_y}))
tick-tick
关注
  • 3
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
深度学习入门必看-手写数字识别
Python，数据分析，机器学习，深度学习
11-15 1万+
前言 目前深度学习框架paddlepaddle、tensorflow、pytorch比较，结合网上大神的总结，pytorch更好学，社区也大，教程较多，莫名其妙的错误比较少。它基于动态图，可以按照正常人的思路玩，API较稳定。 paddlepaddle的话同时支持动态图和静态图，但是社区还在建设中，版本迭代更新快。不过可以嫖百度的云计算服务，值得一试。而且配套的预训练模型和可视化等等开发工具也在上线中，蛮好用的。 tensorflow是出了名新手劝退框架，因为文档比较反萌新，版本兼容性较差（我曾在嫉妒
matlabalexnet图像识别代码-Digitrecognition-CNN--Monkeyspecies-CNN-TF:Digitrec
05-23
手写数字识别。 （SVM和CNN） 项目介绍：- SVM：-在MNIST数据集上实现线性和内核SVM。 您必须尝试使用​​不同的内核（线性，多项式，RBF）并在报告中比较结果。 您可以为此使用任何在线工具箱，例如LIBSVM（）或...
MNIST数据集手写数字识别（CNN）
热门推荐
sikh_0529的博客
09-17 2万+
MNIST 包括6万张28x28的训练样本，1万张测试样本，很多教程都会对它”下手”几乎成为一个 “典范”，可以说它就是计算机视觉里面的Hello World。所以我们这里也会使用MNIST来进行实战。前面在介绍卷积神经网络的时候说到过LeNet-5，LeNet-5之所以强大就是因为在当时的环境下将MNIST数据的识别率提高到了99%，这里我们也自己从头搭建一个卷积神经网络，也达到99%的准确率。
深度学习实战入门——CNN实现MNIST手写数字识别
人形自走写bug机的Blog
03-15 5891
深度学习实战入门——CNN实现MNIST手写数字识别 今天来从头自己搭一个非常简单的卷积网络，使用的数据集是MNIST. MNIST应该算是一个被用烂了的数据集了，非常非常适合初学，数据量比较小，数据处理、训练和预测的时间都比较短，可以很好地用于把控网络搭建的整个过程。 0x01 数据和自定义函数的准备 MNIST数据集的下载地址是http://yann.lecun.com/exdb/mnist/ ，可能稍微有一点点慢，有耐心即可。一共有四个文件： 文件名 说明 大小 train-image
【PyTorch][chapter 17][李宏毅深度学习]【无监督学习][ Auto-encoder]
4AM_明朝百晓生
02-21 1265
最初的Bag-of-words ，也叫做“词袋”，在信息检索中，Bag-of-words model假定对于一个文本，忽略其词序和语法，句法，将其仅仅看做是一个词集合，或者说是词的一个组合，文本中每个词的出现都是独立的，不依赖于其他词是否出现。我们能以多种形式去记忆（比如图像、声音，甚至如上图的词根记忆法），所以即便是数据破损丢失，我们也能回想起来,所以在输入中即使加入了噪声也不会影响模型的性能,只会使得鲁棒性更强.文章2：文章b = [1, 1, 1, 1, 0, 1, 1, 1, 0, 0]
MNIST手写数字数据集+7000张图片.rar
08-17
1、MNIST手写数字数据集，7000张高质量图片数据，图片格式为jpg，分为测试集和训练集。 2、数据集详情展示和更多数据集下载：https://blog.csdn.net/m0_64879847/article/details/132301975
CNN算法实现手写数字识别（MNIST数据集）
你好，明天，，的博客
05-29 2598
基本过程如下图所示： 可能会看不懂的地方附有注释说明，代码： import tensorflow.compat.v1 as tf tf.disable_v2_behavior() from tensorflow.examples.tutorials.mnist import input_data # download and extract the data set automatically # 初始化参数 def weight_variable(shape): initial =
深度学习--TensorFlow（项目）识别自己的手写数字（基于CNN卷积神经网络）
great_yzl的博客
10-15 2万+
目录 基础理论 一、训练CNN卷积神经网络 1、载入数据 2、改变数据维度 3、归一化 4、独热编码 5、搭建CNN卷积神经网络 5-1、第一层：第一个卷积层 5-2、第二层：第二个卷积层 5-3、扁平化 5-4、第三层：第一个全连接层 5-5、第四层：第二个全连接层（输出层） 6、编译 7、训练 8、保存模型 代码 二、识别自己的手写数字（图像） 1、载入数据 2、载入训练好的模型 3、载入自己写的数字图片并设置大小 4、转灰度图 5、转黑底白字、数据归一化..
基于卷积神经网络（cnn）的手写数字识别（PyTorch）
m0_53675977的博客
12-08 1万+
手写数字识别应用广泛，对其研究有重要价值。在众多算法中，卷积神经网络在手写数字识别上表现突出，而且在实现上诸多优点。使用卷积神经网络来处理手写数字是一个很好的选择。pytorch在算法实现上有着简洁，优雅等特点。因此采用卷积神经网络算法和pytorch框架来实现手写数字识别。
CNN实现手写数字识别（Pytorch）
weixin_46599926的博客
05-04 8825
CNN（卷积神经网络）主要包括卷积层、池化层和全连接层。输入数据经过多个卷积层和池化层提取图片信息后，最后经过若干个全连接层获得最终的输出。以下基于Pytorch框架搭建一个CNN神经网络实现手写数字识别。
手写数字识别
frcbob的博客
12-10 1万+
手写数字识别 任务输入：一系列手写数字图片，其中每张图片都是28x28的像素矩阵。 任务输出：经过了大小归一化和居中处理，输出对应的0~9的数字标签。 MNIST数据集 MNIST数据集是深度学习领域标准，易用的成熟数据集。 由6万个训练样本和1万个测试样本组成，每个样本都是一张28*28像素的灰度手写数字图片。 data包含三个元素的列表：train_set、val_set、 test_set，包括50 000条训练样本、10 000条验证样本、10 000条测试样本。每个样本包含手写
CNN之手写数字识别（Handwriting Recognition）
Remoa的休闲茶馆
02-27 6020
CNN之手写数字识别（Handwriting Recognition） 1、常用的包； 2、常见概念； 3、手写数字识别器实现； 3.1 数据准备； 3.2 构建网络； 3.3 运行模型； 3.4 测试模型； 3.5 查看卷积核与特征图
Alexnet网络训练手写数字识别
03-27
主要包含Alexnet网络训练Mnist手写数字说别的训练模型和预测程序
基于CNN的手写数字识别APP.zip
最新发布
04-07
经典模型如LeNet-5用于手写数字识别，而AlexNet、VGG、GoogLeNet、ResNet等现代架构在图像识别竞赛中取得突破性成果，推动了CNN技术的快速发展。如今，CNN已经成为深度学习图像处理领域的基石，并持续创新，如引入...
经典深度学习实战案例合集（CNN手写数字识别、CNN车牌识别、VGG、RestNet鸟类识别、Inception手语识别，等等）
06-24
深度学习35例-卷积神经网络（CNN）实现mnist手写数字识别 | 第1天 深度学习35例-卷积神经网络（CNN）彩色图片分类 | 第2天 深度学习35例-卷积神经网络（CNN）服装图像分类 | 第3天 深度学习35例-卷积神经网络（CNN）...
基于CNN-LSTM-Attention-Protypical Network的鸟类声纹识别.zip
04-07
经典模型如LeNet-5用于手写数字识别，而AlexNet、VGG、GoogLeNet、ResNet等现代架构在图像识别竞赛中取得突破性成果，推动了CNN技术的快速发展。如今，CNN已经成为深度学习图像处理领域的基石，并持续创新，如引入...
CNN卷积神经网络-总结
ScorpC的博客
03-05 568
随意浏览中发现一篇好文，推荐给新手们，简单容易理解。 原文地址：https://www.cnblogs.com/skyfsm/p/6790245.html，感谢！ 原文： 从神经网络到卷积神经网络（CNN） 我们知道神经网络的结构是这样的： 那卷积神经网络跟它是什么关系呢？ 其实卷积神经网络依旧是层级网络，只是层的功能和形式做了变化，可以说是传统神经网络的一个改进。比如下图中就多了许...
CNN卷积神经网络实现手写数字识别（基于tensorflow）
m0_63669388的博客
03-16 5827
cnn实现卷积神经网络，附全部代码，小白易懂。
CNN实现手写数字识别
pengxiang1998的博客
04-29 6948
手写数字识别一致是一个机器学习里面常见的案例，今天通过CNN来实现一个手写数字识别来介绍一个机器学习的流程。 数据预处理 from keras import datasets (x_train, y_train), (x_test, y_test) = datasets.mnist.load_data() x_train = x_train.reshape((60000, 28, 28, 1)) # 归一化，0-255不太方便神经网络进行计算，因此将范围缩小到0—1 x_train = x_train.as
CNN-F和AlexNet哪个好
05-27
CNN-F和AlexNet都是非常经典的卷积神经网络模型。CNN-F是Yann LeCun等人在1998年提出的，是卷积神经网络的开山之作。AlexNet是Alex Krizhevsky等人在2012年提出的，是深度学习在计算机视觉领域的重大突破之一。两者都有其优点和局限性，无法简单地说哪个更好。 CNN-F是一种非常简单的卷积神经网络模型，只有两个卷积层和一个全连接层。它在MNIST手写数字识别任务上表现良好，但是在更复杂的任务上表现不佳。AlexNet则是一种非常深的卷积神经网络模型，有8个卷积层和3个全连接层。它在ImageNet图像分类任务上表现出色，但是需要大量的计算资源和数据才能训练。 因此，选择哪个模型取决于具体的应用和数据集。如果数据集较小且任务相对简单，可以考虑使用CNN-F；如果数据集较大且任务相对复杂，可以考虑使用AlexNet。当然，随着深度学习的发展，现在已经有更加先进的卷积神经网络模型可供选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值