python线性回归实现波士顿房价预测(激活函数)

激活函数

激活函数的作用

生活中真实的例子很复杂，很难将所有的数据用直线来表示出来，实际上真实的数据更容易用曲线表示。所以引入了激活函数。

激活函数的分类

常用的激活函数有Sigmoid，relu，tanh，leaky_relu。

Sigmoid

$$Sigmoid(x)=\frac{1}{1+e^{-x}}$$
$$\frac{\partial Sigmoid(x)}{\partial x}=Sigmoid(x)\ast (1-Sigmoid(x))$$
$Sigmoid(x)$函数图像

$\frac{\partial Sigmoid}{\partial x}$函数图像

Sigmoid的优点是：

1. 能压缩数据，保证数据幅度不会有问题。
2. 便于求导的平滑函数。
3. 适合用于前向传播。

Sigmoid的缺点是：

1. 容易出现梯度消失（gradient vanishing）的现象。
2. Sigmoid 的 output 不是0均值，使得收敛缓慢。
3. 幂运算相对耗时。

Relu

$$Relu(x)=\{\begin{array}{ll}x,& \text{x>=0}\\ 0,& \text{x<0}\end{array}$$
$$\frac{\partial Relu(x)}{\partial x}=\{\begin{array}{ll}1,& \text{x>=0}\\ 0,& \text{x<0}\end{array}$$
$Relu(x)$ 的函数图像

$\frac{\partial Relu(x)}{\partial x}$函数图像
$Relu(x)$的优点是

1. ReLu的收敛速度比 sigmoid 和 tanh 快。
2. 适合用于后向传播。

$Relu(x)$的缺点是

1. Relu的 output 不是0均值，使得收敛缓慢。
2. 某些神经元可能永远不会被激活，导致相应参数永远不会被更新。
3. ReLU不会对数据做幅度压缩，所以数据的幅度会随着模型层数的增加不断扩张。

Tanh

$$Tanh(x)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$$
$$\frac{\partial Tanh(x)}{\partial x}=1-(Tanh(x){)}^2$$
$Tanh(x)$函数图像

$\frac{\partial Tanh(x)}{\partial x}$函数图像

$Tanh(x)$的优点是

1. Tanh函数是0均值的更加有利于提高训练效率

$Tanh(x)$的缺点是

1. 梯度消失（gradient vanishing）的问题和幂运算的问题仍然存在。

Leaky_relu

$$Leaky\_relu(x)=\{\begin{array}{ll}x,& \text{x>=0}\\ \alpha \ast x,& \text{x<0}\end{array}$$
$$\frac{\partial Leaky\_relu(x)}{\partial x}=\{\begin{array}{ll}1,& \text{x>=0}\\ \alpha ,& \text{x<0}\end{array}$$
$Leaky\_relu(x)$函数图像

$\frac{\partial Leaky\_relu(x)}{\partial x}$函数图像

$Leaky\_relu$的优点是

1. 解决了Relu的神经元死亡问题问，在负区域具有小的正斜率，因此即使对于负输入值，它也可以进行反向传播。
2. 具有Relu函数的优点。

$Leaky\_relu$的缺点是

1. 结果不一致，无法为正负输入值提供一致的关系预测（不同区间函数不同）。

激活函数的应用

我们依然使用波士顿房价预测这个例子，将原来的$y=kx+b$改为
$f(x)=k_2\ast Sigmoid(k_1\ast x+b_1)+b_2$
损失函数依然使用$Loss=\frac{\sum y_{true}-y_{hat}}{n}$
对$b_2$求偏导得
$$\frac{\partial Loss}{\partial b_2}=-2\ast \frac{\sum y_{true}-y_{hat}}{n}$$
对$k_2$求偏导得
$$\frac{\partial Loss}{\partial k_2}=-2\ast \frac{\sum (y_{true}-y_{hat})\ast Sigmoid(k_1\ast x+b_1)}{n}$$
对$b_1$求偏导得
$$\frac{\partial Loss}{\partial b_1}=-2\ast \frac{\sum (y_{true}-y_{hat})\ast k_2\ast Sigmoid(k_1\ast x+b_1)\ast (1-Sigmoid(k_1\ast x+b_1))}{n}$$
对$k_1$求偏导得
$$\frac{\partial Loss}{\partial k_1}=-2\ast \frac{\sum x\ast (y_{true}-y_{hat})\ast k_2\ast Sigmoid(k_1\ast x+b_1)\ast (1-Sigmoid(k_1\ast x+b_1))}{n}$$
求偏导得函数依次为：

# 对b2求偏导
def partial_b2(y_ture, y_hat):
    return -2 * np.mean(np.array(y_ture)-np.array(y_hat))

# 对k2求偏导
def partial_k2(y_ture, y_hat, k1, b1, x):
    s = 0
    n = 0
    for y_ture_i, y_hat_i, x_i in zip(y_ture, y_hat, x):
        s += sigmoid(k1 * x_i + b1) * (y_ture_i - y_hat_i) * 2
        n = n + 1
    return -s/n

# 对b1求偏导
def partial_b1(y_ture, y_hat, k1, b1, x):
    s = 0
    n = 0
    for y_ture_i, y_hat_i, x_i in zip(y_ture, y_hat, x):
        s += 2 * (y_ture_i - y_hat_i) * k2 * (sigmoid(k1 * x_i + b1) - sigmoid(k1 * x_i + b1) ** 2)
        n = n + 1
    return (-1.0 * s)/(1.0 * n)

# 对k1求偏导
def partial_k1(y_ture, y_hat, k1, b1, x):
    s = 0
    n = 0
    for y_ture_i, y_hat_i, x_i in zip(y_ture, y_hat, x):
        s += 2 * x_i * (y_ture_i - y_hat_i) * k2 * (sigmoid(k1 * x_i + b1) - sigmoid(k1 * x_i + b1) ** 2)
        n = n + 1
    return (-1.0 * s)/(1.0 * n)

剩下学习步骤与训练$y=k\ast x+b$同理
完整代码：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston

data = load_boston()
X, Y = data['data'], data['target']
room_index = 5
X_rm = X[:, room_index]


def sigmoid(x):
    return 1 / (1 + np.exp(-x))


k1, b1 = np.random.normal(), np.random.normal()
k2, b2 = np.random.normal(), np.random.normal()

print(k1,b1,k2,b2)

def model1(x, k1, b1):
    return k1 * x + b1

def model2(x, k2, b2):
    return k2 * x + b2


def y_hat(k1, k2, b1, b2, x):
    Y1 = []
    for i in x:
        y1 = model1(i, k1, b1)
        #print(y1)
        y2 = sigmoid(y1)
        #print(y2)
        y3 = model2(y2, k2, b2)
        Y1.append(y3)
    return Y1

Y2 = y_hat(k1, k2, b1, b2, X_rm)
plt.scatter(X_rm, Y,color = 'red')
plt.scatter(X_rm,y_hat(k1, k2, b1, b2, X_rm))
plt.show()

# L2-Loss函数
def Loss(y_ture, y_hat):
    return np.mean((np.array(y_ture) - np.array(y_hat)) ** 2)


# 对b2求偏导
def partial_b2(y_ture, y_hat):
    return -2 * np.mean(np.array(y_ture)-np.array(y_hat))

# 对k2求偏导
def partial_k2(y_ture, y_hat, k1, b1, x):
    s = 0
    n = 0
    for y_ture_i, y_hat_i, x_i in zip(y_ture, y_hat, x):
        s += sigmoid(k1 * x_i + b1) * (y_ture_i - y_hat_i) * 2
        n = n + 1
    return -s/n

# 对k1求偏导
def partial_k1(y_ture, y_hat, k1, b1, x):
    s = 0
    n = 0
    for y_ture_i, y_hat_i, x_i in zip(y_ture, y_hat, x):
        s += 2 * x_i * (y_ture_i - y_hat_i) * k2 * (sigmoid(k1 * x_i + b1) - sigmoid(k1 * x_i + b1) ** 2)
        n = n + 1
    return (-1.0 * s)/(1.0 * n)

# 对b1求偏导
def partial_b1(y_ture, y_hat, k1, b1, x):
    s = 0
    n = 0
    for y_ture_i, y_hat_i, x_i in zip(y_ture, y_hat, x):
        s += 2 * (y_ture_i - y_hat_i) * k2 * (sigmoid(k1 * x_i + b1) - sigmoid(k1 * x_i + b1) ** 2)
        n = n + 1
    return (-1.0 * s)/(1.0 * n)

trying_time = 20000
min_loss = float('inf')
best_k1, best_b1 = None, None
best_k2, best_b2 = None, None
learning_rate = 1e-3
y_guess = y_hat(k1, k2, b1, b2, X_rm)

for i in range(trying_time):
    # 将当前损失于最小损失相比较
    y_guess = y_hat(k1, k2, b1, b2, X_rm)
    loss = Loss(Y, y_guess)
    if loss < min_loss:
        best_k1 = k1
        best_b1 = b1
        best_k2 = k2
        best_b2 = b2
        min_loss = loss
    if i % 1000 == 0:
        print(min_loss)

    # 找更合适的k与b
    k1 = k1 - partial_k1(Y, y_guess, k1, b1, X_rm) * learning_rate
    b1 = b1 - partial_b1(Y, y_guess, k1, b1, X_rm) * learning_rate
    k2 = k2 - partial_k2(Y, y_guess, k1, b1, X_rm) * learning_rate
    b2 = b2 - partial_b2(Y, y_guess) * learning_rate


plt.scatter(X_rm, Y,color = 'red')
plt.scatter(X_rm, y_hat(best_k1, best_k2, best_b1, best_b2, X_rm), color='green')
print('表示的函数为{} * sigmoid({} * x+ {} ) + {}'.format(best_k2,best_k1,best_b1,best_b2))
print('损失为{}'.format(min_loss))
plt.show()

训练结果：