【一层隐藏层、一层输出层】隐藏层输出用relu函数

2022-02-04【一个隐藏层，一个输出层】隐藏层输出使用relu函数，输出层输出使用函数过程：设置参数滑动平均的辅助函数训练函数代码：

#参数设置
#输入、隐藏层神经元数、输出
samples = 55000
input_size = 784
output_size = 10
cell = 500
#训练次数，batch大小
training_step = 30000
batch_size = 100
#初始学习率、学习率衰减率、滑动平均衰减率、正则化系数
learning_rate = 0.8
learning_rate_decay = 0.99
moving_average_decay = 0.99
regulization_rate = 0.0001
#滑动平均的辅助函数
def moving_average_helper(input_x , ave_class , w1 , b1 , w2 , b2):
    if ave_class == None:
        layer1 = tf.nn.relu(tf.matmul(input_x,w1) + b1)
        y_pre = tf.matmul(layer1,w2) + b2
    else:
        layer1 = tf.nn.relu(tf.matmul(input_x,ave_class.average(w1)) + ave_class.average(b1))
        y_pre = tf.matmul(layer1,ave_class.average(w2)) + ave_class.average(b2)
    return y_pre
#建立模型、前向传播、后向传播，开始训练
def train(mnist,samples,input_size,output_size,cell,training_step,learning_rate,batch_size,learning_rate_decay,moving_average_decay,regulization_rate):
    
    ############################################################################
    #输入和输出
    x = tf.placeholder(tf.float32, [None,input_size] , name = 'x_input')
    y = tf.placeholder(tf.float32, [ None,output_size] , name = 'y_output')
    
    #参数
    w1 = tf.Variable(tf.truncated_normal([input_size,cell],stddev = 0.1))
    b1 = tf.Variable(tf.constant(0.1,shape = [cell]))
    
    w2 = tf.Variable(tf.truncated_normal([cell,output_size],stddev = 0.1))
    b2 = tf.Variable(tf.constant(0.1,shape = [output_size]))
    
    #不使用滑动平均
    y_pre = moving_average_helper(x , None , w1 , b1 , w2 , b2)
    ############################################################################
    #使用滑动平均计算预测值
    global_step = tf.Variable(0,trainable=False)
    ave_class = tf.train.ExponentialMovingAverage(moving_average_decay,global_step)
    variable_ave = ave_class.apply(tf.trainable_variables())
    moving_y_pre = moving_average_helper(x , ave_class , w1 , b1 , w2 , b2)
    
    y_ = moving_y_pre
    #计算交叉熵loss
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1)) #是一个计算softmax且计算交叉熵的函数，其参数第一个为实际的y，第二个为预测的y的最大值索引值
    cross_entropy_mean = tf.reduce_mean(cross_entropy) #计算所有样本的交叉熵平均值
    
    #计算l2正则化loss
    regularizer = tf.contrib.layers.l2_regularizer(regulization_rate)
    regularization = regularizer(w1) + regularizer(w2)
    
    #计算loss
    loss = cross_entropy_mean + regularization
    
    #设置指数衰减的学习率
    newlearning_rate = tf.train.exponential_decay(learning_rate,global_step,samples/batch_size,learning_rate_decay)
    
    #优化损失函数
    train_step = tf.train.GradientDescentOptimizer(newlearning_rate).minimize(loss , global_step = global_step)
    
    #同时训练参数和其滑动平均值
    #train_op = tf.group(train_step,ave_class)
    
    with tf.control_dependencies([train_step, variable_ave]):
        train_op = tf.no_op(name='train')
    #计算准确度
    correct = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
    accuracy = tf.reduce_mean(tf.cast(correct,tf.float32))
    ###############################################################################
    with tf.Session() as sess:
        tf.initialize_all_variables().run()
        validate_feed = {x:mnist.validation.images,y:mnist.validation.labels}
        test_feed = {x:mnist.test.images,y:mnist.test.labels}
        
        #循环迭代训练
        for i in range(training_step):
            if i % 1000 == 0:
                validate_acc = sess.run(accuracy,feed_dict=validate_feed)
                print('第%d验证集准确度%g：',%(i,validate_acc))
            xs , ys = mnist.train.next_batch(batch_size)
            sess.run(train_op,feed_dict={x:xs,y:ys})
        test_acc = sess.run(accuracy,feed_dict=test_feed)
        print("测试集准确度：",test_acc)
    

结果：

第%d验证集准确度%g： (0, 0.0924)
第%d验证集准确度%g： (1000, 0.0918)
第%d验证集准确度%g： (2000, 0.0922)
第%d验证集准确度%g： (3000, 0.0912)
第%d验证集准确度%g： (4000, 0.0912)
第%d验证集准确度%g： (5000, 0.0916)
第%d验证集准确度%g： (6000, 0.0914)
第%d验证集准确度%g： (7000, 0.0922)
第%d验证集准确度%g： (8000, 0.092)
第%d验证集准确度%g： (9000, 0.0922)
第%d验证集准确度%g： (10000, 0.0914)
第%d验证集准确度%g： (11000, 0.0918)
第%d验证集准确度%g： (12000, 0.092)
第%d验证集准确度%g： (13000, 0.093)
第%d验证集准确度%g： (14000, 0.0934)
第%d验证集准确度%g： (15000, 0.093)
第%d验证集准确度%g： (16000, 0.0928)
第%d验证集准确度%g： (17000, 0.0928)
第%d验证集准确度%g： (18000, 0.0922)
第%d验证集准确度%g： (19000, 0.0932)
第%d验证集准确度%g： (20000, 0.0934)
第%d验证集准确度%g： (21000, 0.094)
第%d验证集准确度%g： (22000, 0.0944)
第%d验证集准确度%g： (23000, 0.0946)
第%d验证集准确度%g： (24000, 0.0936)
第%d验证集准确度%g： (25000, 0.0964)
第%d验证集准确度%g： (26000, 0.097)
第%d验证集准确度%g： (27000, 0.097)
第%d验证集准确度%g： (28000, 0.0974)
第%d验证集准确度%g： (29000, 0.0976)
测试集准确度： 0.0887

常用函数说明：tf. ：

返回当前计算图中所有在获取时未标记为 =False 的变量集。 [可用于更新所有参数]

tf.()：该函数指定执行某些操作的依赖关系

返回一个控制依赖关系的上下文管理器。使用 with 关键字可以执行此上下文中的操作

1 with tf.control_dependencies([a, b]):
2     c = ....
3     d = ...

操作 c 和 d 只能在执行操作 a 和 b 之后执行。这意味着c、d操作依赖于a、b操作

1 with tf.control_dependencies([train_step, variable_averages_op]):
2     train_op = tf.no_op(name='train')

tf.no_op()：表示执行后，操作后什么都不做 tf.group:

用于创建一个操作，可以对传入参数的所有操作进行分组，也是一个操作。

ops = tf.group(, ,…)

其中*为0或更大表示组合，一旦ops完成，那么传入的,,…etc就会完成，常用于组合一些训练节点，

Tf。和 tf.group 两种机制可以用来一次完成多个操作。比如下面两个程序是等价的：【一个实现，两个操作】

with tf.control_dependencies([train_step, variable_averages_op]):
        train_op = tf.no_op(name='train')
############################################

train_op = tf.group(train_step,variables_averages_op)

tf.cast()

cast(
    x,
    dtype,
    name=None
)

将x的数据格式转换为dtype。比如x的原始数据格式是bool，

然后转换成float后，就可以转换成0和1的序列了，反之亦然。

分类：

技术要点：

相关文章：