tensorflow使用DNN、CNN、RNN(lstm)分别实现识别mnist手写数字图片

深碍√TFBOYSˉ_ 2023-07-17 02:53 16阅读 0赞

#### 一、DNN结构实现mnist手写数字图片 ####

import os
    import struct
    import numpy as np
    import tensorflow as tf
    
    #数据加载函数
    def load_mnist(path, kind='train'):
        """load mnist date
        Args:
            path: date path
            kind: train or test
        Returns:
            images and labels
        """
        labels_path = os.path.join(path,'%s-labels.idx1-ubyte'% kind)   #标签数据
        images_path = os.path.join(path,'%s-images.idx3-ubyte'% kind)   #图像数据
        with open(labels_path, 'rb') as lbpath:
            magic, n = struct.unpack('>II',lbpath.read(8))
            labels = np.fromfile(lbpath,dtype=np.uint8)
        
        with open(images_path, 'rb') as imgpath:
            magic, num, rows, cols = struct.unpack('>IIII',imgpath.read(16))
            images = np.fromfile(imgpath,dtype=np.uint8).reshape(len(labels), 784)
            
        return images, labels
    
    #将label进行one-hot处理
    def y_onehot(y):
        """one-hot option
        Args:
            y: labels
        Returns:
            one-hot label
            eg:1->[0,1,0,0,0,0,0,0,0]
        """
        n_class = 10
        y_labels = np.eye(n_class)[y]
        return y_labels
    
    #超参
    Epoch=100
    batch_size=256
    learning_rate=0.05
    
    x=tf.placeholder(tf.float32, [None, 784])
    y=tf.placeholder(tf.float32, [None, 10])
    is_train = tf.placeholder(tf.bool)  #BatchNorm 参数
    keep_prob = tf.placeholder(tf.float32)   #dropout参数
    
    W_fc1 = tf.Variable(tf.truncated_normal(shape=[784, 1024], stddev=0.1), name="W_fc1")
    b_fc1 = tf.Variable(tf.constant(0.01, shape=[1024]), name="b_fc1")
    
    W_fc2 = tf.Variable(tf.truncated_normal(shape=[1024, 512], stddev=0.1), name="W_fc2")
    b_fc2 = tf.Variable(tf.constant(0.01, shape=[512]), name="b_fc2")
    
    W_fc3 = tf.Variable(tf.truncated_normal(shape=[512, 10], stddev=0.1), name="W_fc3")
    b_fc3 = tf.Variable(tf.constant(0.01, shape=[10]), name="b_fc3")
    
    def minist_dnn(x, is_train, keep_prob, W_fc1, b_fc1, W_fc2, b_fc2):
        layer1 = tf.add(tf.matmul(x, W_fc1), b_fc1)
        layer1_bn = tf.layers.batch_normalization(layer1, training=is_train)  #BN层
        layer1_relu = tf.nn.relu(layer1_bn)
        
        #一般添加了BN层就不添加dropout，添加了dropout就不添加BN，这一层只使用dropout
        layer2 = tf.add(tf.matmul(layer1_relu, W_fc2), b_fc2)
        layer2_relu = tf.nn.relu(layer2)
        layer2_drop = tf.nn.dropout(layer2_relu, keep_prob)   #dropout层
        
        layer3 = tf.add(tf.matmul(layer2_drop, W_fc3), b_fc3)
        pred = tf.nn.softmax(layer3)
        
        return pred
    
    pred = minist_dnn(x, is_train, keep_prob, W_fc1, b_fc1, W_fc2, b_fc2)
    loss = -tf.reduce_mean(y*tf.log(tf.clip_by_value(pred, 1e-8, 1)))
    correct_prediction = tf.equal(tf.arg_max(y, 1), tf.arg_max(pred,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
    train_op=optimizer.minimize(loss)
    
    init = tf.global_variables_initializer()
    saver = tf.train.Saver(tf.global_variables())
    
    path = 'D:/data/mnist/'
    X_train, y_train = load_mnist(path, kind='train')    #训练集
    y_train_labels = y_onehot(y_train)
    
    
    with tf.Session() as sess:
        sess.run(init)
        total_batch = int(len(X_train)/batch_size)
        
        for step in range(Epoch):
            for i in range(1,total_batch):
                batch_x = X_train[(i-1)*batch_size: i*batch_size]
                batch_y = y_train_labels[(i-1)*batch_size: i*batch_size]
                
                sess.run(train_op,feed_dict={
        x:batch_x, y:batch_y, is_train:True, keep_prob:0.5})
            
            entropy ,acc = sess.run([loss, accuracy], feed_dict={
        x:X_train[0:1000], y:y_train_labels[0:1000], is_train:False, keep_prob:1})
            print('step{} loss=============>:{:.4f},   auc===========> {:.4f}'.format(step, entropy, acc) )
        
        print ("Optimization Finished!")

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1MTcxMzI_size_16_color_FFFFFF_t_70]

#### 二、CNN结构实现mnist手写数字图片 ####

import os
    import struct
    import numpy as np
    import tensorflow as tf
    
    tf.reset_default_graph()  #清空计算图
    
    #数据加载函数
    def load_mnist(path, kind='train'):
        """load mnist date
        Args:
            path: date path
            kind: train or test
        Returns:
            images and labels
        """
        labels_path = os.path.join(path,'%s-labels.idx1-ubyte'% kind)   #标签数据
        images_path = os.path.join(path,'%s-images.idx3-ubyte'% kind)   #图像数据
        with open(labels_path, 'rb') as lbpath:
            magic, n = struct.unpack('>II',lbpath.read(8))
            labels = np.fromfile(lbpath,dtype=np.uint8)
        
        with open(images_path, 'rb') as imgpath:
            magic, num, rows, cols = struct.unpack('>IIII',imgpath.read(16))
            images = np.fromfile(imgpath,dtype=np.uint8).reshape(len(labels), 784)
            
        return images, labels
    
    #将label进行one-hot处理
    def y_onehot(y):
        """one-hot option
        Args:
            y: labels
        Returns:
            one-hot label
            eg:1->[0,1,0,0,0,0,0,0,0]
        """
        n_class = 10
        y_labels = np.eye(n_class)[y]
        return y_labels
    
    #超参
    Epoch=100
    batch_size=256
    learning_rate=0.001
    
    x= tf.placeholder(tf.float32, [None, 784])  #x
    y=tf.placeholder(tf.float32, [None, 10])  #y
    keep_prob = tf.placeholder(tf.float32)   #用于空值dropout概率
    
    def mnist_cnn(x, keep_prob):
        x_image=tf.reshape(x, [-1,28,28,1])  #将数据变为28*28形状
        
        #第一层卷积
        with tf.variable_scope("conv_pool1"):
            W_conv1 = tf.get_variable("weights",[5,5,1,32], initializer = tf.truncated_normal_initializer(stddev=0.1))   #第一层卷积参数,fileter尺寸为5*5,输入通道为1，输出通道为32
            b_conv1 = tf.get_variable("bias",[32], initializer = tf.constant_initializer(0.01))   #第一层偏置项，输出的每一个通道通会加一个bias，总共加32个
            
            h_conv1=tf.nn.conv2d(x_image, filter= W_conv1, strides=[1,1,1,1], padding="SAME")   #第一层卷积,stride为移动步长
            h_conv1_relu = tf.nn.relu(h_conv1+b_conv1)  #激活函数，注意tf.nn.conv2d不带激活函数，tf.layers.conv2d参数可以指定激活函数
            h_pooling1 = tf.nn.max_pool(h_conv1_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  #ksize为pooling核大小，pooling后变为(?, 14, 14, 32)
        
        #第二层卷积
        with tf.variable_scope("conv_pool2"):
            W_conv2 = tf.get_variable("weights",[5,5,32,64], initializer = tf.truncated_normal_initializer(stddev=0.1))   #第一层卷积参数,fileter尺寸为5*5,输入通道为1，输出通道为32
            b_conv2 = tf.get_variable("bias",[64], initializer = tf.constant_initializer(0.01))   #第一层偏置项，输出的每一个通道通会加一个bias，总共加32个
            
            h_conv2=tf.nn.conv2d(h_pooling1, filter= W_conv2, strides=[1,1,1,1], padding="SAME")   #第一层卷积,stride为移动步长
            h_conv2_relu = tf.nn.relu(h_conv2+b_conv2)  #激活函数，注意tf.nn.conv2d不带激活函数，tf.layers.conv2d参数可以指定激活函数
            h_pooling2 = tf.nn.max_pool(h_conv2_relu, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')  #ksize为pooling核大小，pooling后变为(?, 14, 14, 32)
        
        pool_shape = h_pooling2.get_shape().as_list()   #获得h_pooling2的维度，为[batch_size, wide, height, channel]
        h_pooling2_flat = tf.reshape(h_pooling2, [-1, pool_shape[1]*pool_shape[2]*pool_shape[3]])  #对pooling2一维展开
        
        #全连接
        with tf.variable_scope("fc1"):
            W_fc1 = tf.get_variable("weights",[pool_shape[1]*pool_shape[2]*pool_shape[3], 1024], initializer = tf.truncated_normal_initializer(stddev=0.1))   #全连接层权重，因为经过两层pooling，图片由28*28变为14*14，再变为7*7, 所以输入神经元为7*7*64
            b_fc1 = tf.get_variable("bias",[1024], initializer = tf.constant_initializer(0.01))   
            
            #h_pooling2 = tf.layers.flatten(h_pooling2)  #对pooling2一维展开
            fc1 = tf.add(tf.matmul(h_pooling2_flat, W_fc1), b_fc1) #第一层全连接
            fc1_relu = tf.nn.relu(fc1)
            fc1_drop = tf.nn.dropout(fc1_relu, keep_prob)   #dropout层
            
        #输出层
        with tf.variable_scope("output"):
            W_fc2 = tf.get_variable("weights",[1024, 10], initializer = tf.truncated_normal_initializer(stddev=0.1))    #全连接层权重，因为最终判断为10维，所以最终神经元为10个
            b_fc2 = tf.get_variable("bias",[10], initializer = tf.constant_initializer(0.01)) 
            output = tf.add(tf.matmul(fc1_drop, W_fc2), b_fc2)   #第二层全连接
            pred = tf.nn.softmax(output)
        
        return pred
    
    pred = mnist_cnn(x, keep_prob)  #带入函数
    loss = -tf.reduce_mean(y*tf.log(tf.clip_by_value(pred,1e-11,1.0)))
    correct_prediction = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))   #判断预测准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))     #准确率
    
    #可以加正则化损失
    #loss = loss+ 0.001*tf.nn.l2_loss(W_fc1)
    #optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate)
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)  #用梯度下降求解
    train_op=optimizer.minimize(loss)
    
    init = tf.global_variables_initializer()
    saver = tf.train.Saver(tf.global_variables())
    #saver = tf.compat.v1.train.Saver(tf.compat.v1.global_variables())
    
    #with tf.Session() as sess:
    #    print(accuracy)
    
    
    
    
    path = 'D:/data/mnist/'
    X_train, y_train = load_mnist(path, kind='train')    #训练集
    y_train_labels = y_onehot(y_train)
    
    
    with tf.Session() as sess:
        sess.run(init)
        total_batch = int(len(X_train)/batch_size)
        
        for step in range(Epoch):
            for i in range(1,total_batch):
                batch_x = X_train[(i-1)*batch_size: i*batch_size]
                batch_y = y_train_labels[(i-1)*batch_size: i*batch_size]
                
                sess.run(train_op,feed_dict={
        x:batch_x, y:batch_y, keep_prob:0.5})
            
            #saver.save(sess, 'D:/data/mnist/cnn_mnist.module', global_step=step)  #保存模型
            entropy ,acc = sess.run([loss, accuracy], feed_dict={
        x:X_train[0:1000], y:y_train_labels[0:1000], keep_prob:1})
            print('step{} loss=============>:{:.4f},   auc===========> {:.4f}'.format(step, entropy, acc) )
        
        print ("Optimization Finished!")

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1MTcxMzI_size_16_color_FFFFFF_t_70 1]

#### 三、LSTM结构实现mnist手写数字图片 ####

import os
    import struct
    import numpy as np
    import tensorflow as tf
    
    tf.reset_default_graph()  #清空计算图
    
    #数据加载函数
    def load_mnist(path, kind='train'):
        """load mnist date
        Args:
            path: date path
            kind: train or test
        Returns:
            images and labels
        """
        labels_path = os.path.join(path,'%s-labels.idx1-ubyte'% kind)   #标签数据
        images_path = os.path.join(path,'%s-images.idx3-ubyte'% kind)   #图像数据
        with open(labels_path, 'rb') as lbpath:
            magic, n = struct.unpack('>II',lbpath.read(8))
            labels = np.fromfile(lbpath,dtype=np.uint8)
        
        with open(images_path, 'rb') as imgpath:
            magic, num, rows, cols = struct.unpack('>IIII',imgpath.read(16))
            images = np.fromfile(imgpath,dtype=np.uint8).reshape(len(labels), 784)
            
        return images, labels
    
    #将label进行one-hot处理
    def y_onehot(y):
        """one-hot option
        Args:
            y: labels
        Returns:
            one-hot label
            eg:1->[0,1,0,0,0,0,0,0,0]
        """
        n_class = 10
        y_labels = np.eye(n_class)[y]
        return y_labels
    
    
    #超参
    Epoch=100
    learning_rate=0.05
    timestep=28   #特征序列长度，对应隐藏层ht个数
    num_input=28   #特征维度，共28维。图像每一行可以看做一个维度特征，共28维
    lstm_hidden_size=64  #lstm隐藏层神经元个数
    num_of_layers = 2  #lstm的层数
    
    x= tf.placeholder(tf.float32, [None, 784])  #x
    y=tf.placeholder(tf.float32, [None, 10])  #y
    lstm_keep_prob = tf.placeholder(tf.float32)
    keep_prob = tf.placeholder(tf.float32)   #用于空值dropout概率
    batch_size = tf.placeholder(tf.int32, [])   #一个批次数据，训练集是使用256，预测时使用1000,[]表示是一个Scalar
    
    def mnist_lstm(x, lstm_keep_prob, keep_prob, batch_size):
        x_image = tf.reshape(x, [-1,timestep, num_input])  #将数据序列长度*特征维度
        
        with tf.variable_scope("lstmlayer"):
            #创建lstm结构，ht神经元个数为64，，可推测出，一个门的参数个数为64*(64+28)+64, (64+28)表示ht-1与xt拼接的维度
            #为lstm创建dropout,有两个参数，训练时，input_keep_prob，一般设置为1，out_keep_prob一般设置为0.5
            #创建num_of_layers层lstm，不能用[lstm]*N，否则每层lstm参数会共享
            #注意lstm，dropout和多层MultiRNNCell必须放在一起调用，否则会出现维度错误
            stacked_lstm = tf.nn.rnn_cell.MultiRNNCell([tf.nn.rnn_cell.DropoutWrapper(tf.nn.rnn_cell.BasicLSTMCell(lstm_hidden_size), input_keep_prob=1, output_keep_prob =lstm_keep_prob ) for _ in range(num_of_layers)]) 
            
            init_state = stacked_lstm.zero_state(batch_size, dtype=tf.float32)
            #计算前项lstm层的输出, 两个输出，一个记录ht，一个记录ct
            lstm_outputs, _ = tf.nn.dynamic_rnn(stacked_lstm, x_image, initial_state=init_state, dtype=tf.float32)
            #我们支取最后一个输出状态ht进行下一步的预测
            lstm_output = lstm_outputs[:,-1,:]
        
        with tf.variable_scope("fc1"):
            W_fc1 = tf.get_variable('weight', shape=[lstm_hidden_size, 10], initializer = tf.truncated_normal_initializer(stddev=0.1), dtype=tf.float32)
            b_fc1 = tf.get_variable('bias', shape=[10], initializer = tf.constant_initializer(0.1), dtype=tf.float32)
            
            output = tf.add(tf.matmul(lstm_output, W_fc1), b_fc1) #第一层全连接
        
        pred = tf.nn.softmax(output)
        
        return pred
    
            
    pred = mnist_lstm(x, lstm_keep_prob, keep_prob, batch_size)  #带入函数
    loss = -tf.reduce_mean(y*tf.log(tf.clip_by_value(pred,1e-11,1.0)))
    correct_prediction = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))   #判断预测准确率
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))     #准确率
    
    #可以加正则化损失
    #loss = loss+ 0.001*tf.nn.l2_loss(W_fc1)
    #optimizer = tf.compat.v1.train.AdamOptimizer(learning_rate)
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)  #用梯度下降求解
    train_op=optimizer.minimize(loss)
    
    init = tf.global_variables_initializer()
    #saver = tf.train.Saver(tf.global_variables())
    
    
    path = 'D:/data/mnist/'
    X_train, y_train = load_mnist(path, kind='train')    #训练集
    y_train_labels = y_onehot(y_train)
    
    with tf.Session() as sess:
        sess.run(init)
        total_batch = int(len(X_train)/256)
        
        for step in range(Epoch):
            for i in range(1,total_batch):
                batch_x = X_train[(i-1)*256: i*256]
                batch_y = y_train_labels[(i-1)*256: i*256]
                
                sess.run(train_op,feed_dict={
        x:batch_x, y:batch_y, lstm_keep_prob:0.5, keep_prob:0.5, batch_size:256})
            
            #saver.save(sess, 'D:/data/mnist/cnn_mnist.module', global_step=step)  #保存模型
            entropy ,acc = sess.run([loss, accuracy], feed_dict={
        x:X_train[0:1000], y:y_train_labels[0:1000], lstm_keep_prob:1, keep_prob:1, batch_size:1000})
            print('step{} loss=============>:{:.4f},   auc===========> {:.4f}'.format(step, entropy, acc) )
        
        print ("Optimization Finished!")

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1MTcxMzI_size_16_color_FFFFFF_t_70 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1MTcxMzI_size_16_color_FFFFFF_t_70]: /images/20230528/0688486a2b71476b90e2eb254453281a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1MTcxMzI_size_16_color_FFFFFF_t_70 1]: /images/20230528/636cb3875d7b482d98fce7bceeed3175.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTE1MTcxMzI_size_16_color_FFFFFF_t_70 2]: /images/20230528/9fb165191c0146969fd74d5a96196de9.png