精华内容
下载资源
问答
  • 使用matlab实现的对MNIST手写数字进行识别,经测试,真实可用的。
  • 包含已分好类的minist数据,利用BP神经网络实现minist手写数字识别
  • 基于TensorFlow深度学习的Minist手写数字识别技术.pdf
  • MINIST手写数字识别——06.总结 训练之后,检查模型的预测准确度。用 MNIST 训练的时候,一般 softmax 回归模型的分类准确率为约为 92.64%,多层感知器为98.15%,卷积神经网络可以达到 99.01%。 应用模型 可以使用...

    MINIST手写数字识别——06.总结

    训练之后,检查模型的预测准确度。用 MNIST 训练的时候,一般 softmax 回归模型的分类准确率为约为 92.64%,多层感知器为98.15%,卷积神经网络可以达到 99.01%。

    应用模型

    可以使用训练好的模型对手写体数字图片进行分类,下面程序展示了如何使用训练好的模型进行推断。

    生成预测输入数据

    infer_3.png 是数字 3 的一个示例图像。把它变成一个 numpy 数组以匹配数据feed格式。

    import os
    import numpy as np
    import tensorflow as tf
    from PIL import Image # 导入图像处理模块
    import matplotlib.pyplot as plt
    
    # 打印 infer_3.png 这张图片
    filename = 'infer_3.png'
    img=Image.open(os.getcwd() + '/images/' + filename)
    plt.imshow(img)
    

    在这里插入图片描述

    def load_image(file):
        im = Image.open(file).convert('L')
        im = im.resize((28, 28), Image.ANTIALIAS)
        im = np.array(im).reshape(1, 28, 28, 1).astype(np.float32)
        im = im / 255.0 * 2.0 - 1.0
        return im
    
    tensor_img = load_image(os.getcwd() + '/images/' + filename)
    # tensor_img
    

    模型预测

    model_dir = "./mnist/cnn-model/"
    model_name = 'keras_mnist.h5'
    model_path = os.path.join(model_dir, model_name)
    print('CNN trained model at %s ' % model_path)
    

    CNN trained model at ./mnist/cnn-model/keras_mnist.h5

    mnist_model = tf.keras.models.load_model(model_path)
    pred_results = mnist_model.predict(tensor_img)
    lab = np.argsort(pred_results)
    lab
    

    array([[0, 8, 6, 4, 1, 9, 2, 5, 7, 3]])

    print("Inference result of infer_3.png is: %d" % lab[0][-1])
    

    Inference result of infer_3.png is: 3

    预测结果

    如果顺利,预测结果输入如下:
    Inference result of infer_3.png is: 3 , 说明我们的网络成功的识别出了这张图片!

    总结

    本案例的softmax回归、多层感知机和卷积神经网络是最基础的深度学习模型,很多复杂的神经网络都是从它们衍生出来的,因此这几个模型对之后的学习大有裨益。同时,我们也观察到从最简单的softmax回归变换到稍复杂的卷积神经网络的时候,MNIST数据集上的识别准确率有了大幅度的提升,原因是卷积层具有局部连接和共享权重的特性。在之后学习新模型的时候,希望大家也要深入到新模型相比原模型带来效果提升的关键之处。此外,本教程还介绍了Tensorflow 2模型搭建的基本流程,从网络层的构建,到最后的训练和预测。对这个流程熟悉以后,大家就可以用自己的数据,定义自己的网络模型,并完成自己的训练和预测任务了。

    展开全文
  • Tensorflow2.0之Minist手写数字识别

    千次阅读 2020-01-29 17:13:36
    Tensorflow2.0之Minist手写数字识别 注: 完整代码在最后 Minist数据集介绍  Minist数据集是(Lecun, Bottou, Bengio, & Haffner, 1998)发布的,它包含了0~9 共10 种数字的手写图片,每种数字一共有7000 张图片...

    Tensorflow2.0之Minist手写数字识别

    注: 完整代码在最后

    Minist数据集介绍

     Minist数据集是(Lecun, Bottou, Bengio, & Haffner, 1998)发布的,它包含了0~9 共10 种数字的手写图片,每种数字一共有7000 张图片,采集自不同书写风格的真实手写图片,一共70000 张图片。其中60000张图片作为训练集𝔻 t r a i n ^{train} train(Training Set),用来训练模型,剩下10000 张图片作为测试集𝔻 t e s t ^{test} test(Test Set),用来预测或者测试,训练集和测试集共同组成了整个MNIST 数据集。

     考虑到手写数字图片包含的信息比较简单,每张图片均被缩放到28 × 28的大小,同时
    只保留了灰度信息

     现在我们来看下图片的表示方法。一张图片包含了ℎ行(Height/Row),𝑤(Width/Column),每个位置保存了像素(Pixel)值,像素值一般使用0~255 的整形数值来表达颜色强度信息,例如0 表示强度最低,255 表示强度最高。如果是彩色图片,则每个像素点包含了R、G、B 三个通道的强度信息,分别代表红色通道、绿色通道、蓝色通道的颜色强度,所以与灰度图片不同,它的每个像素点使用一个1 维、长度为3 的向量(Vector)来表示,向量的3 个元素依次代表了当前像素点上面的R、G、B 颜色强值,因此彩色图片需要保存为形状是[ℎ, 𝑤, 3]的张量(Tensor,可以通俗地理解为3 维数组)。如果是灰度图片,则使用一个数值来表示灰度强度,例如0 表示纯黑,255 表示纯白,因此它只需要一个形状为[ℎ, 𝑤]的二维矩阵(Matrix)来表示一张图片信息(也可以保存为[ℎ, 𝑤, 1]形状的张量)。图 3.3 演示了内容为8 的数字图片的矩阵内容,可以看到,图片中黑色的像素用0 表示,灰度信息用0~255 表示,图片中灰度越白的像素点,对应矩阵位置中数值也就越大。

    在这里插入图片描述

    网络结构介绍

     本文中使用的简单的三层神经网络:
    o u t = r e l u {   r e l u {   [ X @ W 1 + b 1 ] @ W 2 + b 2 }   @ W 3 + b 3 }   out=relu \{\ relu\{\ [X@W_1+b_1]@W_2+b_2\}\ @W_3+b_3 \}\ out=relu{ relu{ [X@W1+b1]@W2+b2} @W3+b3} 
     out 可以套上激活函数也可以不用套
     我们采用的数据集是MNIST 手写数字图片集,输入节点数为784,第一层的输出节点数是256,第二层的输出节点数是128,第三层的输出节点是10,也就是当前样本属于10 类别的概率。

    代码部分

    导入相应的包

    from matplotlib import pyplot as mp
    import tensorflow as tf
    from tensorflow.keras import datasets, layers, optimizers
    

    预处理函数

     从 keras.datasets 中加载的数据集的格式大部分情况都不能满足模型的输入要求,因此需要根据用户的逻辑自己实现预处理函数。Dataset 对象通过提供map(func)工具函数可以非常方便地调用用户自定义的预处理逻辑,它实现在func 函数里:

    # 预处理函数实现在preprocess 函数中,传入函数引用即可
    train_db = train_db.map(preprocess)
    

     考虑 MNIST 手写数字图片,从keras.datasets 中经.batch()后加载的图片x shape 为[𝑏, 28,28],像素使用0~255 的整形表示;标注shape 为[𝑏],即采样的数字编码方式。实际的神经网络输入,一般需要将图片数据标准化到[0,1]或[−1,1]等0 附近区间,同时根据网络的设置,需要将shape [28,28] 的输入Reshape 为合法的格式;对于标注信息,可以选择在预处理时进行one-hot 编码,也可以在计算误差时进行one-hot 编码。

     同时,我们将MNIST 图片数据映射到𝑥 ∈ [0,1]区间,视图调整为
    [𝑏, 28 ∗ 28];对于标注y,我们选择在预处理函数里面进行one-hot 编码:

    def preprocess(x, y): # 自定义的预处理函数
    	# 调用此函数时会自动传入x,y 对象,shape 为[b, 28, 28], [b]
    	# 标准化到0~1
    	x = tf.cast(x, dtype=tf.float32) / 255.
    	x = tf.reshape(x, [-1, 28*28]) # 打平
    	y = tf.cast(y, dtype=tf.int32) # 转成整形张量
    	y = tf.one_hot(y, depth=10) # one-hot 编码
    	# 返回的x,y 将替换传入的x,y 参数,从而实现数据的预处理功能
    	return x,y
    

    加载手写数据集并进行数据处理

    batchsz = 512
    train_db = tf.data.Dataset.from_tensor_slices((x, y))  # 转化为Dataset对象
    train_db = train_db.shuffle(1000)  # 随机打散
    train_db = train_db.batch(batchsz)  # 批训练
    train_db = train_db.map(preprocess)  # 数据预处理
    train_db = train_db.repeat(20)  # 复制20份数据
    test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test))
    test_db = test_db.shuffle(1000).batch(batchsz).map(preprocess)
    x, y = next(iter(train_db))
    print('train sample:', x.shape, y.shape)
    

     关于随机打散,批训练之类的内容在我的另一篇博客中有讲解:https://blog.csdn.net/python_LC_nohtyp/article/details/104106498

    main() 函数部分

     在本次的网络中我们定义学习率lr=1e-2,并使用accs和losses两个列表来存储准确度和误差,方便之后绘图使用

    设置网络层结构

    网络的输入结点有784个,输出结点有10个

    # 784 => 512
        w1, b1 = tf.Variable(tf.random.normal([784, 256], stddev=0.1)), tf.Variable(tf.zeros([256]))
        # 512 => 256
        w2, b2 = tf.Variable(tf.random.normal([256, 128], stddev=0.1)), tf.Variable(tf.zeros([128]))
        # 256 => 10
        w3, b3 = tf.Variable(tf.random.normal([128, 10], stddev=0.1)), tf.Variable(tf.zeros([10]))
    

    循环更新

     现在我们进行循环更新,使用for循环去变量上述得到的train_db,并对w1,w2,w3,b1,b2,b3进行更新。

    for step, (x, y) in enumerate(train_db):
    	...
    

     下面说的都是for循环内的内容:

    先我们将图片信息张量打平

    x = tf.reshape(x, (-1, 784))
    

    之后进行网络的搭建和误差的计算

    with tf.GradientTape() as tape:
        # layer1.
        h1 = x @ w1 + b1
        h1 = tf.nn.relu(h1)
        # layer2
        h2 = h1 @ w2 + b2
        h2 = tf.nn.relu(h2)
        # output
        out = h2 @ w3 + b3
        # compute loss
        # [b, 10] - [b, 10]
        loss = tf.square(y - out)
        # [b, 10] => scalar
        loss = tf.reduce_mean(loss)
    

    通过自动求导函数计算梯度(求偏导)并进行参数的更新

    参数更新通过公式:
    θ ′ = θ − η ∗ σ L σ θ \theta '= \theta - \eta *\frac{\sigma L}{\sigma \theta} θ=θησθσL
    进行更新

    # 计算梯度
    grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
    # 参数更新
    for p, g in zip([w1, b1, w2, b2, w3, b3], grads):
        p.assign_sub(lr * g)
    

     每当step可以被100整除的时候打印一下错误率,并将其添加到列表当中,同时还进行准确度的计算

    # print
    if step % 100 == 0:
        print(step, 'loss:', float(loss))
        losses.append(float(loss))
    if step % 100 == 0:
        ...
    

    接下来说一下第二个if里应该写什么

    首先我们先定义两个变量用于计算准确度

    total, total_correct = 0., 0
    

    之后我们去迭代测试集获得准确度

     我们将测试集中的图片数据带入到目前的网络中进行对比,我们知道网络输出的是一个[b,10]结构的张量,b代表在每个数据集下的准确度,那么我们就选取最大的作为预测值
    我们根据tf.argmax函数选出概率最大值出现的索引号,也即样本最有可能的类别号:
     pred = tf.argmax(out, axis=1)
    由于我们的标注y 已经在预处理中完成了one-hot 编码,这在测试时其实是不需要的,因此通过tf.argmax 可以得到数字编码的标注y:
     y = tf.argmax(y, axis=1)
    通过tf.equal 可以比较这2 者的结果是否相等:
     correct = tf.equal(pred, y)
    并求和比较结果中所有True(转换为1)的数量,即为预测正确的数量:
    total_correct += tf.reduce_sum(tf.cast(correct,dtype=tf.int32)).numpy()
    通过预测的数量除以总测试数量即可得到准确度:
    print(step, ‘Evaluate Acc:’, total_correct/total)

    if step % 100 == 0:
        # evaluate/test
        total, total_correct = 0., 0
        # 计算准确度
        for x, y in test_db:
            # layer1.
            h1 = x @ w1 + b1
            h1 = tf.nn.relu(h1)
            # layer2
            h2 = h1 @ w2 + b2
            h2 = tf.nn.relu(h2)
            # output
            out = h2 @ w3 + b3
            # [b, 10] => [b]
            pred = tf.argmax(out, axis=1)
            # convert one_hot y to number y
            y = tf.argmax(y, axis=1)
            # bool type
            correct = tf.equal(pred, y)
            # bool tensor => int tensor => numpy
            total_correct += tf.reduce_sum(tf.cast(correct, dtype=tf.int32)).numpy()
            total += x.shape[0]
        print(step, 'Evaluate Acc:', total_correct / total)
        accs.append(total_correct / total)
    

     到这里循环更新的内容就写完了,
     通过简单的3 层神经网络,训练20 个Epoch 后,我们在测试集上获得了87.25%的准确率,如果使用复杂的神经网络模型,增加数据增强,精调网络超参数等技巧,可以获得更高的模型性能

    生成svg图片文件

    mp.figure()
    x = [i * 80 for i in range(len(losses))]
    mp.plot(x, losses, color='C0', marker='s', label='train')
    mp.ylabel('MSE')
    mp.xlabel('Step')
    mp.legend()
    mp.savefig('train.svg')
    mp.figure()
    mp.plot(x, accs, color='C1', marker='s', label='test')
    mp.ylabel('Acc')
    mp.xlabel('Step')
    mp.legend()
    mp.savefig('test.svg')
    

    完整代码

    from matplotlib import pyplot as mp
    import tensorflow as tf
    from tensorflow.keras import datasets, layers, optimizers
    
    
    def preprocess(x, y):
        """
        预处理函数
        """
        # [b, 28, 28], [b]
        print(x.shape, y.shape)
        x = tf.cast(x, dtype=tf.float32) / 255.
        x = tf.reshape(x, [-1, 28 * 28])  # 将图片打平
        y = tf.cast(y, dtype=tf.int32)
        y = tf.one_hot(y, depth=10)
        return x, y
    
    
    (x, y), (x_test, y_test) = datasets.mnist.load_data()  # 加载手写数据集数据
    print('x:', x.shape, 'y:', y.shape, 'x test:', x_test.shape, 'y test:', y_test)
    
    batchsz = 512
    train_db = tf.data.Dataset.from_tensor_slices((x, y))  # 转化为Dataset对象
    train_db = train_db.shuffle(1000)  # 随机打散
    train_db = train_db.batch(batchsz)  # 批训练
    train_db = train_db.map(preprocess)  # 数据预处理
    train_db = train_db.repeat(20)  # 复制20份数据
    test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test))
    test_db = test_db.shuffle(1000).batch(batchsz).map(preprocess)
    x, y = next(iter(train_db))
    print('train sample:', x.shape, y.shape)
    
    
    def main():
        # learning rate
        lr = 1e-2
        accs, losses = [], []
        # 784 => 512
        w1, b1 = tf.Variable(tf.random.normal([784, 256], stddev=0.1)), tf.Variable(tf.zeros([256]))
        # 512 => 256
        w2, b2 = tf.Variable(tf.random.normal([256, 128], stddev=0.1)), tf.Variable(tf.zeros([128]))
        # 256 => 10
        w3, b3 = tf.Variable(tf.random.normal([128, 10], stddev=0.1)), tf.Variable(tf.zeros([10]))
        for step, (x, y) in enumerate(train_db):
            # [b, 28, 28] => [b, 784]
            x = tf.reshape(x, (-1, 784))
            with tf.GradientTape() as tape:
                # layer1.
                h1 = x @ w1 + b1
                h1 = tf.nn.relu(h1)
                # layer2
                h2 = h1 @ w2 + b2
                h2 = tf.nn.relu(h2)
                # output
                out = h2 @ w3 + b3
                # compute loss
                # [b, 10] - [b, 10]
                loss = tf.square(y - out)
                # [b, 10] => scalar
                loss = tf.reduce_mean(loss)
            # 计算梯度
            grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
            # 参数更新
            for p, g in zip([w1, b1, w2, b2, w3, b3], grads):
                p.assign_sub(lr * g)
    
            # print
            if step % 100 == 0:
                print(step, 'loss:', float(loss))
                losses.append(float(loss))
    
            if step % 100 == 0:
                # evaluate/test
                total, total_correct = 0., 0
                # 计算准确度
                for x, y in test_db:
                    # layer1.
                    h1 = x @ w1 + b1
                    h1 = tf.nn.relu(h1)
                    # layer2
                    h2 = h1 @ w2 + b2
                    h2 = tf.nn.relu(h2)
                    # output
                    out = h2 @ w3 + b3
                    # [b, 10] => [b]
                    pred = tf.argmax(out, axis=1)
                    # convert one_hot y to number y
                    y = tf.argmax(y, axis=1)
                    # bool type
                    correct = tf.equal(pred, y)
                    # bool tensor => int tensor => numpy
                    total_correct += tf.reduce_sum(tf.cast(correct, dtype=tf.int32)).numpy()
                    total += x.shape[0]
                print(step, 'Evaluate Acc:', total_correct / total)
                accs.append(total_correct / total)
    
        mp.figure()
        x = [i * 80 for i in range(len(losses))]
        mp.plot(x, losses, color='C0', marker='s', label='train')
        mp.ylabel('MSE')
        mp.xlabel('Step')
        mp.legend()
        mp.savefig('train.svg')
    
        mp.figure()
        mp.plot(x, accs, color='C1', marker='s', label='test')
        mp.ylabel('Acc')
        mp.xlabel('Step')
        mp.legend()
        mp.savefig('test.svg')
    
    
    if __name__ == '__main__':
        main()
    
    
    展开全文
  • 主要介绍了详解PyTorch手写数字识别(MNIST数据集),文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • MINIST手写数字识别

    2019-09-28 17:42:49
    多层神经网络实现MINIST手写数字识别: import input_data #input_data为下载的脚本文件,网址见最后 import tensorflow as tf mnist = input_data.read_data_sets( ' F:/PycharmProjects/untitled2/...

    1、配置环境:tensorflow+matplotlib

    添加matplotlib库:https://blog.csdn.net/jiaoyangwm/article/details/79252845

    2、下载数据:

    http://yann.lecun.com/exdb/mnist/

    3、主要步骤:

      1)载入数据,解析文件

      2)构建CNN网络    

        (1)传统LeNet5包含输入层、卷积层CONV5-32、池化层pool2、卷积层CONV5-64、池化层pool2、全连接层fc1、输出层fc。

          改进的LeNet5神经网络激活函数采用ReLU激活函数,添加dropout层防止过拟合,输出层为softmax分类层,

    INPUT: [28x28x1]          weights: 0
    CONV5-32: [28x28x32]      weights: (5*5*1+1)*32
    POOL2: [14x14x32]         weights: 2*2*1
    CONV5-64: [14x14x64]      weights: (5*5*32+1)*64
    POOL2: [7x7x64]           weights: 2*2*1
    FC: [1x1x1024]            weights: (7*7*64+1)*1024
    FC: [1x1x10]              weights: (1*1*512+1)*10

        (2)

        (3)

      3)构建loss function

        softmax损失函数

      4)配置寻优器

        梯度下降法、Adam优化器、动量优化器、Adagrad优化器、FTRL优化器、RMSProp优化器、

      5)训练、测试

      6)tensorboard可视化

    4、详细解释

    http://wiki.jikexueyuan.com/project/tensorflow-zh/tutorials/mnist_beginners.html

    5、具体实现

    多层神经网络实现MINIST手写数字识别:

    import input_data   #input_data为下载的脚本文件,网址见最后
    import tensorflow as tf
    
    mnist = input_data.read_data_sets('F:/PycharmProjects/untitled2/tensorflow/MINIST_data', one_hot=True) #下载的MNIST数据集存储路径
    
    x = tf.placeholder(tf.float32, [None, 784])
    y_ = tf.placeholder(tf.float32, [None, 10])
    
    def weight_variable(shape):
        initial = tf.truncated_normal(shape,stddev = 0.1)
        return tf.Variable(initial)
    
    def bias_variable(shape):
        initial = tf.constant(0.1,shape = shape)
        return tf.Variable(initial)
    
    def conv2d(x,W):
        return tf.nn.conv2d(x, W, strides = [1,1,1,1], padding = 'SAME')
    
    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1], padding='SAME')
    
    W_conv1 = weight_variable([5, 5, 1, 32])
    b_conv1 = bias_variable([32])
    
    x_image = tf.reshape(x,[-1,28,28,1])
    
    h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)
    h_pool1 = max_pool_2x2(h_conv1)
    
    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])
    
    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)
    
    W_fc1 = weight_variable([7 * 7 * 64, 1024])
    b_fc1 = bias_variable([1024])
    
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
    
    keep_prob = tf.placeholder("float")
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])
    
    y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
    
    cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
    
    saver = tf.train.Saver() #定义saver
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for i in range(2000):
            batch = mnist.train.next_batch(50)
            if i % 100 == 0:
                train_accuracy = accuracy.eval(feed_dict={
                    x: batch[0], y_: batch[1], keep_prob: 1.0})
                print('step %d, training accuracy %g' % (i, train_accuracy))
            train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
        saver.save(sess, 'F:/PycharmProjects/untitled2/tensorflow/MINIST_data/model.ckpt') #模型储存位置
    
        print('test accuracy %g' % accuracy.eval(feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

     

      运行结果:

        

        

      CNN模型文件:

        

     

     

     

     

     

     

     讲一下入过的坑: 

    第一个坑: 

      报错:ImportError: No module named examples.tutorials.mnist.input_data

      这就需要从TensorFlow的官网上下载input_data.py,这个国内可拷贝的链接是:http://blog.csdn.net/fdbptha/article/details/51265430。
    第二个坑:(安装tf2.0的后果,变化太大不会使,只能重新安装低版的tf)

      报错:AttributeError: module 'tensorflow' has no attribute 'placeholder'

      替换 import tensorflow as tf

      为:import tensorflow.compat.v1 as tf

      报错:RuntimeError: tf.placeholder() is not compatible with eager execution.

    重装tf1.15版本后可以正常运行了,感动到泪奔T_T

     

     

      

    转载于:https://www.cnblogs.com/chengmm/p/11565058.html

    展开全文
  • 文章目录1数据集介绍reshape2标签数据和独热编码one-hot取值3为什么要用独热编码?4数据集的划分3数据批量读取 1数据集介绍 可视化 ...import matplotlib.pyplot as plt ... plt.imshow(image.reshape(28,28),cmap='...

    1数据集介绍

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    可视化
    在这里插入图片描述

    import matplotlib.pyplot as plt
    def plot_image(image):
        plt.imshow(image.reshape(28,28),cmap='binary')
        plt.show()
    
    plot_image(mnist.train.images[320])
    

    在这里插入图片描述

    reshape

    在这里插入图片描述
    在这里插入图片描述
    1357行抽取出来在左边,246行右边形成了上图

    2标签数据和独热编码

    在这里插入图片描述
    在这里插入图片描述
    独热编码
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    采用one-hot可以有效避免3-1比8-3近

    one-hot取值

    在这里插入图片描述
    在这里插入图片描述
    one_hot的效果
    在这里插入图片描述

    3为什么要用独热编码?

    在这里插入图片描述

    4数据集的划分

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    新的工作模型
    在这里插入图片描述

    3数据批量读取

    next_batch会带shuffle
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在此执行会在上一次执行基础上再抽10个直到数据集轮一遍

    展开全文
  • Keras手写数字识别Demo

    2017-05-28 23:30:50
    利用Keras 进行手写数字识别的例子,采用了CNN,准确率在99%左右,需要安装Keras的相关库。结构比较清晰,不做过多说明,含model调用示例
  • 本资源是属于博客“基于Keras mnist手写数字识别---Keras卷积神经网络入门教程”的项目文件,主要是讲了如何使用keras实现手写数字识别
  • MINIST手写数字识别——04.多层感知器(MLP) 加载 MNIST 数据集 import tensorflow as tf (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data() print(x_train.shape, type(x_train)) ...
  • 转自:...项目内容:minist手写数据集识别 # -*- coding: utf-8 -*- import tensorflow as tf #导入input_data用于自动下载和安装MNIST数据集 from tensorflow.examples.tutorials.mn...
  • 手写数字识别是每个学习神经网络的人上手操作的必由之路,今天在前人肩膀上做了些小小的尝试。 话不多说,开始~ 1.导入相关模块数据包(需提前配置tenseorflow模块) 在tenseorflow模块中内置了MNIST数据集,其中...
  • keras实现的mnist手写数字识别,模型已经训练好,也可以重新进行训练,带了自己手写的28x28的测试图片,有需要的可以下载
  • KNN算法使用MNIST数据集、0-1二值图集、自写的数字图片集,做手写数字识别的代码,文件夹分类明确。
  • MATLAB源码实现手写数字识别,模式识别经典分类算法,识别率有待提高,思路清晰,适合新手入门学习使用
  • MNIST数据集是机器学习领域中非常经典的一个数据集,由60000个训练样本和10000个测试样本组成,每个样本都是一张28 * 28像素的灰度手写数字图片。 这些文件不是任何标准的图像格式而是以字节的形式进行存储的 使用...
  • 代码: import pandas as pd import tensorflow as tf ...train=pd.read_csv('../Desktop/DataSets/MINIST/train.csv') test=pd.read_csv('../Desktop/DataSets/MINIST/test.csv') X_train=tra...
  • mnist手写数字识别matlab
  • 最后还是到了官方网站去,还好有官方文档中文版,今天就结合官方文档以及之前看的教程写一篇关于MINIST手写数字识别,小白一枚,不足之处还请大家多多见谅。 tensorflow的安装 这个确实是个问题,很多人用tensorflow...
  • 多分类问题可以转换为多个二分类问题,例如,需要完成对手写数字的十分类时,可以采用依次对每个数字(0-9)进行二分类的方式,最终对每次分类中计算出的正样本概率值进行排序,选择概率最高的数字作为分类的结果。...
  • 需要下载MNIST数据集,将路径修改为本地MNIST数据集的地址。需要OpenCV与Tensorflow环境
  • 思路:通过构建一个三层的CNN网络,实现数字识别。(图像处理问题) #导入各种用到的模块组件 from __future__ import absolute_import from __future__ import print_function from keras.preprocessing.image ...
  • import numpy from tensorflow.keras.datasets import mnist from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense from tensorflow.keras.layers import Dropout ...
  • 目录数据集的读取神经网络的推理批处理 数据集的读取 以“(训练图像,训练标签),(测试图像,测试标签)”的形式读入的MNIST数据 import sys, os sys.path.append(os.pardir) # 为了导入父目录中的文件而进行的设定 ...
  • CNN卷积神经网络实现手写数字识别,Matlab+minist数据集都有,在matlab上可直接运行,新手友好,亲测可用。
  • 思路: 网络是三层: h1=relu(w1*x+b1)-输入28*28,输出256 h2=relu(w2*h1+b2)-输入256,输出64 h3=w3*h2+b3-输入64,输出10 其中256,64是自己构想的,10是固定的结果10分类 每次是512个28*28的1通道图片进入一起...
  • labels-idx1-ubyte.gz',60000) test_data,test_labels = data_read('./minist_data/t10k-images-idx3-ubyte.gz','./minist_data/t10k-labels-idx1-ubyte.gz',10000) print('训练集参数:',train_data.shape,train_...
  • 内容索引:VC/C++源码,图形处理,模板匹配法,手写数字识别 书中的一个经典实例,在此摘录出来,让C++此方面编程的朋友可以更容易的找得到,压缩包内有3种识别技术的算法实例,需要慢慢研究哦。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,711
精华内容 684
关键字:

minist手写数字识别