深度学习笔记（二）：基于tensorflow gpu版本的深度神经网络程序总览

在第一篇笔记深度学习笔记（一）：基于numpy的深度神经网络程序总览之后，又用tensorflow的gpu版本实现了一遍，果然封装很好，写起来很舒服，速度也快很多，100次epoch分分钟就结束了，效果和第一篇笔记中基于numpy的效果差不多，以下是代码，比基于numpy的代码少了一多半，后续笔记就开始记录程序结构和算法步骤了，有时间就更新。

源代码和数据：点击打开链接

# -*- coding: utf-8 -*-
"""
Created on Sat Sep 30 18:45:47 2017

@author: 董玮
"""

import argparse
import time
import numpy as np
import matplotlib.pyplot as plt

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
from tensorflow.python.framework import ops

"""
类型：抽象类
说明：规则化数据接口，一般用于数据预处理中。
"""
class interface_normalize_data(object):
    
    """
    类型：公有成员变量
    说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
    """
    epsilon = 1e-8
    
    """
    类型：抽象公有成员函数
    说明：用来规则化数据。
    参数：
        data -- 待处理的数据。
    返回值：
        data -- 处理后的数据。
    """
    def normalize_data(self, data):
        
        pass

"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于中心化数据，使数据中心在坐标原点上。
"""
class mean_normalization(interface_normalize_data):           
        
    def normalize_data(self, data):
        #计算数据每个维度的期望，并用每一条数据减去期望。
        center = data - tf.reduce_mean(data, axis = 0, keep_dims = True)
        return center

"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于中心化数据，并除以方差，使数据中心在坐标原点上，并且使每个维度之间的跨度相似。
"""  
class variance_normalization(interface_normalize_data):
    
    def normalize_data(self, data):
        center = data - tf.reduce_mean(data, axis = 0, keep_dims = True)
        #计算数据每个维度的方差。
        variance = tf.reduce_mean(tf.square(center), axis = 0, keep_dims = True)
        #除以方差并在除数上加上无穷小精度。
        vscore = center / (variance + self.epsilon)
        return vscore

"""
类型：实体类，继承自抽象类interface_normalize_data
说明：用于Z-Score统计，与上述实体类的区别是除以标准差而不是方差。
"""     
class zscore_normalization(interface_normalize_data):
    
    def normalize_data(self, data):
        center = data - tf.reduce_mean(data, axis = 0, keep_dims = True)
        variance = tf.reduce_mean(tf.square(center), axis = 0, keep_dims = True)
        #除以标准差并在除数上加上无穷小精度。
        zscore = center / tf.sqrt(variance + self.epsilon)
        return zscore
    
"""   
类型：抽象类
说明：神经网络初始化参数接口。
"""
class interface_initialize_parameters(object):
    
    """
    类型：公有成员变量
    说明：定义输入层、隐藏层、输出层每层的神经元个数。
    """
    structure = None
    
    """
    类型：公有成员变量
    说明：定义规则化功能。
    """
    regularizer = None
    
    """
    类型：公有成员变量
    说明：随机种子，用来产生随机数。
    """
    seed = 1
    
    """
    类型：抽象公有成员函数
    说明：用来初始化参数。
    """
    def initialize_parameters(self):
        
        pass

"""
类型：实体类
说明：标准的x-avier参数初始化，继承自抽象类interface_initialize_parameters
"""
class xavier_initialize_parameters(interface_initialize_parameters):
    
    """
    类型：公有成员函数
    说明：用来初始化参数。
    参数：无
    返回值：
        parameters -- 返回初始化后的参数。
    """
    def initialize_parameters(self):
        
        tf.set_random_seed(self.seed)
        parameters = {}
        
        #初始化两类参数，一种是W1、W2、W3……，另一种是b1、b2、b3……。其中数字代表层数。
        #W的维度为(当前层神经元数，前一层神经元数)。b的维度为(当前层神经元数，1)。
        for l in range(1, len(self.structure)):
            parameters["W" + str(l)] = tf.get_variable("W" + str(l), [self.structure[l-1], self.structure[l]], 
                      initializer = tf.contrib.layers.xavier_initializer(self.seed), regularizer = self.regularizer)
            
            parameters["b" + str(l)] = tf.get_variable("b" + str(l), [1, self.structure[l]], 
                      initializer = tf.zeros_initializer())
            
        return parameters

"""
类型：实体类
说明：具有batch normalization功能的x-avier参数初始化，继承自抽象类interface_initialize_parameters
"""    
class xavier_initialize_parameters_BN(interface_initialize_parameters):
    
    """
    类型：公有成员函数
    说明：用来初始化参数。
    参数：无
    返回值：
        parameters -- 返回初始化后的参数。
    """
    def initialize_parameters(self):
        
        tf.set_random_seed(self.seed)
        parameters = {}
        
        #因batch normalization需要，初始化三类参数，W1、W2、W3……，gamma1、gamma2、gamma3……，beta1、beta2、beta3……。其中数字代表层数。
        #W的维度为(当前层神经元数，前一层神经元数)。gamma与beta的维度均为(当前层神经元数，1)。
        for l in range(1, len(self.structure)):
            parameters["W" + str(l)] = tf.get_variable("W" + str(l), [self.structure[l-1], self.structure[l]], 
                      initializer = tf.contrib.layers.xavier_initializer(self.seed), regularizer = self.regularizer)
            parameters["gamma" + str(l)] = tf.get_variable("gamma" + str(l), [1, self.structure[l]], 
                      initializer = tf.ones_initializer())
            parameters["beta" + str(l)] = tf.get_variable("beta" + str(l), [1, self.structure[l]], 
                      initializer = tf.zeros_initializer())
            
        return parameters

"""
类型：抽象类
说明：定义向前向后算法。
"""
class interface_propagation(object):
    
    """
    类型：公有成员变量
    说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
    """
    epsilon = 1e-8
    
    """
    类型：公有成员变量
    说明：是否进行dropout规则化操作。
    """
    is_dropout = False
    
    """
    类型：公有成员变量
    说明：如果is_dropout为真，那么此变量存储每一层保持神经元个数的概率。
    """
    keep_prob = 1.
    
    """
    类型：公有成员变量
    说明：定义激活函数。
    """
    act_func = None

    """
    类型：抽象公有函数
    说明：向前算法。
    参数：
        training_set -- 训练集。
        training_label -- 训练标签。
        parameters -- 训练参数。
    """
    def forward_propagation(self, training_set, training_label, parameters):
        
        pass

"""
类型：具体类
说明：标准的向前算法，继承自interface_propagation。
"""  
class propagation_standard(interface_propagation):

    def forward_propagation(self, training_set, training_label, parameters):
        
        if(len(parameters) < 2):
            return None
        
        #向前算法
        A = training_set
        
        layer_number = len(parameters) // 2
        for l in range(1, layer_number):
            Z = tf.matmul(A, parameters["W"+str(l)]) + parameters["b" + str(l)]
            #激活函数
            A = self.act_func(Z)
            
            #添加dropout正则化功能
            if(self.is_dropout == True):
                A = tf.nn.dropout(A, self.keep_prob)
    
        Z = tf.matmul(A, parameters["W"+str(layer_number)]) + parameters["b" + str(layer_number)]
        
        #计算代价函数
        cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = training_label, logits = Z)) + tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
        
        return cross_entropy, Z

"""
类型：具体类
说明：带有Batch normalization的向前算法，继承自interface_propagation。
"""     
class propagation_BN(interface_propagation):
    
    def forward_propagation(self, training_set, training_label, parameters):
        
        if(len(parameters) < 2):
            return None
        
        #向前算法
        A = training_set
        
        #注意，因为Batch normalization有三个学习参数，这里要除以3取整。
        layer_number = len(parameters) // 3
        for l in range(1, layer_number):
            Z = tf.matmul(A, parameters["W"+str(l)])
            #向前算法中的Batch normalization步骤。
            Zmean = tf.reduce_mean(Z, axis = 0, keep_dims = True)
            Zcenter = Z - Zmean
            Zvariance = tf.reduce_mean(tf.square(Zcenter), axis = 0, keep_dims = True)
            Ztilde = Zcenter / tf.sqrt(Zvariance + self.epsilon)
            Z = tf.multiply(Ztilde, parameters["gamma" + str(l)]) + parameters["beta" + str(l)]
            
            #激活函数
            A = self.act_func(Z)
            if(self.is_dropout == True):
                A = tf.nn.dropout(A, self.keep_prob)
        
        #向前算法中输出层的Batch normalization步骤。
        Z = tf.matmul(A, parameters["W"+str(layer_number)])
        Zmean = tf.reduce_mean(Z, axis = 0, keep_dims = True)
        Zcenter = Z - Zmean
        Zvariance = tf.reduce_mean(tf.square(Zcenter), axis = 0, keep_dims = True)
        Ztilde = Zcenter / tf.sqrt(Zvariance + self.epsilon)
        Z = tf.multiply(Ztilde, parameters["gamma" + str(layer_number)]) + parameters["beta" + str(layer_number)]
        
        #计算代价函数
        cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels = training_label, logits = Z)) + tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))
        
        return cross_entropy, Z

"""
类型：抽象类
说明：定义一个工厂类，用来生产学习模型过程中所需要的模块。
"""
class interface_factory(object):
    
    """
    类型：公有成员变量
    说明：数据预处理规则化模块。
    """
    normalizer = None
    
    """
    类型：公有成员变量
    说明：学习参数初始化模块。
    """
    initializer = None
    
    """
    类型：公有成员变量
    说明：向前学习算法模块。
    """
    propagator = None
    
    """
    类型：公有成员变量
    说明：规则化数据过程中，定义一个无穷小精度，用来防止数据计算中的非法操作。
    """
    epsilon = 1e-8
    
    """
    类型：公有成员变量
    说明：定义优化算法的学习率。
    """
    learning_rate = 1e-3
    
    """
    类型：公有成员变量
    说明：Batch normalization超参数。
    """
    beta1 = 0.9
    
    """
    类型：公有成员变量
    说明：Batch normalization超参数。
    """
    beta2 = 0.999
    
    """
    类型：公有成员变量
    说明：数据批量优化算法说需要的batch大小，即每次训练从训练集里抽样的个数。
    """
    minibatch_size = 512
    
    """
    类型：公有成员变量
    说明：epoch个数，即需要训练整个数据集多少遍。
    """
    num_epochs = 100
    
    """
    类型：公有成员变量
    说明：定义每几步衰减一次。
    """
    epoch_step = 5
    
    """
    类型：公有成员变量
    说明：衰退比率。
    """
    k = 0.09
    
    """
    类型：抽象公有成员函数
    说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
    """
    def create_workpiece(self, *arguments):
        
        pass
"""
类型：具体类
说明：工厂版本v1，不带Batch normalization功能，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，优化算法为adam，学习率为指数衰减。
"""
class factory_v1(interface_factory):
    
    """
    类型：公有成员函数
    说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
    参数：
        arguments[0] -- 数值计算精度 - epsilon
        arguments[1] -- 网络结构 - structure
        arguments[2] -- 随机种子 - seed
        arguments[3] -- 学习率 - learning_rate
        arguments[4] -- adam参数 - beta1
        arguments[5] -- adam参数 - beta2
        arguments[6] -- batch的大小 - minibatch_size
        arguments[7] -- epoch个数 - num_epochs
        arguments[8] -- 衰减步数 - epoch_step
        arguments[9] -- 衰减率 - k
    """
    def create_workpiece(self, *arguments):
        
        self.epsilon = arguments[0]
        
        self.normalizer = zscore_normalization()
        self.normalizer.epsilon = self.epsilon
        
        structure = arguments[1]
        seed = arguments[2]
        
        self.initializer = xavier_initialize_parameters()
        self.initializer.structure = structure
        self.initializer.seed = seed
        
        self.propagator = propagation_standard()
        self.propagator.epsilon = self.epsilon
        self.propagator.act_func = tf.nn.relu
        
        self.learning_rate = arguments[3]
        self.beta1 = arguments[4]
        self.beta2 = arguments[5]
        
        self.minibatch_size = arguments[6]
        self.num_epochs = arguments[7]
        
        self.epoch_step = arguments[8]
        self.k = arguments[9]
        
        return self
"""
类型：具体类
说明：工厂版本v3，带Batch normalization功能，带dropout规则化，激活函数为relu，最后一层激活函数为softmax，代价函数用的是交叉熵损失函数，优化算法为adam，学习率为指数衰减。
"""     
class factory_v2(interface_factory):
    
    """
    类型：公有成员函数
    说明：创建一个工厂，该工厂生产训练和测试数据过程中所需要的模块。
    参数：
        arguments[0] -- 数值计算精度 - epsilon
        arguments[1] -- 网络结构 - structure
        arguments[2] -- 随机种子 - seed
        arguments[3] -- 学习率 - learning_rate
        arguments[4] -- adam参数 - beta1
        arguments[5] -- adam参数 - beta2
        arguments[6] -- batch的大小 - minibatch_size
        arguments[7] -- epoch个数 - num_epochs
        arguments[8] -- 衰减步数 - epoch_step
        arguments[9] -- 衰减率 - k
        arguments[10] -- 是否进行dropout步骤 - is_dropout
        arguments[11] -- dropout保持概率 - keep_prob
    """
    def create_workpiece(self, *arguments):
        
        self.epsilon = arguments[0]
        #tf_epsilon = tf.Variable(epsilon)
        
        self.normalizer = zscore_normalization()
        self.normalizer.epsilon = self.epsilon
        
        structure = arguments[1]
        seed = arguments[2]
        
        self.initializer = xavier_initialize_parameters_BN()
        self.initializer.structure = structure
        self.initializer.seed = seed
        
        self.propagator = propagation_BN()
        self.propagator.epsilon = self.epsilon
        self.propagator.act_func = tf.nn.relu
        
        self.learning_rate = arguments[3]
        self.beta1 = arguments[4]
        self.beta2 = arguments[5]
        
        self.minibatch_size = arguments[6]
        self.num_epochs = arguments[7]
        
        self.epoch_step = arguments[8]
        self.k = arguments[9]
        
        is_dropout = arguments[10]
        keep_prob = arguments[11]
        
        self.propagator.is_dropout = is_dropout
        self.propagator.keep_prob = keep_prob
        
        return self

"""
类型：抽象类
说明：定义一个工厂类，用来生产学习模型过程中所需要的模块。
"""   
class interface_train_model(object):
    
    """
    类型：公有成员变量
    说明：学习参数。
    """
    parameters = None
    
    """
    类型：公有成员变量
    说明：训练集。
    """
    training_set = None
    
    """
    类型：公有成员变量
    说明：训练标签。
    """
    training_label = None
    
    """
    类型：公有成员变量
    说明：验证集。
    """
    validation_set = None
    
    """
    类型：公有成员变量
    说明：验证标签。
    """
    validation_label = None
    
    """
    类型：公有成员变量
    说明：测试集。
    """
    test_set = None
    
    """
    类型：公有成员变量
    说明：测试标签。
    """
    test_label = None
    
    """
    类型：公有成员变量
    说明：工厂对象。
    """
    factory = None
    
    """
    类型：抽象公有成员函数
    说明：训练模型方法。
    """
    def training_model(self, *arguments):
        
        pass

"""
类型：具体类
说明：定义深度神经网络。
"""
class deep_neural_networks(interface_train_model):

    """
    类型：初始化函数
    说明：初始化工厂对象。
    """
    def __init__(self, factory):
        self.factory = factory
    
    def training_model(self, *arguments):
        
        #重置图计算步骤，恢复默认状态。
        ops.reset_default_graph()
        
        #定义占位符，用来输入数据
        X = tf.placeholder(tf.float32, shape=(None, self.training_set.shape[1]))
        Y = tf.placeholder(tf.float32, shape=(None, self.training_label.shape[1]))
        
        #定义深度神经网络结构
        self.factory.initializer.structure = np.append(np.array([self.training_set.shape[1]]), self.factory.initializer.structure)
        num_minibatches = int(self.training_set.shape[0] / self.factory.minibatch_size) + 1
        
        #定义数据预处理步骤
        if(self.factory.normalizer != None):
            normalize_result = self.factory.normalizer.normalize_data(X)
        
        #定义学习参数及超参数初始化步骤
        self.parameters = self.factory.initializer.initialize_parameters()
        seed = self.factory.initializer.seed
        
        #定义向前算法步骤
        cross_entropy, ZL = self.factory.propagator.forward_propagation(X, Y, self.parameters)
        
        global_step = tf.Variable(0, trainable = False)
        
        #定义学习率衰减
        learning_rate_target = tf.train.natural_exp_decay(self.factory.learning_rate, global_step, self.factory.epoch_step * self.training_set.shape[0], self.factory.k, staircase=True)
        
        #定义优化算法
        optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate_target, beta1 = self.factory.beta1, beta2 = self.factory.beta2, epsilon = self.factory.epsilon).minimize(cross_entropy, global_step = global_step)

        #定义计算精度
        correct_prediction = tf.equal(tf.argmax(ZL, 1), tf.argmax(Y, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
        
        costs = []
        training_accuracies = []
        validation_accuracies = []
        
        #在验证集上表现最好的学习参数
        best_parameters = {}
        #最好学习参数时，训练集的精度
        best_training_acc = 0.
        #最好学习参数时，验证集的精度
        best_validation_acc = 0.
            
        init = tf.global_variables_initializer()
        
        #执行计算图
        with tf.Session() as sess:
            
            start = time.clock()
            sess.run(init)
            
            #数据在计算图中的预处理步骤
            if(self.factory.normalizer != None):
                self.training_set = sess.run(normalize_result, feed_dict={X: self.training_set})
                self.validation_set = sess.run(normalize_result, feed_dict={X: self.validation_set})
            
            #epoch学习过程
            for iter_epoch in range(1, self.factory.num_epochs + 1):
                cost = 0
                
                #minibatch学习过程
                for iter_batch in range(1, num_minibatches + 1):
                    seed += 1
                    (minibatch_X, minibatch_Y) = self.__random_mini_batches(self.factory.minibatch_size, seed)
                    _ , minibatch_cost = sess.run([optimizer, cross_entropy], feed_dict={X: minibatch_X, Y: minibatch_Y})
                    cost += minibatch_cost
                
                cost /= num_minibatches
                costs.append(cost)
                training_acc = accuracy.eval(feed_dict={X: self.training_set, Y: self.training_label})
                training_accuracies.append(training_acc)
                validation_acc = accuracy.eval(feed_dict={X: self.validation_set, Y: self.validation_label})
                validation_accuracies.append(validation_acc)
                
                if(validation_acc > best_validation_acc):
                    best_training_acc = training_acc
                    best_validation_acc = validation_acc
                    best_parameters = sess.run(self.parameters)
                
                print ("Cost after epoch %i: %f" % (iter_epoch, cost))
                print ("Training accuracy after epoch %i: %f" % (iter_epoch, training_acc))
                print ("Validation accuracy after epoch %i: %f" % (iter_epoch, validation_acc))
                
            end = time.clock()
            
            self.factory.initializer.seed = seed
            self.parameters = best_parameters
                
            plt.plot(np.squeeze(costs))
            plt.ylabel('cost')
            plt.xlabel('epochs')
            plt.title("Learning rate of Start step =" + str(self.factory.learning_rate))
            plt.show()
            
            plt.plot(np.squeeze(training_accuracies))
            plt.ylabel('training accracy')
            plt.xlabel('epochs')
            plt.title("Learning rate of Start step =" + str(self.factory.learning_rate))
            plt.show()
            
            plt.plot(np.squeeze(validation_accuracies))
            plt.ylabel('validation accracy')
            plt.xlabel('epochs')
            plt.title("Learning rate of Start step =" + str(self.factory.learning_rate))
            plt.show()
            
            print ("Accuracy of total Training set: %f%%" % (best_training_acc * 100))
            print ("Accuracy of total Validation set: %f%%" % (best_validation_acc * 100))
            print ("Training of total Time: %f Minutes" % ((end - start) / 60))
    

    """
    从训练数据集和标签集中随机抽取minibatch。
    参数：
        X_train -- 训练数据集。
        Y_train -- 训练标签集。
        minibatch_size -- minibatch尺寸。
        seed -- 随机种子。
    返回值：
        元组 -- 返回一个minibatch，包括训练数据和对应的标签数据。
    """
    def __random_mini_batches(self, minibatch_size, seed):
        
        np.random.seed(seed)
        shuffle_array = np.random.randint(0, self.training_set.shape[0], minibatch_size)
        return (self.training_set[shuffle_array, :], self.training_label[shuffle_array, :])   

def main():
    
    parser = argparse.ArgumentParser()
    parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
                        help='Directory for storing input data')
    FLAGS, unparsed = parser.parse_known_args()
    mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
    
    struct = [512, 256, 128, 64, 32, 16, 10]
    factory = factory_v2()
    factory.create_workpiece(1e-8, struct, 1, 1e-3, 0.9, 0.999, 512, 100, 5, 0.009, False, 0.8)
    
    dnn = deep_neural_networks(factory)
    dnn.training_set = mnist.train.images
    dnn.training_label = mnist.train.labels
    dnn.validation_set = mnist.test.images
    dnn.validation_label = mnist.test.labels
    dnn.training_model()

main()

运行结果：