import tensorflow as tf

a = tf.constant([1,2,3,1,1])

b = tf.constant([0,1,3,4,5])

c = tf.where(tf.greater(a, b), a, b) # 若 a > b，返回 a 对应位置的元素，否则返回 b 对应位置的元素

print("c:", c)

运行结果：

c: tf.Tensor([1 2 3 4 5], shape=(5,), dtype=int32)

1.2 np.random.RandomState.rand()

1、作用

返回一个 [0, 1) 之间的随机数

2、语法

np.random.RandomState.rand(维度) # 维度为空，返回标量

3、代码

import numpy as np

rdm=np.random.RandomState(seed=1)  # seed=常数每次生成随机数相同
a=rdm.rand()  # 返回一个随机标量
b=rdm.rand(2, 3)  # 返回维度为2行3列随机数矩阵
print("a:", a)
print("b:", b)

运行结果：

a: 0.417022004702574
b: [[7.20324493e-01 1.14374817e-04 3.02332573e-01]
?[1.46755891e-01 9.23385948e-02 1.86260211e-01]]

1.3?np.vstack()

1、作用

将两个数组按垂直方向叠加

2、语法

np.vstack(数组1, 数组2)

3、代码

import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.vstack((a, b))
print("c:\n", c)

运行结果：

c:
?[[1 2 3]
?[4 5 6]]

1.4?np.mgrid[]、.ravel()、np.c_[]

1、np.mgrid[]

np.mgrid[ 起始值: 结束值: 步长, 起始值: 结束值: 步长, ... ]

2、x.ravel()

x.ravel() 将 x 变为一维数组，“ 把 . 前变量拉直”

3、np.c_[]

np.c_[] 使返回的间隔数值点配对

np.c_[ 数组1, 数组2, ... ]

4、代码

二、复杂度学习率

2.1 神经网络（NN）复杂度

1、NN 复杂度：多用 NN 层数和 NN 参数的个数表示

2.2 学习率

2.3 指数衰减学习率

可以先用较大的学习率，快速得到较优解，然后逐步减小学习率，使模型在训练后期稳定。

指数衰减学习率 = 初始学习率 * 学习率衰减率 (当前轮数 / 多少轮衰减次)?

import tensorflow as tf

w = tf.Variable(tf.constant(5, dtype=tf.float32))

epoch = 40
LR_BACE  = 0.2
LR_DECAY = 0.99
LR_STEP  = 1

for epoch in range(epoch):
    lr = LR_BACE * LR_DECAY ** (epoch / LR_STEP)
    with tf.GradientTape() as tape:
        loss = tf.square(w + 1)
    grads = tape.gradient(loss, w)
    
    w.assign_sub(lr * grads)
    print("After %s epoch, w is %f, loss is %f, lr is %f" % (epoch, w.numpy(), loss, lr))

三、激活函数

3.1 Sigmoid 函数

特点：

(1) 易造成梯度消失

(2) 输出非 0 均值，收敛慢

(3) 幂运算复杂，训练时间长

3.2 tanh 函数?

特点：

(1) 输出是 0 均值

(2) 易造成梯度消失

(3) 幂运算复杂，训练时间长

3.3 relu 函数

优点：

(1) 解决了梯度消失问题 (在正区间)

(2) 只需判断输入是否大于0，计算速度快

(3) 收敛速度远快于 sigmoid 和 tanh

缺点:

(1) 输出非 0 均值，收敛慢

(2) Dead RelU 问题：某些神经元可能永远不会被激活，导致相应的参数永远不能被更新

3.4 Leaky Relu 函数

理论上来讲，Leaky Relu 有 Relu 的所有优点，外加不会有 Dead Relu 问题，但是在实际操作当中，并没有完全证明 Leaky Relu 总是好于 Relu

3.5 总结

四、损失函数

4.1 均方误差

4.2 代码

1、简介

2、python代码

import tensorflow as tf
import numpy as np

SEED = 23455

rdm = np.random.RandomState(seed=SEED)  # 生成[0,1)之间的随机数

x = rdm.rand(32, 2)
print(x, "\n")

y_ = [[x1 + x2 + (rdm.rand() / 10.0 - 0.05)] for (x1, x2) in x]  
x = tf.cast(x, dtype=tf.float32)

print(x, "\n")
print(y_, "\n")


w1 = tf.Variable(tf.random.normal([2, 1], stddev=1, seed=1))

epoch = 20000
lr = 0.002

for epoch in range(epoch):
    with tf.GradientTape() as tape:
        y = tf.matmul(x, w1)
        loss_mse = tf.reduce_mean(tf.square(y_ - y))

    grads = tape.gradient(loss_mse, w1)
    w1.assign_sub(lr * grads)

    if epoch % 500 == 0:
        print("After %d training steps, w1 is " % (epoch))
        print(w1.numpy(), "\n")
        
print("Final w1 is: ", w1.numpy())

4.3 自定义损失函数

4.4 代码

1、简介

2、python 代码

import tensorflow as tf
import numpy as np

SEED = 23455
COST = 1
PROFIT = 99

rdm = np.random.RandomState(seed=SEED)  # 生成[0,1)之间的随机数

x = rdm.rand(32, 2)
print(x, "\n")

y_ = [[x1 + x2 + (rdm.rand() / 10.0 - 0.05)] for (x1, x2) in x]  
x = tf.cast(x, dtype=tf.float32)

print(x, "\n")
print(y_, "\n")


w1 = tf.Variable(tf.random.normal([2, 1], stddev=1, seed=1))

epoch = 20000
lr = 0.002

for epoch in range(epoch):
    with tf.GradientTape() as tape:
        y = tf.matmul(x, w1)
        loss_mse = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_) * COST, (y_ - y) * PROFIT))

    grads = tape.gradient(loss_mse, w1)
    w1.assign_sub(lr * grads)

    if epoch % 500 == 0:
        print("After %d training steps, w1 is " % (epoch))
        print(w1.numpy(), "\n")
        
print("Final w1 is: ", w1.numpy())