作者相关推荐

TensorFlow2_200729系列---14、MSE求梯度实例

一、总结

一句话总结：

tf.losses.MSE：loss = tf.reduce_mean(tf.losses.MSE(y, logits))

1、机器学习中的公式推导？

机器学习中，很多看似很复杂的公式的推导，就是非常普通的按照求导的规则来求导，比如求各种函数梯度

二、MSE求梯度实例

博客对应课程的视频位置：

import tensorflow as tf 


# 表示神经网络输入层3个节点
x=tf.random.normal([1,3])
# 表示是3个节点连两个节点
w=tf.ones([3,2])
# 表示是被连的两个节点
# 在这里也表示输出层是两个节点
b=tf.ones([2])
# 输出层为0和1
y = tf.constant([0, 1])


with tf.GradientTape() as tape:
    # watch要求梯度的参数w和b（这里w和b都是矩阵）
	tape.watch([w, b])
    # 用激活函数sigmoid
	logits = tf.sigmoid(x@w+b) 
    # 计算loss（计算预测值logits和真实值y的MSE）
	loss = tf.reduce_mean(tf.losses.MSE(y, logits))

# 计算梯度：对loss函数计算w和b对应的梯度
grads = tape.gradient(loss, [w, b])
print('w grad:', grads[0])
print('b grad:', grads[1])

w grad: tf.Tensor(
[[ 0.02753587 -0.05880144]
 [-0.03335685  0.07123186]
 [-0.11601511  0.24774435]], shape=(3, 2), dtype=float32)
b grad: tf.Tensor([ 0.06927714 -0.1479378 ], shape=(2,), dtype=float32)

2、详细分析过程（中间变量）

In [2]:

# 表示神经网络输入层3个节点
x=tf.random.normal([1,3])
x

Out[2]:

<tf.Tensor: shape=(1, 3), dtype=float32, numpy=array([[0.18152788, 0.19228849, 0.83497703]], dtype=float32)>

In [3]:

# 表示是3个节点连两个节点
w=tf.ones([3,2])
w

Out[3]:

<tf.Tensor: shape=(3, 2), dtype=float32, numpy=
array([[1., 1.],
       [1., 1.],
       [1., 1.]], dtype=float32)>

In [4]:

# 表示是被连的两个节点
# 在这里也表示输出层是两个节点
b=tf.ones([2])
# 输出层为0和1
y = tf.constant([0, 1])
y

Out[4]:

<tf.Tensor: shape=(2,), dtype=int32, numpy=array([0, 1])>

In [8]:

with tf.GradientTape() as tape:
    # watch要求梯度的参数w和b（这里w和b都是矩阵）
    tape.watch([w, b])
    print("========================x@w+b========================")
    print(x@w+b)
    # 用激活函数sigmoid
    logits = tf.sigmoid(x@w+b) 
    print("========================logits========================")
    print(logits)
    # 计算loss（计算预测值logits和真实值y的MSE）
    loss = tf.reduce_mean(tf.losses.MSE(y, logits))
    print("========================loss========================")
    print(loss)

# 计算梯度：对loss函数计算w和b对应的梯度
grads = tape.gradient(loss, [w, b])
print("========================grads========================")
print(grads)

========================x@w+b========================
tf.Tensor([[2.2087934 2.2087934]], shape=(1, 2), dtype=float32)
========================logits========================
tf.Tensor([[0.9010364 0.9010364]], shape=(1, 2), dtype=float32)
========================loss========================
tf.Tensor(0.4108302, shape=(), dtype=float32)
========================grads========================
[<tf.Tensor: shape=(3, 2), dtype=float32, numpy=
array([[ 0.0145849 , -0.00160191],
       [ 0.01544947, -0.00169686],
       [ 0.06708644, -0.00736831]], dtype=float32)>, <tf.Tensor: shape=(2,), dtype=float32, numpy=array([ 0.08034526, -0.00882457], dtype=float32)>]

In [9]:

print('w grad:', grads[0])
print('b grad:', grads[1])

w grad: tf.Tensor(
[[ 0.0145849  -0.00160191]
 [ 0.01544947 -0.00169686]
 [ 0.06708644 -0.00736831]], shape=(3, 2), dtype=float32)
b grad: tf.Tensor([ 0.08034526 -0.00882457], shape=(2,), dtype=float32)

3、softmax求多分类实例

In [14]:

import tensorflow as tf 


x=tf.random.normal([2,4])
w=tf.random.normal([4,3])
b=tf.zeros([3])
# 两次的预测结果分别是2和0
y = tf.constant([2, 0])
print(y)


with tf.GradientTape() as tape:
    tape.watch([w, b])
    prob = tf.nn.softmax(x@w+b,axis=1) 
    print(prob)
    loss = tf.reduce_mean(tf.losses.MSE(tf.one_hot(y,depth=3), prob))

grads = tape.gradient(loss, [w, b])
print('w grad:', grads[0])
print('b grad:', grads[1])

tf.Tensor([2 0], shape=(2,), dtype=int32)
tf.Tensor(
[[9.71989512e-01 1.00679705e-02 1.79424882e-02]
 [7.29947150e-01 2.69553602e-01 4.99337562e-04]], shape=(2, 3), dtype=float32)
w grad: tf.Tensor(
[[-0.05403889  0.07584023 -0.02180129]
 [ 0.01013849 -0.00606219 -0.00407629]
 [-0.03504124  0.02041196  0.01462925]
 [ 0.00705199  0.00788973 -0.01494168]], shape=(4, 3), dtype=float32)
b grad: tf.Tensor([-0.02092656  0.032325   -0.01139841], shape=(3,), dtype=float32)

计算结果数据：1和0

就是预测数据prob中最大的索引

In [ ]: