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

一、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!")

二、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!")

三、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!")