精华内容
下载资源
问答
  • tf.nn.moments 计算返回的 mean 和 variance 作为 tf.nn.batch_normalization 参数调用 计算每个列的均值及方差。 import tensorflow as tf W = tf.constant([[-2.,12.,6.],[3.,2.,8.]], ) mean,var = tf....

     

     

    批标准化

    • 批标准化(batch normalization,BN)一般用在激活函数之前,使结果x=Wx+b 各个维度均值为0,方差为1。通过规范化让激活函数分布在线性区间,让每一层的输入有一个稳定的分布会有利于网络的训练。
    • 优点:
      加大探索步长,加快收敛速度。
      更容易跳出局部极小。
      破坏原来的数据分布,一定程度上防止过拟合。
      解决收敛速度慢和梯度爆炸。

    方法一: 

    tensorflow相应API

    • mean, variance = tf.nn.moments(x, axes, name=None, keep_dims=False)

      • 计算统计矩,mean 是一阶矩即均值,variance 则是二阶中心矩即方差,axes=[0]表示按列计算;
      • 对于以feature map 为维度的全局归一化,若feature map 的shape 为[batch, height, width, depth],则将axes赋值为[0, 1, 2]
    • tf.nn.batch_normalization(x, mean, variance, offset, scale, variance_epsilon, name=None)

      • tf.nn.batch_norm_with_global_normalization(x, mean, variance, beta, gamma, variance_epsilon, scale_after_normalization, name=None);
      • tf.nn.moments 计算返回的 mean 和 variance 作为 tf.nn.batch_normalization 参数调用

    计算每个列的均值及方差。

    import tensorflow as tf
    W = tf.constant([[-2.,12.,6.],[3.,2.,8.]], )
    mean,var = tf.nn.moments(W, axes = [0])
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        resultMean = sess.run(mean)
        print(resultMean)
        resultVar = sess.run(var)
        print(resultVar)
    #输出
    [ 0.5      7.    7.  ]
    [ 6.25   25.     1.  ]
    
    

    标准化

    size = 3
    scale = tf.Variable(tf.ones([size]))
    shift = tf.Variable(tf.zeros([size]))
    epsilon = 0.001
    W = tf.nn.batch_normalization(W, mean, var, shift, scale, epsilon)
    #参考下图BN的公式,相当于进行如下计算
    #W = (W - mean) / tf.sqrt(var + 0.001)
    #W = W * scale + shift
    
    with tf.Session() as sess:
        #必须要加这句不然执行多次sess会报错
        sess.run(tf.global_variables_initializer())
        resultW = sess.run(W)
        print(resultW)
    #观察初始W第二列 12>2 返回BN的W值第二列第二行是负的,其余两列相反
    
    #输出
    [[-0.99992001  0.99997997 -0.99950027]
     [ 0.99991995 -0.99997997  0.99950027]]

     

    方法二(批量归一化的简单用法)

    上面的函数虽然参数不多,但是需要几个函数联合起来使用,于是TensorFlow中的layers模块里又实现了一次BN函数,相当于把几个函数合并到了一起,使用起来更加简单。下面来介绍一下,使用时需要引入:

    from tensorflow.contrib.layers.python.layers import batch_norm

    或者直接调用tf.contrib.layers.batch_norm(),该函数的定义如下:

    def batch_norm(inputs,
                   decay=0.999,
                   center=True,
                   scale=False,
                   epsilon=0.001,
                   activation_fn=None,
                   param_initializers=None,
                   param_regularizers=None,
                   updates_collections=ops.GraphKeys.UPDATE_OPS,
                   is_training=True,
                   reuse=None,
                   variables_collections=None,
                   outputs_collections=None,
                   trainable=True,
                   batch_weights=None,
                   fused=False,
                   data_format=DATA_FORMAT_NHWC,
                   zero_debias_moving_mean=False,
                   scope=None,
                   renorm=False,
                   renorm_clipping=None,
                   renorm_decay=0.99):

    tf.contrib.layers.batch_norm()函数的具体详细使用教程链接https://www.cnblogs.com/zyly/p/8996070.html 

     

     

     

    reference:

    BN作用https://blog.csdn.net/buddhistmonk/article/details/79769928

    展开全文
  • def moments( x, axes, shift=None, # pylint: disable=unused-argument name=None, keep_dims=False) 函数用来计算均值和方差,计算得出的均值和方差 可为batch_nomalization 所用。 参数: x: 输入tensor, ...

    函数原型:

    def moments(
        x,
        axes,
        shift=None,  # pylint: disable=unused-argument
        name=None,
        keep_dims=False)
    

    函数用来计算均值和方差,计算得出的均值和方差 可为batch_nomalization 所用。

    参数:

    • x: 输入tensor, 四维:[batch_size, height, width, channel]
    • axes: 在指定的维度求均值和方差,这里一般要求指定3个维度, 如 [1,2,3],这也是为啥这里用复数axes 而不是 axis
    • keep_dims: 是否保持维度

    举例:

    import tensorflow as tf
    
    # [batch, channel, hight, width] =[2, 2, 2, 2]
    input = [[[[1, 2],
               [2, 1]],
              [[3, 4],
               [4, 3]]],
             [[[5, 6],
               [6, 5]],
              [[7, 8],
               [8, 7]]
             ]]
    
    input_tf = tf.constant(input, dtype=tf.float32)
    input_tf = tf.transpose(input_tf, perm=(0, 2, 3, 1))
    output = tf.nn.moments(input_tf, [0, 1, 2])
    
    with tf.Session() as sess:
        mean, var = sess.run(output)
        print('mean:', mean)
        print('variance:', var)
    
    
    
    
    # 输出为:
    # mean: [3.5 5.5]
    # variance: [4.25 4.25]
    

    input 是一个[2, 2, 2, 2]的输入,形为[batch, channel, hight, width]
    先把维度顺序转换为[batch, channel, hight, width] --> [batch, hight, width, channel]
    然后在指定的维度 axes=[0, 1, 2], 也就是 [batch, hight, width] 上求均值和方差

    这里可以理解为: 对batch中所有图片的每个channel 求均值和方差。 比如,所有图片的第一个channel求均值和方差,再对第二个channel求均值和方差, 以此类推。结果的均值列表 和 方差的列表 长度都等于channel的个数。

    以上面例子:

    第一张图片的第一个channel为:
    [[1, 2],
    [2, 1]]

    第一张图片的第二个channel为:
    [[3, 4],
    [4, 3]]

    第二张图片的第一个channel为:
    [[5, 6],
    [6, 5]]

    第二张图片的第二个channel为:
    [[7, 8],
    [8, 7]]

    所以,
    第一个channel的均值为:
    ( 1 + 2 + 1 + 2 + 5 + 6 + 6 + 5 ) / 8 = 3.5 (1 + 2 + 1 + 2 + 5 + 6 + 6 + 5) / 8 = 3.5 (1+2+1+2+5+6+6+5)/8=3.5

    第一个channel的均值为:
    ( 3 + 4 + 4 + 3 + 7 + 8 + 8 + 7 ) / 8 = 5.5 (3 + 4 + 4 + 3 + 7 + 8 + 8 + 7) / 8 = 5.5 (3+4+4+3+7+8+8+7)/8=5.5

    第一个channel的方差为:
    [ ( 1 − 3.5 ) 2 + ( 2 − 3.5 ) 2 + ( 2 − 3.5 ) 2 + ( 1 − 3.5 ) 2 + ( 5 − 3.5 ) 2 + ( 6 − 3.5 ) 2 + ( 6 − 3.5 ) 2 + ( 5 − 3.5 ) 2 ] / 8 = 4.25 [(1 - 3.5)^2+ (2 - 3.5)^2 + (2 - 3.5)^2 + (1 - 3.5)^2 + (5- 3.5)^2 + (6- 3.5)^2 + (6- 3.5)^2 + (5- 3.5)^2] / 8 = 4.25 [(13.5)2+(23.5)2+(23.5)2+(13.5)2+(53.5)2+(63.5)2+(63.5)2+(53.5)2]/8=4.25

    第一个channel的方差为:
    [ ( 3 − 4.5 ) 2 + ( 4 − 4.5 ) 2 + ( 4 − 4.5 ) 2 + ( 3 − 4.5 ) 2 + ( 7 − 4.5 ) 2 + ( 8 − 4.5 ) 2 + ( 8 − 4.5 ) 2 + ( 7 − 4.5 ) 2 ] / 8 = 4.25 [(3 - 4.5)^2+ (4 - 4.5)^2 + (4 - 4.5)^2 + (3 - 4.5)^2 + (7- 4.5)^2 + (8- 4.5)^2 + (8- 4.5)^2 + (7- 4.5)^2] / 8 = 4.25 [(34.5)2+(44.5)2+(44.5)2+(34.5)2+(74.5)2+(84.5)2+(84.5)2+(74.5)2]/8=4.25

    展开全文
  • tf.nn.moments()函数解析(最清晰的解释)

    万次阅读 多人点赞 2019-03-29 20:49:56
    这两天在看batch normalization的代码时碰到了这个tf.nn.moments()函数,特此记录。 # 用于在指定维度计算均值与方差 tf.nn.moments( x, axes, shift=None, # pylint: disable=unused-argument name=None, keep...

    欢迎关注WX公众号:【程序员管小亮】

    这两天在看batch normalization的代码时碰到了这个tf.nn.moments()函数,特此记录。

    tf.nn.moments()函数用于计算均值和方差。

    # 用于在指定维度计算均值与方差
    tf.nn.moments(
        x,
        axes,
        shift=None,	# pylint: disable=unused-argument
        name=None,
        keep_dims=False)
    

    参数:

    • x:一个Tensor,可以理解为我们输出的数据,形如 [batchsize, height, width, kernels]。

    • axes:整数数组,用于指定计算均值和方差的轴。如果x是1-D向量且axes=[0] 那么该函数就是计算整个向量的均值与方差。

    • shift:未在当前实现中使用。

    • name:用于计算moment的操作范围的名称。

    • keep_dims:产生与输入具有相同维度的moment,通俗点说就是是否保持维度。

    返回:

    Two Tensor objects: mean and variance.

    两个Tensor对象:mean和variance.

    解释如下:

    • mean 就是均值
    • variance 就是方差

    例子1:

    计算3 * 3维向量的mean和variance,程序如下:

    import tensorflow as tf
    
    img = tf.Variable(tf.random_normal([3, 3]))
    axis = list(range(len(img.get_shape()) - 1))
    mean, variance = tf.nn.moments(img, axis)
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        print(sess.run(img))
        print(axis)
        resultMean = sess.run(mean)
        print('resultMean',resultMean)
        resultVar = sess.run(variance)
        print('resultVar',resultVar)
    
    > [[ 0.9398157   1.1222504  -0.6046098 ]
       [ 1.4187386  -0.298682    1.033441  ]
       [ 0.64805275  0.40496045  1.4371132 ]]
    > [0]
    > resultMean [1.0022024  0.40950966 0.62198144]
    > resultVar [0.10093883 0.33651853 0.77942157]
    

    根据上面的代码,很容易可以看出axis=[0],那么tf.moments()函数就是在 [0] 维度上求了个均值和方差。

    而针对3 * 3的矩阵,其实可以这么理解,当axis=[0]时,那么我们3 * 3的矩阵就可以看成三个长度为3的一维向量,然后就是三个向量的均值和方差计算,也就是对应三个向量的对应第一个数进行一次计算,对应第二个数进行一次计算,对应第三个数进行一次计算,这么说的就非常的通俗了。这是一个非常简单的例子,如果换做形如

    例子2:

    计算卷积神经网络某层的的mean和variance,程序如下:

    import tensorflow as tf
    
    img = tf.Variable(tf.random_normal([128, 32, 32, 64]))
    axis = list(range(len(img.get_shape()) - 1))
    mean, variance = tf.nn.moments(img, axis)
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
    #     print(sess.run(img))
        print(axis)
        resultMean = sess.run(mean)
        print('resultMean',resultMean)
        resultVar = sess.run(variance)
        print('resultVar',resultVar)
    

    形如[128, 32, 32, 64]的数据在CNN的中间层非常常见,为了给出一个直观的认识,函数的输出结果如下,可能输出的数字比较多。

    > [0, 1, 2]
    > resultMean [ 2.6853075e-03 -3.0257576e-03  2.3035323e-03 -2.6062224e-03
     			  -3.2305701e-03  2.1037455e-03  6.7329779e-03 -2.2388114e-04
      			   2.6253066e-03 -6.7248638e-03  2.3191441e-04 -5.8187090e-04
    			  -9.0473756e-04 -1.6551851e-03 -1.1362392e-03 -1.9381186e-03
    			  -1.2468656e-03 -3.5813404e-03  7.0505054e-04  5.0926261e-04
    			  -3.4001360e-03 -2.2198933e-03 -1.8291552e-04 -2.9487342e-03
    			   2.8003550e-03  2.0361040e-03  7.5038348e-04  1.1216532e-03
    			   1.1721103e-03  4.0136781e-03 -1.3581098e-03 -1.9081675e-03
    			  -5.7506924e-03  1.4085017e-04  9.2261989e-04  3.6248637e-03
    			  -3.4064866e-04 -1.7123687e-03  2.8599303e-03  3.3247408e-03
    			  -3.0919732e-04 -2.5428729e-03 -1.8558424e-03  6.8022363e-04
    			  -2.3567205e-04  2.0230825e-03 -5.6563923e-03 -4.9449857e-03
    			  -1.5591505e-03  5.4281385e-04  3.4175792e-03  3.4342592e-03
    			  -2.2981209e-03 -1.1064336e-03 -2.4347606e-03 -8.7688277e-03
    			   4.2153443e-03  1.8990067e-03 -1.7339690e-03 -4.1099632e-04
      			   2.9905797e-05 -2.2589187e-03  1.3317640e-03 -1.0637580e-03]
    > resultVar [0.99827653 0.99892205 1.0023996  1.0008711  1.0027382  1.0062183
    		 	 1.0062574  0.9907291  1.0007423  1.0074934  0.9987777  0.99734586
    			 0.99948376 0.9996146  0.9981512  0.9992911  1.0065222  0.9959912
    			 0.99847895 0.9947184  1.0043     1.004565   0.9955365  1.0063928
    			 0.9991787  0.99631685 1.0008278  1.0084031  1.0019135  1.0009897
    			 1.0022242  1.0076597  1.0040829  0.9944737  1.0008909  0.9962167
    			 1.002177   1.0043476  1.0003107  1.0018493  1.0021918  1.0038664
    			 0.9958006  0.99403363 1.0066489  1.001033   0.9994988  0.9943808
    			 0.9973529  0.9969688  1.0023019  1.004277   1.0000937  1.0009365
    			 1.0067816  1.0005956  0.9942864  1.0030564  0.99745005 0.9908926
    			 1.0037254  0.9974016  0.99849343 1.0066065 ]
    

    对于 [128, 32, 32, 64] 这样的4维矩阵来说,一个batch里的128个图,经过一个64kernels卷积层处理,得到了128 * 64个图,再针对每一个kernel所对应的128个图,求它们所有像素的mean和variance,因为总共有64个kernels,输出的结果就是一个一维长度64的数组。
    在这里插入图片描述

    python课程推荐。
    在这里插入图片描述

    参考文章:

    谈谈Tensorflow的Batch Normalization

    展开全文
  • 先来看个例子吧。 测试代码: x = np.arange(12,dtype=np.float32).reshape(3,4) a = tf.nn.moments(tf.constant(x),[0]) b = tf.nn.moments(tf.constant(x),[1]) ...c = tf.nn.moments(tf.con.

    先来看个例子吧。

    测试代码:

    x = np.arange(12,dtype=np.float32).reshape(3,4)
    a = tf.nn.moments(tf.constant(x),[0])
    b = tf.nn.moments(tf.constant(x),[1])
    # 相当于展开[0,1]维度, 在所有数上计算均值和方差,等于x.mean(),x.var()
    c = tf.nn.moments(tf.constant(x),[0,1])
    d = tf.nn.moments(tf.constant(x),None) # 同上
    e = tf.nn.moments(tf.constant(x),[]) # 在实数上(0维tensor上)计算 
    print(0, x,x.mean(),x.var())
    with tf.Session() as sess:
        print(1, sess.run(a))
        print(2, sess.run(b))
        print(3, sess.run(c))
        print(4, sess.run(c)==sess.run(d),)
        print(5, sess.run(e))
    

    执行结果:

    0 [[ 0.  1.  2.  3.]
     [ 4.  5.  6.  7.]
     [ 8.  9. 10. 11.]] 5.5 11.916667
    1 (array([4., 5., 6., 7.], dtype=float32), array([10.666667, 10.666667, 10.666667, 10.666667], dtype=float32))
    2 (array([1.5, 5.5, 9.5], dtype=float32), array([1.25, 1.25, 1.25], dtype=float32))
    3 (5.5, 11.916667)
    4 True
    5 (array([[ 0.,  1.,  2.,  3.],
           [ 4.,  5.,  6.,  7.],
           [ 8.,  9., 10., 11.]], dtype=float32), array([[0., 0., 0., 0.],
           [0., 0., 0., 0.],
           [0., 0., 0., 0.]], dtype=float32))
    

      再来看看具体原理解析。

      最近在看batchnorm函数的时候,看到了tf.nn.moments( )函数,查看了相关文章,有了一些理解,主要是是对axes参数的理解。

      首先看到函数的定义:

      def moments(
          x,
          axes,
          shift=None,  # pylint: disable=unused-argument
          name=None,
          keep_dims=False):
      
       

        参数:
        x:一个tensor张量,即我们的输入数据
        axes:一个int型数组,它用来指定我们计算均值和方差的轴(这里不好理解,可以结合下面的例子)
        shift:当前实现中并没有用到
        name:用作计算moment操作的名称
        keep_dims:输出和输入是否保持相同的维度

        返回:
        两个tensor张量:均值和方差

        1.对axes参数的理解

        (axes是axis的复数形式,意思是轴)
        这个当我们使用tensorflow,keras等框架时很常见,用来表示我们在那个轴进行计算,通常当我们需要计算的是一个二维矩阵的数据的时候,是比较好理解,可以通过“按行计算”或“按列计算”来理解,但是在卷积神经网络CNN中,我们通常处理的是4维的,例如[128,32,32,8]。

        这里通过几个例子来理解一下:

        1.1当输入的维度=[3,3],axes=[0]时

        理解:当输入的维度=[3,3]axes=[0]时, 我们是在第0维度上进行计算均值和方差的,也就是把0之后的维度作为一个整体。
        看例子:

        import tensorflow as tf
        input_x = np.random.randn(3,3)
        print("input_x: "+str(input_x))
        x = tf.placeholder(tf.float32, [None,3])
        axis = list(range(len(x.get_shape())-1))
        print("axis: "+str(axis))
        mean, var = tf.nn.moments(x, axis)
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            print("均值:" + str(sess.run(mean, feed_dict={x:input_x})))
            print("方差:" + str(sess.run(mean, feed_dict={x: input_x})))
        
         

          输出结果:

          input_x: [[-1.50319888 -1.05945651 -0.61838205]
           [-2.25241293 -0.30277139  0.85060157]
           [-1.58252382 -0.66426399  0.48765805]]
          axis: [0]
          均值:[-1.7793785 -0.6754973  0.2399592]
          方差:[0.11292955 0.0954918  0.39032948]
          
           

            通过“人工计算”来理解上面的:输入是二维数组,参数axes=[0],按照我们的理解,是在第0维度上(二维也就是“行”)计算的,我们这里计算一下均值的第一个数来验证一下:(-1.50319888-2.25241293-1.58252382)/3=-1.77937854,可以看到结果是没错的,有时间也可以去验证一下其他的。

            1.1当输入的维度=[2,2,2,3],axes=[0,1,2]时

            在卷积神经网络中我们通常是四维的,这里为了后面好验证,我们每个维度比较小。
            例子:

            input_x = np.random.randn(2,2,2,3)
            print("input_x: "+str(input_x))
            x = tf.placeholder(tf.float32, [None,2,2,3])
            axis = list(range(len(x.get_shape())-1))
            print("axis: "+str(axis))
            mean, var = tf.nn.moments(x, axis)
            with tf.Session() as sess:
                sess.run(tf.global_variables_initializer())
                print("均值:" + str(sess.run(mean, feed_dict={x:input_x})))
                print("方差:" + str(sess.run(var, feed_dict={x: input_x})))
            
             

              输出:

              input_x: [[[[-0.01217182 -0.57956742 -1.51674327]
                 [-0.70532721 -0.78963661 -0.10783073]]
                [[-1.09448815 -0.61574064 -0.82319978]
                 [-1.07687148  1.22917172 -0.14001623]]]
               [[[-1.13214309  0.2310679  -0.18868495]
                 [-0.38519615 -0.07045672 -0.88649796]]
                [[-1.22102837  0.32518845 -0.02877724]
                 [ 0.87842328  0.64151107  1.17883896]]]]
              axis: [0, 1, 2]
              均值:[-0.5936004   0.04644222 -0.31411394]
              方差:[0.46612024 0.4259762  0.5540037 ]
              
               

                同样这里我们通过“人工计算”验证我们的理解,这里我们的输入维度是[2,2,2,3],axes=[0,1,2]表示我们在(0,1,2)上进行计算,即把第3维度当做一个整体,我们还是取均值的第一个验证:(-0.01217182-0.70532721-1.09448815-1.07687148-1.13214309-0.38519615-1.22102837+0.87842328)/8=-0.5936004。

                这里引用一下网上的总结:
                就是将x上除去axes所指定的纬度的剩余纬度组成的各个子元素看做个体,个体中的每个位置的值看做个体的不同位置属性,然后求所有个体在每种位置属性上的均值和方差。

                2.补充

                为什么卷积网络中batchnorm中计算均值和方差,参数在axes=[0,1,2]?

                卷积网络中batchnorm中计算均值和方差也就是在axes=[0,1,2]上面进行计算,的即我们把第3维度当做一个整体,我们算上了2x2x2这么多个值来计算,第一个2是样本数,后面两个2分别表示图像的宽度和高度,在几何意义上面理解就是我们在做归一化计算每一个通道上面的均值和方差时,需要涉及到样本的肯定是需要包括样本数的,其次归一化就是让数据的分布呈标准正态分布,所以我们需要对每个通道上面的数据2x2也要加入到计算。

                怎么理解上面这段话呢?为了简单我们考虑一个样本的情况,例如我们看到下面1x32x32x3的例子,当我们进行batchnorm的时候如何计算均值和方差?
                例如现在我对计算通道a上面的某一点进行归一化,此时均值和方差计算就是通过通道a上所有点的均值(加起来除以32x32),方差同理。当样本数不为1时等于64时,就是把所有样本通道a上面的点加起来进行计算(64x32x32个),然后在进行归一化的时候,每个通道上面的点就用该通道计算得来的均值和方差进行归一化。
                在这里插入图片描述

                参考文章:

                https://blog.csdn.net/qq_36231549/article/details/101016937
                https://blog.csdn.net/CarryLvan/article/details/103585913

                展开全文
              • 这两天在看batch normalization的代码时碰到了这个tf.nn.moments()函数,特此记录。 tf.nn.moments()函数用于计算均值和方差。 # 用于在指定维度计算均值与方差 tf . nn . moments ( x , axes , shift = ...
              • tf.nn.moments函数中参数的理解1.对axes参数的理解1.1当输入的维度=[3,3],axes=[0]时1.1当输入的维度=[2,2,2,3],axes=[0,1,2]时2.补充 最近在看batchnorm函数的时候,看到了tf.nn.moments( )函数,查看了相关文章...
              • tensorflow 在实现 Batch Normalization(各个网络层输出的归一化)时,主要用到以下两个 api: tf.nn.moments(x, axes, name=None, keep_dims=False) ⇒ mean, variance:
              • tf.nn.moments()的使用

                千次阅读 2019-06-18 20:40:23
                tf.nn.moments()是用于计算均值和方差。 参数(x, axes, shift=None, name=None, keep_dim=False) x: 输入 axes: 需要进行求均值/方差的维度,以列表的形式表示,如[0,1,2]表示求第0,1,2三个维度的均值/方差。 ...
              • Tensorflow—tf.nn.moments( )函数中参数的理解 转载:https://blog.csdn.net/CarryLvan/article/details/103585913
              • x = np.arange(12,dtype=np....a = tf.nn.moments(tf.constant(x),[0]) b = tf.nn.moments(tf.constant(x),[1]) # 相当于展开[0,1]维度, 在所有数上计算均值和方差 c = tf.nn.moments(tf.constant(x),[0,1]) d = tf....
              • Tensorflow的tf.nn.moments函数

                千次阅读 2018-12-31 21:20:36
                tf.nn.moments函数 1.官方的输入定义如下:  def moments(x, axes, name=None, keep_dims=False) x理解为输出数据,形如[batchsize,height,width,kernels] axes表示在哪个维度上求解,是个list,例如[0,1,2] ...
              • tf.nn.moments( ) 的用法

                万次阅读 2019-01-21 20:07:36
                def moments( x, axes, shift=None, # pylint: disable=unused-argument name=None, keep_dims=False) x: 形如:[batch_size, height, width, kernels] axes: 求解的维度,如 [1,2,3] keep_dims: 是否保...
              • tf.nn.moments 计算返回的 mean 和 variance 作为 tf.nn.batch_normalization 调用参数;    import tensorflow as tf W = tf.constant([[-2.,12.,6.],[3.,2.,8.]], ) mean,var = tf.nn.moments(W, ...
              • tf.nn.moments()函数理解

                千次阅读 2019-04-19 13:17:15
                def moments(x, axes, name=None, keep_dims=False) 解释如下: x 可以理解为我们输出的数据,形如 [batchsize, height, width, kernels] axes 表示在哪个维度上求解,是个list,例如 [0, 1, 2] name 就是个...
              • 2], [2, 1]], [[3, 4], [4, 3]]], [[[5, 6], [6, 5]], [[7, 8], [8, 7]] ]] input_tf = tf.constant(input, dtype=tf.float32) input_tf = tf.transpose(input_tf, perm=(0, 2, 3, 1)) mean, var = tf.nn.moments...
              • 一、环境 TensorFlow API r1.12 CUDA 9.2 V9.2.148 cudnn64_7.dll Python 3.6.3 ...https://tensorflow.google.cn/api_docs/python/tf/nn/moments 按照 axis 指定的轴计算输入张量 x 中的...
              • tf.nn.moments 计算返回的 mean 和 variance 作为 tf.nn.batch_normalization 参数调用; tensorflow及python实现 import tensorflow as tf W = tf.constant([[- 2. , 12. , 6. ],[ 3. , 2. , 8. ]], ) ...
              • 在使用tensorflow构建神经网络时,经常看到tf.nntf.layers,tf.contrib这三个模块,它们有很多函数的功能是相同的,部分可以混用,这就导致使用者很容易被迷惑,本文在此做一下笔记以理清思路。 tf.nn:用于原始...
              • TensorFlow tf.nn

                2019-08-02 19:50:14
                tf.nn库能提供神经网络相关操作的支持,包括卷积操作(conv)、池化操作(pooling)、归一化、loss、分类操作、embedding、RNN、Evaluation等,相对tf.layer更底层一些。** 1.激活函数Activation Functions 2....
              • 1. tf.nn.moments(x, axes=[0, 1, 2]) # 对前三个维度求平均值和标准差,结果为最后一个维度,即对每个feature_map求平均值和标准差 参数说明:x为输入的feature_map, axes=[0, 1, 2] 对三个维度求平均,即每一个...
              • tf.nn.batch_normalization()函数解析(最清晰的解释)

                万次阅读 多人点赞 2019-03-30 14:38:30
                这两天在看batch normalization的代码时碰到了这个tf.nn.moments()函数,特此记录。 # 用于最中执行batch normalization的函数 tf.nn.batch_normalization( x, mean, variance, offset, scale, variance_...
              • 批标准化 批标准化(batch normalization,BN)一般用在激活函数之前,使结果 x = W x + b x=Wx+b  各个维度均值为0,方差为1...tensorflow 的 Batch Normalization 实现(tf.nn.momentstf.nn.batch_normalization)
              • 使用tf.nn.batch_normalization函数实现Batch Normalization操作 觉得有用的话,欢迎一起讨论相互学习~Follow Me 参考文献 吴恩达deeplearningai课程 课程笔记 Udacity课程 """ ...
              • TensorFlow(七)tf.nn

                万次阅读 多人点赞 2018-02-03 15:42:34
                tf.nntf.layers, tf.contrib模块有很多功能是重复的 下面是对三个模块的简述: tf.nn :提供神经网络相关操作的支持,包括卷积操作(conv)、池化操作(pooling)、归一化、loss、分类操作、embedding、RNN、...

              空空如也

              空空如也

              1 2 3 4 5 ... 20
              收藏数 1,092
              精华内容 436
              关键字:

              tf.nn.moments