精华内容
下载资源
问答
  • TensorFlow2.0 卷积神经网络 手写数字识别简单实战

    千次阅读 热门讨论 2020-03-06 18:10:59
    本文是作者在学习tensorflow2.0框架中,学习的一个卷积神经网络实现手写数字识别的例子,并进行了简单的分析。结果表明,卷积神经网络能够很好地完成手写数字识别的任务,测试准确率达到了99.07%。由于程序简单,...


    相比于全连接神经网络,卷积神经网络在分类任务上具有更好的表现,识别准确率更高,在大型数据集上面表现更为突出,本文以MNIST数据集为例,构建包含两层卷积层的卷积神经网络,以下是具体代码:

    1. 配置库文件

    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers, optimizers, datasets
    

    2. 导入数据库

    # 下面一行是在线加载方式
    # mnist = tf.keras.datasets.mnist
    # 下面两行是加载本地的数据集
    datapath  = r'E:\Pycharm\project\project_TF\.idea\data\mnist.npz'
    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data(datapath)
    

    3. 数据预处理

    由于导入的为60000* 28* 28 的数据,全连接网络应reshape为60000* 784(也即打平的作用Flatten()), 卷积网络则为60000* 28 * 28*1(黑白单通道),因此需要进行数据预处理。

    # 数据预处理
    x_train = x_train.reshape(x_train.shape[0],28,28,1).astype('float32')
    x_test = x_test.reshape(x_test.shape[0],28,28,1).astype('float32')
    # 归一化
    x_train = tf.keras.utils.normalize(x_train, axis=1)
    x_test = tf.keras.utils.normalize(x_test, axis=1)   #归一化
    

    4.建立卷积神经网络结构模型

    建立两层卷积层和两层池化层的卷积神经网络。其中,第一层卷积核深度(个数)16,大小为5 * 5,same的填充是指输出图像大小与输入一致(这一点比PyTorch简便一点);第二层卷积核深度为36,以提取更高维度的信息,大小为5 * 5。一般来说,最大池化层比平均池化层在分类上表现更好。

    model = keras.models.Sequential([
        layers.Conv2D(filters=16, kernel_size=(5,5), padding='same',
                     input_shape=(28,28,1),  activation='relu'),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Conv2D(filters=36, kernel_size=(5,5), padding='same',
        			 activation='relu'),
        layers.MaxPooling2D(pool_size=(2, 2)),
        layers.Dropout(0.25),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(10,activation='softmax')
    ])
    #打印模型
    print(model.summary())
    

    网络结构模型打印出来如下:

    5.模型编译及训练

    损失函数使用交叉熵损失函数,优化器使用adam;训练10个epoch和128的batch_size。

    #训练配置
    model.compile(loss='sparse_categorical_crossentropy',
                  optimizer='adam', metrics=['accuracy'])
    #开始训练
    model.fit(x=x_train, y=y_train, validation_split=0.2,	##validation_split是指将一部分作为验证集使用,0.2代表80%的数据作为训练集,20%作为验证集
                            epochs=10, batch_size=128, verbose=1)   #verbose=1代表显示训练过程
    

    6. 测试集验证

    val_loss, val_acc = model.evaluate(x_test, y_test) # model.evaluate输出计算的损失和精确度
    print('Test Loss:{:.6f}'.format(val_loss))
    print('Test Acc:{:.6f}'.format(val_acc))
    

    整个程序到此结束了。

    7. 测试结果

    在cpu环境下,每个epoch运行完成需要70s左右。最终训练的平均准确率为:98.62%,平均Loss为:0.0439。而在测试集中,识别的准确率达到99.07%,Loss为0.0277。与上一篇的全连接神经网络的97.87%相比,准确率有所上升。

    展开全文
  • 最近学习cnn,老师要求完成一份图片识别的案例,参照了很多网上博客的做法,加上自己的研究 在 Google Colaboratory 写的 推荐一位博主的博客,对卷积,池化,以及多卷积核,多通道等 讲的十分透彻: 大佬文章...

    最近学习cnn,老师要求完成一份图片识别的案例,参照了很多网上博客的做法,加上自己的研究

    在 Google Colaboratory 写的

    推荐一位博主的博客,对卷积,池化,以及多卷积核 ,多通道等 讲的十分透彻:

    大佬文章地址

    try:
      # Colab only
      %tensorflow_version 2.x
    except Exception:
        pass

     

    import numpy as np
    import tensorflow as tf
    import keras
    from keras.datasets import mnist # 这里是从keras的datasets中导入mnist数据集
    from keras.utils import np_utils 
    from keras.models import Sequential 
    from keras.layers import Dense 
    from keras.layers import Activation
    from keras.layers import MaxPooling2D
    from keras.layers import Flatten
    from keras.layers import Dropout 
    from keras.layers import Conv2D
    import matplotlib.pyplot as plt
    from keras.optimizers import Adam
    (X_train,y_train),(X_test,y_test) = mnist.load_data()
    #  导入数据集
    
    #  展示效果
    fig = plt.figure()
    for i in range(9):
      plt.subplot(3,3,i+1)
      plt.tight_layout()
      plt.imshow(X_train[i], cmap='gray', interpolation='none')
      plt.title("Digit: {}".format(y_train[i]))
      plt.xticks([])
      plt.yticks([])
    
    X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
    X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
    y_train = np_utils.to_categorical(y_train, num_classes=10) 
    y_test = np_utils.to_categorical(y_test,num_classes=10)
    
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')
    X_train /= 255
    X_test /= 255
    model = Sequential()
    #convolutional layer with rectified linear unit activation
    model.add(Conv2D(32, kernel_size=(3, 3),
                     activation='relu',
                    #  border_mode='same',
                     input_shape=(28,28,1)))
    
    model.add(Conv2D(64, (3, 3), activation='relu', strides=2)) # border_mode='same', 
    
    #choose the best features via pooling
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    #randomly turn neurons on and off to improve convergence
    model.add(Dropout(0.25))
    
    #flatten since too many dimensions, we only want a classification output
    model.add(Flatten())
    
    #fully connected to get all relevant data
    model.add(Dense(128, activation='relu'))
    
    #one more dropout for convergence' sake :) 
    model.add(Dropout(0.25)) 
    
    #output a softmax to squash the matrix into output probabilities
    model.add(Dense(10, activation='softmax'))
    model.summary()
    
    model.compile(loss=keras.losses.categorical_crossentropy,
                  optimizer=keras.optimizers.Adadelta(),
                  metrics=['accuracy'])
    
    batch_size = 128
    print("\n---------------------------------------Training---------------------------------------")
    model_log = model.fit(X_train, y_train,
              batch_size=batch_size,
              epochs=1,
              verbose=1)
    
    print("\n---------------------------------------Training-Result---------------------------------------")
    trainLoss,trainAccuracy = model.evaluate(X_train,y_train)
    print('\ntrain loss:', trainLoss)
    print('\ntrain accuracy:', trainAccuracy)
    
    print("\n---------------------------------------Testing-Result---------------------------------------")
    loss,accuracy = model.evaluate(X_test,y_test)
    print('\ntrain loss:', loss)
    print('\ntrain accuracy:', accuracy)

    大致讲一下上述的模型吧,上述模型使用了官方提供的手写数字的数据库,60000张训练图片,10000张测试图片,然后将训练和测试的图片(X)改成(数量,28,28,1)其中数量是此训练数组的size,28*28是图片的长宽比,1是通道的个数。y值采用工具包向量化,比如一张图片的值是1,则向量化之后的值为(0 0 0 0 0 0 0 0 1 0)。

    模型的重头戏,构建模型的层次:(不了解下述内容的可以去看页首的博客,讲的挺好的)

    1.建立第一层卷积层

    这里卷积核的个数为32个, 卷积核大小为 3*3, 激活函数为'relu',inpu_shape为你输入该层图片的格式,我们的图片格式28*28*1,border_mode这个参数简单来说是指图片经过该层后的大小,如为默认,图片经过该层的大小应该为26*26,计算公式为:(图片原长 - 卷积核长 + 2*需要填充的0的个数)/ strides+ 1;默认(28 - 3 - 2*0)/1+1 = 26,宽类推。这里的strides默认为1,具体用法参照首页博客。若将border_mode = 'same' 则输出结果的图片大小不改变。图片输出结果应为:(26,26,32),图片经过32个卷积核变为32层(卷积核内容是可修正的,基本各不相同)。也就是这层可修正的参数值为:32*9+32这个公式是我自己根据结果倒推的,可能有错误,我的理解是:32个卷积核*(3*3)卷积核面积+32个偏置。

    2.建立第二层卷积层

    这层将原先的(26,26,28)输入,得到(12,12,64),至于为什么 参照 第一步的计算公式

    这一层的可修正参数:64 * 32 * 9 + 64,理解32层的输入 * 64个卷积核 *(3*3)卷积核面积 + 64 个偏置

    3.建立池化层

    池化层很好理解,输入的图片规模/池化的规模,输入为(12,12,64) 输出 (6,6,64)

    4.Dropout

    防止过拟合,简单理解,25%的随机节点不参与计算

    5.

    这是将 图片变成一维向量,一维向量的长度应为:6*6*64

    6.

    增加全连接层,128个节点,可修改 修正参数值:(6*6*64)*128+128 (偏置)

    7

    输出层10个节点,分别对应手写数字0-9,激活函数softmax:结果归一化,也就是10个节点的值相加为1,

    可修正参数值为:(128+1)*10


    本人小白,初学cnn,肯定以上有不对或者不好的地方,希望有大佬看见能指导指导,不胜感激。

    展开全文
  • 卷积神经网络经典案例,手写数字识别代码详解,注释之处如有错误,欢迎指正 from tensorflow.examples.tutorials.mnist import input_data import tensorflow as tf #初始化权重函数 def weight_variable(shape):...

    卷积神经网络经典案例,手写数字识别代码详解,注释之处如有错误,欢迎指正

    from tensorflow.examples.tutorials.mnist import input_data
    import tensorflow as tf
    
    #初始化权重函数
    def weight_variable(shape):
        initial = tf.truncated_normal(shape,stddev=0.1);#生成维度是shape标准差是0.1的正态分布数
        return tf.Variable(initial)
    
    #初始化偏置项
    def bias_variable(shape):
        initial = tf.constant(0.1,shape=shape)#生成维度为shape的全为0.1的向量
        return tf.Variable(initial)
    
    #定义卷积函数
    def conv2d(x,w):
        return tf.nn.conv2d(x,w,strides=[1,1,1,1],padding='SAME')
        #strides: 卷积时在图像每一维的步长,这是一个一维的向量,
        #[ 1, strides, strides, 1],第一位和最后一位固定必须是1
        #padding参数是string类型,值为“SAME” 和 “VALID”,表示的是卷积的形式。
        #设置为"SAME"时,会在原图像边缘外增加几圈0来使卷积后的矩阵和原图像矩阵的维度相同
        #设置为"VALID"则不考虑这一点,卷积后的矩阵维度会相应减少,例如原图像如果是5*5,卷积核是3*3
        #那么卷积过后的输出矩阵回是3*3的
        
    #定义一个2*2的最大池化层
    def max_pool_2_2(x):
        return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
        #第一个参数value:需要池化的输入,一般池化层接在卷积层后面,
        #依然是[batch, height, width, channels]这样的shape
        #第二个参数ksize:池化窗口的大小,取一个四维向量,一般是[1, height, width, 1],
        #因为我们不想在batch和channels上做池化,所以这两个维度设为了1
        #第三个参数strides:和卷积类似,窗口在每一个维度上滑动的步长,
        #一般也是[1, stride,stride, 1]
        #第四个参数padding:和卷积类似,可以取'VALID' 或者'SAME'
     
    if __name__ == "__main__":
        #定义输入变量
        x = tf.placeholder("float",shape=[None,784])#占位    
        #浮点型变量,行数不定,列数为784(每个图像是一个长度为784(28*28)的向量)
        
        #定义输出变量
        y_ = tf.placeholder("float",shape=[None,10])#占位
        #浮点型变量,行数不定,列数为10,输出一个长度为10的向量来表示每个数字的可能性
        #初始化权重,第一层卷积,32的意思代表的是输出32个通道
        # 其实,也就是设置32个卷积,每一个卷积都会对图像进行卷积操作
        
        w_conv1 = weight_variable([5,5,1,32])###生成了32个5*5的矩阵
        #初始化偏置项
        b_conv1 = bias_variable([32])
        
        x_image = tf.reshape(x,[-1,28,28,1])
        #将输入的x转成一个4D向量,第2、3维对应图片的宽高,最后一维代表图片的颜色通道数
        # 输入的图像为灰度图,所以通道数为1,如果是RGB图,通道数为3
        # tf.reshape(x,[-1,28,28,1])的意思是将x自动转换成28*28*1的数组
        # -1的意思是代表不知道x的shape,它会按照后面的设置进行转换
        
        # 卷积并激活
        h_conv1 = tf.nn.relu(conv2d(x_image,w_conv1) + b_conv1)
        #池化
        h_pool1 = max_pool_2_2(h_conv1)
        #第二层卷积
        #初始权重
        w_conv2 = weight_variable([5,5,32,64])
        #在32个第一层卷积层上每个再用一个5*5的卷积核在做特征提取,并输出到第二层卷积层,
        #第二层设置了64个卷积层
        
        #初始化偏置项
        b_conv2 = bias_variable([64])
        #将第一层卷积池化后的结果作为第二层卷积的输入加权求和后激活
        h_conv2 = tf.nn.relu(conv2d(h_pool1,w_conv2) + b_conv2)
        #池化
        h_pool2 = max_pool_2_2(h_conv2)
        # 设置全连接层的权重
        w_fc1 = weight_variable([7*7*64,1024])
        #28*28的原图像经过两次池化后变为7*7,设置了1024个输出单元
        
        # 设置全连接层的偏置
        b_fc1 = bias_variable([1024])
        # 将第二层卷积池化后的结果,转成一个7*7*64的数组
        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)
     
        #日志输出,每迭代100次输出一次日志
        #定义交叉熵为损失函数
        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"))
        sess = tf.Session()
        sess.run(tf.initialize_all_variables())
        #上面的两行是在为tf的输出变量做准备
        # 下载minist的手写数字的数据集
        mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
        for i in range(20000):#迭代20000次
            batch = mnist.train.next_batch(50)#设置batch,即每次用来训练模型的数据个数
            if i % 100 == 0:#每100次迭代输出一次精度
                train_accuracy = accuracy.eval(session=sess,
                                               feed_dict={x:batch[0],y_:batch[1],keep_prob:1.0})
                #喂给之前占位的x和y_本次训练的batch个数据中第一个数据的图像矩阵和标签,不考虑过拟合
                #计算当前的精度
                
                print("step %d,training accuracy %g"%(i,train_accuracy))
            train_step.run(session = sess,feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})
            #当i不能被100整除时的训练过程,考虑过拟合,单元保留的概率为0.5
     
        print("test accuracy %g" % accuracy.eval(session=sess,feed_dict={
            x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))
        #输出测试集的精度

    结果如下:

    因为20000次计算花的时间太长,这里我就换成1000次就输出结果了

    展开全文
  • Python 3.7 数据集:MNIST 2 训练过程 数据准备 首先,导入实验所需的库,定义一些宏参数,BATCH_SIZE表示每个batch加载多少个样本、EPOCHS表示总共训练批次。如果支持cuda就用gpu来run,不支持就用cpu来run。 ...

    1.实验环境

    • Pytorch 1.4.0
    • conda 4.7.12
    • Jupyter Notebook 6.0.1
    • Python 3.7
    • 数据集:MNIST

    2 训练过程

    数据准备

    首先,导入实验所需的库,定义一些宏参数,BATCH_SIZE表示每个batch加载多少个样本、EPOCHS表示总共训练批次。如果支持cuda就用gpu来run,不支持就用cpu来run。

    import torch
    import torch.nn as nn
    import torch.nn.functional as F
    import torch.optim as optim
    from torchvision import datasets, transforms
    import matplotlib.pyplot as plt
    
    BATCH_SIZE = 200
    EPOCHS = 10 
    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") 
    

    Pytorch的torchvision的dataset里面有MNIST数据集,我们可以直接使用。 如果是第一次run需要下载data,如果已经下载过了就可以直接用了。

    接着构造数据提供器,归一化数据,shuffle=True设置在每个epoch重新打乱数据,保证数据的随机性。
    因为Pytorch已经实现了dataset,所以这里可以直接使用DataLoader来对数据进行读取。
    处理好了训练集和测试集。

    # 训练集
    train_set = datasets.MNIST('data', train = True, download = True,
                               transform = transforms.Compose([
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.1037,), (0.3081,))
                               ]))
    train_loader = torch.utils.data.DataLoader(train_set,
                               batch_size = BATCH_SIZE, shuffle = True)
    
    # 测试集
    test_set = datasets.MNIST('data', train = False, 
                              transform = transforms.Compose([
                                  transforms.ToTensor(),
                                  transforms.Normalize((0.1037,), (0.3081,))
                              ]))
    test_loader = torch.utils.data.DataLoader(test_set,
                              batch_size = BATCH_SIZE, shuffle = True)
    

    网络配置

    定义一个卷积神经网络,网络为1个卷积层接1个最大池化层,再接一个卷积层,然后紧接着两个全连接层,最后是输出层,最后输出10个维度,这10个维度我们作为0-9的标识来确定识别出的是那个数字。其中卷积层采用ReLU函数作为激活函数,输出层使用log_softmax函数.

    # 定义模型
    class MyConvNet(nn.Module):
        def __init__(self):
            super().__init__()
            #1*1*28*28
            self.conv1 = nn.Conv2d(1, 10, 5) 
            self.conv2 = nn.Conv2d(10, 20, 3) 
            self.fc1 = nn.Linear(20 * 10 * 10, 500)
            self.fc2 = nn.Linear(500, 10)
            
        def forward(self, x):
            in_size = x.size(0)
            out= self.conv1(x) 
            out = F.relu(out)
            out = F.max_pool2d(out, 2, 2) 
            out = self.conv2(out) 
            out = F.relu(out)
            out = out.view(in_size, -1) 
            out = self.fc1(out) 
            out = F.relu(out)
            out = self.fc2(out) 
            out = F.log_softmax(out, dim = 1)
            return out
    

    初始化模型,优化器采用Adam。

    # 定义模型
    model = MyConvNet().to(DEVICE)
    optimizer = optim.Adam(model.parameters())
    

    模型训练

    定义训练函数,print进度和过程中的loss,print每一epoch的accuracy。

    def train(model, device, train_loader, optimizer, epoch):
        model.train()
        train_loss = []
        train_acc = 0
        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)
            optimizer.zero_grad()
            output = model(data)
            loss = F.nll_loss(output, target)
            loss.backward()
            optimizer.step()
            pred = output.max(1, keepdim = True)[1] 
            train_acc += pred.eq(target.view_as(pred)).sum().item()
            
            if (batch_idx + 1) % 30 == 0:
                print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                    epoch, batch_idx * len(data), len(train_loader.dataset),
                    100. * batch_idx / len(train_loader), loss.item()))
                train_loss.append(loss.data.item())
            
        train_acc=train_acc/len(train_loader.dataset)    
        print('\nTrain Epoch: {}\tAccuracy:{:.4f}% '.format(epoch,100.*train_acc))
        return train_loss,100.*train_acc
    

    定义测试函数,print每一epoch的loss和accuracy。

    def test(model, device, test_loader):
        model.eval()
        test_loss =0
        correct = 0
        with torch.no_grad():
            for data, target in test_loader:
                data, target = data.to(device), target.to(device)
                output = model(data)
                test_loss += F.nll_loss(output, target, reduction = 'sum') 
                pred = output.max(1, keepdim = True)[1] 
                correct += pred.eq(target.view_as(pred)).sum().item()
        
        test_loss /= len(test_loader.dataset)
        test_acc= correct / len(test_loader.dataset)
        print("\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.4f}%) \n"
              .format(test_loss, correct, 
              len(test_loader.dataset),100.* test_acc))
        return test_loss.item(),100.*test_acc
    

    预定义4个数组,分别存储训练集的loss和accuracy、测试集的loss和accuracy,然后开始训练和测试。

    train_losses = []
    train_acces = []
    test_losses = []
    test_acces = []
    
    for epoch in range(1, EPOCHS + 1):
        tr_loss,tr_acc=train(model,  DEVICE, train_loader, optimizer, epoch)
        te_loss,te_acc=test(model, DEVICE, test_loader)
        for item in tr_loss:
            train_losses.append(item)
        train_acces.append(tr_acc)
        test_losses.append(te_loss)
        test_acces.append(te_acc)
    

    模型评估

    图形化训练过程中和测试过程中的loss和accuracy。

    def draw_plot(data,label,x,y):
        plt.plot(data,label=label)
        plt.xlabel(x, fontsize=14)
        plt.ylabel(y, fontsize=14)
        plt.legend()
    
    draw_plot(train_losses,"train_loss","iteration","loss")
    
    draw_plot(test_losses,"test_loss","iteration","loss")
    
    draw_plot(train_acces,"train_accuracy","iteration","acc")
    
    draw_plot(test_acces,"test_accuracy","iteration","acc")
    

    卷积神经网络最后accuracy为98.94%

    展开全文
  • python不使用框架实现卷积神经网络识别手写数字, 在100个的测试集上准确率最高可达95%。内含数据集
  • 利用卷积神经网络实现手写数字识别

    万次阅读 多人点赞 2019-05-29 12:26:44
    我们在之前的博客,已经学习了用KNN和dense SIFT算法实现图像分类,今天我们学习另一种新的方法来实现图像分类,用卷积神经网络实现手写数字集的分类。 一、卷积神经网络(CNN) 1.卷积神经网络概述 2.卷积​ 二...
  • # 设置卷积神经网络 class CNN(nn.Module): def __init__(self): super(CNN, self).__init__() # 定义第一层的输入和输出 self.conv1 = nn.Sequential( # input shape (1, 28, 28) nn.Conv2d( in_channels=1, ...
  • 基于卷积神经网络手写数字识别python代码实现 卷积神经网络(Convolutional Neural Network,CNN)中,卷积层的神经元只与前一层的部分神经元节点相连,即它的神经元间的连接是非全连接的,且同一层中某些神经元...
  • CNN卷积神经网络手写数字识别实例及代码详解

    万次阅读 多人点赞 2016-12-30 22:57:34
    我在应该该代码进行训练时,出现一些报错,如expand函数应用不对,flipall函数未定义等问题,对这些问题进行了修正,完成网络训练和验证。 本文mnist_uint8.mat的获取可以参照我的另一篇博客:MNIST数据库处理--...
  • # -*- coding: utf-8 -*- """ ...#利用卷积神经网络进行手写数字识别 from keras.models import Sequential from keras.layers import Dense,Dropout,Flatten from keras.la...
  • 这种用于识别手写数字的基于CNN的模型在训练12个时期之后获得99.2%的验证准确度。 它在Kaggle的MNIST数据集上训练
  • 基于卷积神经网络手写数字识别,工具使用Google的人工智能TensorFlow库,识别准确率高,代码使用python3.0以上版本
  • CNN卷积神经网络的理论教程参考 http://blog.csdn.net/luanpeng825485697/article/details/79009241 加载样本数据集 首先我们要有手写体的数据集文件 t10k-images.idx3-ubyte t10k-labels.idx1-ubyte train-...
  • 本文使用Python基于TensorFlow 卷积神经网络设计手写数字识别算法,并编程实现GUI 界面,构建手写数字识别系统。本系统界面设计友好,功能完善。通过测试,本识别系统对于较规范的手写数字识别达到了很好的识别...
  • # 第一层卷积神经网络SAME保持图片大小不变,卷积核32个 #relu防止梯度消失,神经元单边休整 cnn1 = tf.nn.conv2d(xs,w_cnn1,strides = [1,1,1,1],padding="SAME")+b_cnn1 #第一层池化,图片大小变为14*14 pool...
  • 使用卷积神经网络手写数字识别 使用Keras和MNIST数据集完成 建筑学: Layer (type) Output Shape Param # ================================================================= conv2d_239 (Conv2D) (None, 26,...
  • 在朋友的强烈建议下,写一篇关于利用CNN卷积神经网络实现基于MATLAB的手写数字识别系统的设计的博客。 一、关于卷积神经网络 关于卷积神经网络我写过一篇文章单独介绍,可以参考:手写数字识别问题(3)——详解卷积...
  • 利用Python制作简易的神经网络 * 实现手写数字识别 * github项目地址:https://github.com/coding-cheng/mnist * 完整的数据集: 训练集 :http://www.pjreddie.com/midea/files/mnist_train.csv 测试集 :...
  • import tensorflow as tf import tensorflow.examples.tutorials.mnist.input_data as input_data...#2 建立模型 使用卷积神经网络 #2.1 输入图像与标签 x = tf.placeholder("float", shape = [None, 28,28,1]) y_ = .
  • 基于卷积神经网络手写数字识别系统设计(调用USB摄像头) ** 本科毕业设计做的就是这个,所以想了想就在这里写一下。 至于讲述卷积神经网络以及图像处理的部分,在网上一搜能够找到打把的资料,这里就不多说,直接...
  • Y_train = np_utils.to_categorical(y_train, nb_classes) Y_test = np_utils.to_categorical(y_test, nb_classes) print("Y_train:", Y_train.shape)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,062
精华内容 2,424
关键字:

利用python卷积神经网络手写数字识别

python 订阅