线性回归

场景:使用线性回归来预测波士顿房价。

说明

线性回归，即学习一个线性方程来拟合特征X与结果Y。
如根据房屋面积x1，房间数量x2，地理位置x3等来预测房屋的价格y。
所以我们要学习一个方程:

这个方程就是线性回归的，就是最终我们用来预测y值的函数
其中 就是我们要学习的参数。

如何学习 呢，我们要学到怎样的才能证明这个模型ok呢？
我们的目标是让预测值尽可能地接近真实值。设预测值为,真实值为y，我们当然是希望|y-|的值越小越好。
所以我们引入一个代价函数，用来衡量整体的预测值与真实值的整体差距。代价函数如下:
J(W,b) =

我们的目标就是要最小化J(W,b)。最小化J(W,b)的方法就是梯度下降法。

变量说明

对所用到的变量做一个统一说明，方便检查。

将 改写为:

设:
m: 样本个数
n_x：特征维度
θ：(
则：
X的shape 为:(m,n_x+1)
y的shape为：(m,1)
θ 的shape = (n_x+1,1)

实现

Package

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
import seaborn as sb

加载数据

X,y = datasets.load_boston(return_X_y=True)
y = y.reshape(-1,1)

#将数据分为训练集和测试集
train_X,test_X,train_y,test_y = train_test_split(X,y,test_size = 0.15,random_state = 1)
print(f"train_X的大小为：{train_X.shape}")
print(f"tain_y的大小为：{train_y.shape}")
print(f"test_X的大小为：{test_X.shape}")
print(f"test_y的大小为：{test_y.shape}")

train_X的大小为：(430, 13)
tain_y的大小为：(430, 1)
test_X的大小为：(76, 13)
test_y的大小为：(76, 1)

#标准化
def nomalize(X,axis):
    mean = np.mean(X,axis)
    std = np.std(X,axis)
    print(mean.shape)
    return (X-mean)/std, mean,std

#将数据标准化
train_X,mean,std = nomalize(train_X,axis=0)
test_X = (test_X-mean)/std

#插入一列全为1的表示x0
train_X = np.insert(train_X,0,1,axis=1)
test_X = np.insert(test_X,0,1,axis=1)
print(train_X.shape)
print(test_X.shape)

(13,)
(430, 14)
(76, 14)

初始化参数

def init_parameters(n):
    theta = np.random.randn(n,1)
    return theta

定义损失函数

def compute_cost(y_,y):
    m = y.shape[0]
    cost = np.sum(np.square(y_-y))/(2*m)
    return cost

梯度下降

损失函数J(·)是一个凸函数。存在极小值。
梯度下降所做的就是在损失函数上沿着导数方向下降，从而靠近极小值。
所以实现梯度下降的步骤为:
1.对θ求偏导:

2.根据更新θ的值:

α为学习速率，人为指定。

def gradient_desent(X,y,theta,learning_rate):
    m = y.shape[0]
    y_ = np.dot(X,theta)
    d_theta = np.dot(X.T,y_-y)/m
    theta = theta - learning_rate*d_theta
    return theta

预测

使用模型函数进行预测

def predict(X,theta):
    return  np.dot(X,theta)

优化

def optimizer(train_X,train_y,theta,learning_rate,steps):
    costs = []
    for step in range(steps):
        theta = gradient_desent(train_X,train_y,theta,learning_rate)
        y_ = predict(train_X,theta)
        loss = compute_cost(y_,train_y)
        costs.append(loss)
        if step % 100 == 0:
            print(f"\nAfter {step} step(s),cost is :{loss}")
    return theta,costs

计算正确率

给定一个误差范围，如果预测值与真实值之差在该范围内，则表示预测准确

def calc_accuracy(y_pred,y,error_ratio):   
    '''
    y_pred---预测值
    y -- 真实值
    error_ratio ---误差范围，相比于真实值的百分比，如0.1，0.05
    '''
    y = y.reshape(-1,1)
    m = y.shape[0]
    correct_num = np.sum(np.fabs(y_pred-y) < error_ratio*y)
    return correct_num/m
    

组合到一起，训练模型

def model(train_X,train_y,test_X,test_y,learning_rate=0.05,steps=1):
    m,n_x = train_X.shape
    print(learning_rate)
    #初始化参数
    theta = init_parameters(n_x)
    theta,costs = optimizer(train_X,train_y,theta,learning_rate,steps)
    
    error_ratio = 0.30 # 即误差不能超过30%
    print("==== 训练集验证 ====")
    y_pred = predict(train_X,theta)
    corr_ratio = calc_accuracy(y_pred,train_y,error_ratio)
    print(f"训练集的正确率为：{corr_ratio}")
    
    print("==== 验证集验证 ====")
    y_pred = predict(test_X,theta)
    corr_ratio = calc_accuracy(y_pred,test_y,error_ratio)
    print(f"验证集的正确率为：{corr_ratio}")
    cost = compute_cost(y_pred,test_y)
    print(f"验证集的损失为：{cost}")

    # 绘制损失函数
    plt.xlim(0,steps)
    plt.plot(costs)
    plt.xlabel("step(s)")
    plt.ylabel("costs")
    plt.show() 

model(train_X,train_y,test_X,test_y,learning_rate=0.05,steps=800)

After 600 step(s),cost is :11.010287620444073

After 700 step(s),cost is :11.008066076099043
==== 训练集验证 ====
训练集的正确率为：0.872093023255814
==== 验证集验证 ====
验证集的正确率为：0.8289473684210527
验证集的损失为：10.975677786706013

损失函数曲线

源码地址：https://github.com/huanhuang/housePrices.git