TF之BN:BN算法对多层中的每层神经网络加快学习QuadraticFunction_InputData+Histogram+BN的Error_curve-阿里云开发者社区

开发者社区> 一个处女座的程序猿> 正文

TF之BN:BN算法对多层中的每层神经网络加快学习QuadraticFunction_InputData+Histogram+BN的Error_curve

简介: TF之BN:BN算法对多层中的每层神经网络加快学习QuadraticFunction_InputData+Histogram+BN的Error_curve
+关注继续查看

输出结果

image.png


代码设计


# 23 Batch Normalization

import numpy as np

import tensorflow as tf

import matplotlib.pyplot as plt

ACTIVATION = tf.nn.tanh

N_LAYERS = 7          

N_HIDDEN_UNITS = 30  

def fix_seed(seed=1):

   # reproducible

   np.random.seed(seed)

   tf.set_random_seed(seed)

def plot_his(inputs, inputs_norm):

   # plot histogram for the inputs of every layer

   

   for j, all_inputs in enumerate([inputs, inputs_norm]):

       for i, input in enumerate(all_inputs):

           plt.subplot(2, len(all_inputs), j*len(all_inputs)+(i+1))

           plt.cla()

           if i == 0:

               the_range = (-7, 10)

           else:

               the_range = (-1, 1)

           plt.hist(input.ravel(), bins=15, range=the_range, color='#0000FF')

           plt.yticks(())

           if j == 1:

               plt.xticks(the_range)

           else:

               plt.xticks(())

           ax = plt.gca()

           ax.spines['right'].set_color('none')

           ax.spines['top'].set_color('none')

       plt.title("%s normalizing" % ("Without" if j == 0 else "With"))

   plt.title('Matplotlib,BN,histogram--Jason Niu')

   plt.draw()

   plt.pause(0.001)

def built_net(xs, ys, norm):

   def add_layer(inputs, in_size, out_size, activation_function=None, norm=False):

       # weights and biases (bad initialization for this case)

       Weights = tf.Variable(tf.random_normal([in_size, out_size], mean=0., stddev=1.))

       biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)

       # fully connected product

       Wx_plus_b = tf.matmul(inputs, Weights) + biases

       # normalize fully connected product

       if norm:

           # Batch Normalize

           fc_mean, fc_var = tf.nn.moments(

               Wx_plus_b,

               axes=[0],  

                           

           )

           scale = tf.Variable(tf.ones([out_size]))

           shift = tf.Variable(tf.zeros([out_size]))

           epsilon = 0.001

           # apply moving average for mean and var when train on batch

           ema = tf.train.ExponentialMovingAverage(decay=0.5)

           def mean_var_with_update():

               ema_apply_op = ema.apply([fc_mean, fc_var])

               with tf.control_dependencies([ema_apply_op]):

                   return tf.identity(fc_mean), tf.identity(fc_var)

           mean, var = mean_var_with_update()

           Wx_plus_b = tf.nn.batch_normalization(Wx_plus_b, mean, var, shift, scale, epsilon)

           

           # Wx_plus_b = (Wx_plus_b - fc_mean) / tf.sqrt(fc_var + 0.001)  #进行BN一下

           # Wx_plus_b = Wx_plus_b * scale + shift

 

       # activation

       if activation_function is None:

           outputs = Wx_plus_b

       else:

           outputs = activation_function(Wx_plus_b)

       return outputs  #输出激活结果

   fix_seed(1)

   if norm:

       # BN for the first input

       fc_mean, fc_var = tf.nn.moments(

           xs,

           axes=[0],

       )

       scale = tf.Variable(tf.ones([1]))

       shift = tf.Variable(tf.zeros([1]))

       epsilon = 0.001

       # apply moving average for mean and var when train on batch

       ema = tf.train.ExponentialMovingAverage(decay=0.5)

       def mean_var_with_update():

           ema_apply_op = ema.apply([fc_mean, fc_var])

           with tf.control_dependencies([ema_apply_op]):

               return tf.identity(fc_mean), tf.identity(fc_var)

       mean, var = mean_var_with_update()

       xs = tf.nn.batch_normalization(xs, mean, var, shift, scale, epsilon)

   # record inputs for every layer

   layers_inputs = [xs]

   # build hidden layers

   for l_n in range(N_LAYERS):

       layer_input = layers_inputs[l_n]

       in_size = layers_inputs[l_n].get_shape()[1].value

       output = add_layer(

           layer_input,    # input

           in_size,        # input size

           N_HIDDEN_UNITS, # output size

           ACTIVATION,     # activation function

           norm,           # normalize before activation

       )

       layers_inputs.append(output)  

   # build output layer

   prediction = add_layer(layers_inputs[-1], 30, 1, activation_function=None)

   cost = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction), reduction_indices=[1]))

   train_op = tf.train.GradientDescentOptimizer(0.001).minimize(cost)

   return [train_op, cost, layers_inputs]

fix_seed(1)

x_data = np.linspace(-7, 10, 2500)[:, np.newaxis]  #水平轴-7~10

np.random.shuffle(x_data)

noise = np.random.normal(0, 8, x_data.shape)

y_data = np.square(x_data) - 5 + noise

xs = tf.placeholder(tf.float32, [None, 1])  # [num_samples, num_features]

ys = tf.placeholder(tf.float32, [None, 1])

#建立两个神经网络作对比

train_op, cost, layers_inputs = built_net(xs, ys, norm=False)

train_op_norm, cost_norm, layers_inputs_norm = built_net(xs, ys, norm=True)

sess = tf.Session()

if int((tf.__version__).split('.')[1]) < 12 and int((tf.__version__).split('.')[0]) < 1:

   init = tf.initialize_all_variables()

else:

   init = tf.global_variables_initializer()

sess.run(init)

# record cost

cost_his = []      

cost_his_norm = []  

record_step = 5    

plt.ion()

plt.figure(figsize=(7, 3))

for i in range(250):

   if i % 50 == 0:

       # plot histogram

       all_inputs, all_inputs_norm = sess.run([layers_inputs, layers_inputs_norm], feed_dict={xs: x_data, ys: y_data})

       plot_his(all_inputs, all_inputs_norm)

   # train on batch每一步都run一下

   sess.run([train_op, train_op_norm], feed_dict={xs: x_data[i*10:i*10+10], ys: y_data[i*10:i*10+10]})

   if i % record_step == 0:

       # record cost

       cost_his.append(sess.run(cost, feed_dict={xs: x_data, ys: y_data}))

       cost_his_norm.append(sess.run(cost_norm, feed_dict={xs: x_data, ys: y_data}))

#以下是绘制误差值Cost误差曲线的方法

plt.ioff()

plt.figure()

plt.title('Matplotlib,BN,Error_curve--Jason Niu')

plt.plot(np.arange(len(cost_his))*record_step, np.array(cost_his), label='no BN')     # no norm

plt.plot(np.arange(len(cost_his))*record_step, np.array(cost_his_norm), label='BN')   # norm

plt.legend()

plt.show()


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Geospatial
Geospatial是Redis在3.2版本以后增加的地理位置GEO模块,这个模块可以用来实现微信附近的人,在线点餐“附近的餐馆”等位置功能。
4 0
令牌桶限流
令牌桶算法比较简单,它就好比摇号买房,拿到号的人才有资格买,没拿到号的就只能等下次了(还好小编不需摇号,因为买不起!)。
4 0
跳跃列表
Skip List(跳跃列表)这种随机的数据结构,可以看做是一个二叉树的变种,它在性能上与红黑树、AVL树很相近;但是Skip List(跳跃列表)的实现相比前两者要简单很多,目前Redis的zset实现采用了Skip List(跳跃列表)(其它还有LevelDB等也使用了跳跃列表)。
5 0
滑动窗口限流
滑动窗口限流
5 0
当随机采样遇见插值,微软亚研提出节省推理计算量的新范式
同一张图像的不同区域空间冗余度是不一样的,背景部分的冗余度往往低于人物区域。如何利用这种特性来节省模型推理的计算量呢?在一篇 ECCV 2020 Oral 论文中,来自微软亚洲研究院等机构的研究者提出了一种随机采样与插值相结合的新方法,可以有效降低节省推理的计算量。
4 0
布隆(Bloom Filter)过滤器
布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多,缺点是有一定的误识别率和删除困难。
4 0
HyperLogLog
HyperLogLog是用来做基数统计的算法,它提供不精确的去重计数方案(这个不精确并不是非常不精确),标准误差是0.81%,对于UV这种统计来说这样的误差范围是被允许的。HyperLogLog的优点在于,输入元素的数量或者体积非常大时,基数计算的存储空间是固定的。在Redis中,每个HyperLogLog键只需要花费12KB内存,就可以计算接近2^64个不同的基数。
4 0
LFU(Least Frequently Used)
LRU有一个明显的缺点,它无法正确的表示一个Key的热度,如果一个key从未被访问过,仅仅发生内存淘汰的前一会儿被用户访问了一下,在LRU算法中这会被认为是一个热key。
5 0
Redis持久化
Redis的非常快,很大一部分原因是因为Redis的数据存储在内存中,既然在内存中,那么当服务器宕机或者断电的时候,数据就会全部丢失了,所以Redis提供了两种机制来保证Redis数据不会因为故障而全部丢失,这种机制称为Redis的持久化机制。
4 0
LRU(Least Recently Used)
Redis是基于内存存储的key-value数据库,我们知道内存虽然快但空间小,当物理内存达到上限时,系统就会跑的很慢,这是因为swap机制会将部分内存的数据转移到swap分区中,通过与swap的交换保证系统继续运行;但是swap属于硬盘存储,速度远远比不上内存,尤其是对于Redis这种QPS非常高的服务,发生这种情况是无法接收的。(注意如果swap分区内存也满了,系统就会发生错误!)
5 0
+关注
一个处女座的程序猿
国内互联网圈知名博主、人工智能领域优秀创作者,全球最大中文IT社区博客专家、CSDN开发者联盟生态成员、中国开源社区专家、华为云社区专家、51CTO社区专家、Python社区专家等,曾受邀采访和评审十多次。仅在国内的CSDN平台,博客文章浏览量超过2500万,拥有超过57万的粉丝。
1701
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载