TensorFlow2.0:误差计算

最新推荐文章于 2021-01-09 01:35:16 发布

梅文化_2019

最新推荐文章于 2021-01-09 01:35:16 发布

阅读量937

点赞数

分类专栏： tensorflow2.0

本文链接：https://blog.csdn.net/meijie2018_1/article/details/99828829

版权

tensorflow2.0 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

一 MSE(Mean Square Error)均方误差

**
在这里插入图片描述

In [2]: out = tf.random.normal([5,4])                                                             

In [3]: y = tf.constant([1,2,3,0,2])                                                              

In [4]: y = tf.one_hot(y,depth=4)                                                                 

In [5]: y                                                                                         
Out[5]: 
<tf.Tensor: id=10, shape=(5, 4), dtype=float32, numpy=
array([[0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.],
       [1., 0., 0., 0.],
       [0., 0., 1., 0.]], dtype=float32)>

In [6]: loss1 = tf.reduce_mean(tf.square(y-out))                                                  

In [7]: loss2 = tf.square(tf.norm(y-out))/(5*4)                                                   

In [8]: loss3 = tf.reduce_mean(tf.losses.MSE(y,out))                                              

In [9]: loss1,loss2,loss3                                                                         
Out[9]: 
(<tf.Tensor: id=15, shape=(), dtype=float32, numpy=0.8161726>,
 <tf.Tensor: id=24, shape=(), dtype=float32, numpy=0.8161727>,
 <tf.Tensor: id=29, shape=(), dtype=float32, numpy=0.8161725>)

二 Cross Entropy交叉熵

**
熵指的是某个独立分布的信息量衡量标准.
熵越小,不确定因素越多,信息量也越大.
熵越大,分布越稳定.
在这里插入图片描述

In [10]: a = tf.fill([4],0.25)#使用一个稳定的分布对熵进行计算                                                                                                                                               

In [11]: -tf.reduce_sum(a*tf.math.log(a)/tf.math.log(2.))                                                                                                                                                   
Out[11]: <tf.Tensor: id=43, shape=(), dtype=float32, numpy=2.0>

In [12]: a = tf.constant([0.1,0.1,0.1,0.7])#使用一个不太稳定的分布计算熵                                                                                                                                    

In [13]: -tf.reduce_sum(a*tf.math.log(a)/tf.math.log(2.))                                                                                                                                                   
Out[13]: <tf.Tensor: id=53, shape=(), dtype=float32, numpy=1.3567797>

In [14]: a = tf.constant([0.01,0.01,0.01,0.97])#使用一个特别不稳定的分布计算熵                                                                                                                              

In [15]: -tf.reduce_sum(a*tf.math.log(a)/tf.math.log(2.))                                                                                                                                                   
Out[15]: <tf.Tensor: id=63, shape=(), dtype=float32, numpy=0.24194068>

交叉熵Cross Entropy指的是两个分布之间的信息分布标准.
在这里插入图片描述

在这里插入图片描述当p=q时,交叉熵最小.
即当交叉熵最小时,p与q概率分布最接近.

In [17]: y = tf.constant([0,1,0,0])                                                                                                                                                                         

In [18]: out = tf.constant([0.25,0.25,0.25,0.25])                                                                                                                                                           

In [19]: tf.losses.categorical_crossentropy(y,out)                                                                                                                                                          
Out[19]: <tf.Tensor: id=82, shape=(), dtype=float32, numpy=1.3862944>

In [20]: out = tf.constant([0.1,0.1,0.8,0.1])                                                                                                                                                               

In [21]: tf.losses.categorical_crossentropy(y,out)                                                                                                                                                          
Out[21]: <tf.Tensor: id=100, shape=(), dtype=float32, numpy=2.3978953>

In [22]: out = tf.constant([0.1,0.7,0.1,0.1])                                                                                                                                                               

In [23]: tf.losses.categorical_crossentropy(y,out)                                                                                                                                                          
Out[23]: <tf.Tensor: id=118, shape=(), dtype=float32, numpy=0.35667497>

In [24]: out = tf.constant([0.01,0.97,0.01,0.01])                                                                                                                                                           

In [25]: tf.losses.categorical_crossentropy(y,out)                                                                                                                                                          
Out[25]: <tf.Tensor: id=136, shape=(), dtype=float32, numpy=0.030459179>

In [27]: tf.losses.BinaryCrossentropy()([1],[0.1])                                                                                                                                                          
Out[27]: <tf.Tensor: id=173, shape=(), dtype=float32, numpy=2.3025842>

In [28]: tf.losses.binary_crossentropy([1],[0.1])                                                                                                                                                           
Out[28]: <tf.Tensor: id=200, shape=(), dtype=float32, numpy=2.3025842>