机器学习代码实现：多元线性回归（梯度下降法）吴恩达课后题目

移动开发 2023-04-16 13:36:01 阅读次数: 0

数据集

数据集如图：（面积，卧室数，价格），来自机器学习吴恩达的课后作业
预测价格
在这里插入图片描述

数据集下载：链接: https://pan.baidu.com/s/1MzUq1jPVlic5kkTGsXY87Q?pwd=hdkk 提取码: hdkk
–来自百度网盘超级会员v4的分享

代码思路

1、模型思想

当样本 x i ⃗ = ( x i 1 , x i 2 , . . , x i d ) \vec{x_i} = (x_{i1}, x_{i2},..,x_{id}) xi​ ​=(xi1​,xi2​,..,xid​)有多个属性描述时，我们采用多元线性回归模型，使得模型预测值 f ( x i ⃗ ) = w ⃗ T x i ⃗ + b f(\vec{x_i}) = \vec{w}^T\vec{x_i} + b f(xi​ ​)=w Txi​ ​+b，与真实标记 y i y_i yi​之间的差距尽可能小。

代码中 X X X如图：即 f ( x i ⃗ ) = w ⃗ ^ T x i ⃗ ^ f(\vec{x_i}) = \hat{\vec{w}}^T \hat{\vec{x_i}} f(xi​ ​)=w ^Txi​ ​^​，给每个 x i ⃗ \vec{x_i} xi​ ​添加一列1，省略b的计算。

具体公式推导理论这里不多说，详情看西瓜书，之后会写一篇总结。
在这里插入图片描述

2、策略：代价函数的选取

依然是差距平方和最小化：
在这里插入图片描述

此计算代价的函数不管一元还是多元都是不变的：

# 代价函数，返回该模型w，b参数下的代价
def cost_function(w_hat_matrix, X_matrix, y_matrix) -> float:
    """ 此方法不管几维都固定不变
    :param w_hat_matrix: 二维matrix，1 * 3
    :param X_matrix: 二维matrix，47 * 3
    :param y_matrix: 二维matrix，47 * 1
    :return:  代价
    """
    m = len(X_matrix)  # 样本数
    return np.sum(np.power(X_matrix * w_hat_matrix.T - y_matrix, 2)) / (2 * m)

3、计算w和b：梯度下降法

本题采用梯度下降法实现，可以得到局部最优解。

梯度下降法可以参考吴恩达讲解的，暂时会个公式就可以：注意对代价函数求偏导
在这里插入图片描述
在这里插入图片描述

1、吴恩达讲的 θ \theta θ就是西瓜书里的 w w w， h 就 是 f h就是f h就是f
2、每梯度下降一次，会使得代价更小
3、影响每次下降的因素有：学习率 α \alpha α和初始的 w w w。

  • 一般初始 w ⃗ ^ = [ [ 0 , 0 , . . . 应 d + 1 个 0 ] ] \hat{\vec{w}} = [[0,0,...应d+1个0]] w ^=[[0,0,...应d+1个0]]，即1行d+1列，d为属性个数
  • 学习率 α \alpha α 一般设为0.01，或者0.03， 0.1， 0.3， 1， 3， 10。

4、迭代指定次数后，返回：

  • 最后一次迭代得到的 w ⃗ ^ \hat{\vec{w}} w ^,将此结果带入代价函数中，计算得到最小的cost
  • cost一维array，初始化cost = np.zeros(iters),记录每次迭代的代价，最后画出曲线，查看收敛速度。

代码：梯度下降

# 梯度下降函数
def gradientDescent(alpha, iters, w_hat_matrix, X_matrix, y_matrix) -> tuple:
    """
    :param alpha: 梯度下降学习率/步长
    :param iters:   梯度下降次数
    :param w_hat_matrix:   二维matrix，1 * 3；
                    一般初始设置为[[0, 0, 0]]，初值对梯度下降收敛速度影响大
    :param X_matrix: 二维matrix，47 * 3。就是公式推导里记的那个超大矩阵X.存放扩展了1的所有样本
    :param y_matrix: 二维matrix，47 * 1。存放真实标记
    :return:
    """
    parameters = int(w_hat_matrix.shape[1])  # 3个参数
    m = len(X_matrix)  # 样本数47
    cur_w_mat_matrix = np.matrix(np.zeros(w_hat_matrix.shape))  # 暂存每次迭代得到的w_hat1*3
    cost = np.zeros(iters)  # 记录每次迭代后的新的代价cost
    # 迭代iters次
    for i in range(iters):
        # 所有样本x_i预测输出 和真实标记 y_i的误差。第i行记录了样本x_i的误差
        error_matrix = X_matrix * w_hat_matrix.T - y_matrix  # 97*1
        # 梯度下降公式：得到新的w_hat：j指向每一列，进行更新（w_1, w_2,..,w_j,...w_d, b）
        for j in range(parameters):
            # np.multiply：m*n和m*n的相同下标元素元素相乘，结果还是m*n的矩阵。可以看成多个数乘
            s = np.sum(np.multiply(error_matrix, X_matrix[:, j]))  # 公式：error矩阵和x的第j列相乘
            cur_w_mat_matrix[0, j] = cur_w_mat_matrix[0, j] - alpha * s / m
        w_hat_matrix = cur_w_mat_matrix  # 每次下降更新w_hat
        cost[i] = cost_function(w_hat_matrix, X_matrix, y_matrix)  # 更新代价，用于观察梯度下降的代价变化曲线
    return w_hat_matrix, cost

4、特征缩放

4.1 均值标准化

使用均值标准化，因为样本中两个属性值相差太大，代价函数收敛会很慢，因此要先对数据进行缩放。

采用公式： d a t a − 平 均 值 标 准 差 data - 平均值 \over 标准差 标准差data−平均值​

    data = pd.read_csv(path, names=["Sizes", "Bedrooms", "Prices"])

    # 获取原始数据data的一些描述
    data_origin = data.values  # 二维array，每个子array存放样例的数据
    means = data.mean().values # 一维array，第i个元素：第i列的 均值
    stds = data.std().values  # 一维array，第i个元素：第i列的 标准差
    mins = data.min().values  # 一维array，第i个元素：第i列的 最小值
    maxs = data.max().values # 一维array，第i个元素：第i列的 最大值

    '''data特征缩放：均值标准化，让不同特征值差异不要太大，否则梯度下降收敛会很慢'''
    data = (data - data.mean()) / data.std()

4.2 恢复

    """之前获得的res_w_hat，是数据缩放后得到的res_w_hat
    最终我们要把res_w_hat恢复成与原始数据对应的transform_w_hat
    
    data = (data - data.mean()) / data.std()
    """

    # 咋说呢，就是做了个转置
    res_w_hat_reshape = np.array(res_w_hat.reshape(-1, 1)) # 把1*3的二维matrix变成 3*1 的二维array
    means_reshape = means.reshape(-1, 1)  # 3 * 1 的二维array
    stds_reshape = stds.reshape(-1, 1) # 3*1 的二维array
    transform_w_hat = w_hat_transform(res_w_hat_reshape, means_reshape, stds_reshape)
    print("transform_w_hat:", transform_w_hat)

# 把数据经过特征缩放（均值标准化）的w_hat变成 符合原始数据的w_hat_transform
def w_hat_transform(arr_w_hat_T, means_T, stds_T):
    """ 同型array相乘相除：对应位置元素相乘，返回矩阵仍然是原型
    :param arr_w_hat:  3*1 的二维array
                array([[-1.11069546e-16],
                    [ 8.78503652e-01],
                    [-4.69166570e-02]])
    :param means_T: 3*1 的二维array
    :param stds_T: 3*1 的二维array
    :return:  咱也不知道为啥这么缩放，抄就完事了。。。。
        标准化的公式 ： data = (data - data.mean()) / data.std()
        转化：
            1. temp = y的均值  * w / y的标准差
            2. 转化的b = (b - sum(temp)) * y的标准差  + y的均值
            3. 转化的w = w * y的标准差 / x的标准差
        最后把w_hat_T恢复成 1 * 3返回
    """
    # data = (data - data.mean()) / data.std()
    temp = means_T[:-1] * arr_w_hat_T[1:] / stds_T[:-1]
    arr_w_hat_T[0] = (arr_w_hat_T[0] - np.sum(temp)) * stds_T[-1] + means_T[-1]
    arr_w_hat_T[1:] = arr_w_hat_T[1:] * stds_T[-1] / stds_T[:-1]
    return arr_w_hat_T.reshape(1, -1)

注意点：

1、np

np.matrix(a)

1、代码里基本运算全都是matrix即二维数据运算，比如w, x全都要一维转化为二维np.matrix()

a = [1,2,3]
np.matrix(a)
Out[52]: matrix([[1, 2, 3]])

a = np.array([1,2,3])
np.matrix(a)
Out[54]: matrix([[1, 2, 3]])

2、对于dataframe类型的数据，转matrix

    data_x_hat = data.iloc[:, 0: cols - 1]  # 取dataframe的x：前3列
    data_y = data.iloc[:, [cols - 1]]  # 取dataframe 的y

    # 获取matrix类型的所有样本X和真实标记y_matrix
    X = np.matrix(data_x_hat) # 47 * 3
    y_matrix = np.matrix(data_y) # 47 * 1

矩阵运算

1、星乘：同型矩阵相乘，对应位置的元素相乘，结果仍然同型

（1）直接乘法符号

a = np.array([[1,2,3], [12,3,4]])
b = np.array([[1,2,3], [12,3,4]])
a * b
Out[40]: 
array([[  1,   4,   9],
       [144,   9,  16]])

（2）np.multiply(a, b)

np.multiply(a, b)
Out[41]: 
array([[  1,   4,   9],
       [144,   9,  16]])

点乘：内部做内积:np.dot(a,b)

A 4 ∗ 3 ∗ B 3 ∗ 4 → C 4 ∗ 4 A_{4*3} * B_{3*4} \to C_{4*4} A4∗3​∗B3∗4​→C4∗4​

a = np.array([[1,2,3], [12,3,4], [2,3,4], [1,2,3]])
b = np.array([[1,2,3,3], [12,3,4,3], [2,3,4,2]])
np.dot(a,b)
Out[61]: 
array([[31, 17, 23, 15],
       [56, 45, 64, 53],
       [46, 25, 34, 23],
       [31, 17, 23, 15]])

2、矩阵内元素做n次方：np.power(a, n)

np.power(a, 2)
Out[45]: 
array([[  1,   4,   9],
       [144,   9,  16]])

构造矩阵和矩阵的形状

1、零矩阵：np.zeros((m,n), dtype = )

  • 参数1：形状，元组形式传入
  • 参数dtype：元素类型，默认为float
np.zeros((2,3))
Out[47]: 
array([[0., 0., 0.],
       [0., 0., 0.]])
np.zeros((2,3), dtype = int)
Out[48]: 
array([[0, 0, 0],
       [0, 0, 0]])

2、矩阵转置：a.T

a
Out[49]: 
array([[ 1,  2,  3],
       [12,  3,  4]])
a.T
Out[50]: 
array([[ 1, 12],
       [ 2,  3],
       [ 3,  4]])

查看矩阵是几行几列：a.shape

a = np.array([[1,2,3], [12,3,4]])
a.shape
Out[37]: (2, 3)

转换矩阵形状：a.reshape(m, n)

如：np.matrix w = [[-1.11069546e-16 8.78503652e-01 -4.69166570e-02]]

  • a/b = -1表示不关心行数/列数
  • w.reshape(-1,1) 表示把1行3列的matrix变成1列的matrix，形式为
matrix([[-1.11069546e-16],
   [ 8.78503652e-01],
   [-4.69166570e-02]])

2、pandas

read_csv获取dataframe

1、除了path不给任何参数：默认head是第一行数据
在这里插入图片描述

2、header = 1/2/3…：指定行x为head，数据从head之后开始

    data1 = pd.read_csv(path, header = 1)

在这里插入图片描述

3、names参数：给每列指定head名

data = pd.read_csv(path, names=["Sizes", "Bedrooms", "Prices"])

在这里插入图片描述

4、data.head()：只输出五行（不包括head）

data.xx().values：获取mean,std,min,max等数据的描述值

在这里插入图片描述

data.iloc[p1, p2]

对于dataframe对象使用iloc[p1, p2],输出形式都是：dataframe的形式

  • p1:表示取哪些行：
a:b：提取行a~b-1
[c]：提取行c
  • p2:表示取哪些列
a:b：提取列a~b-1
[c]：提取列c

例：

cols = 4
data_x_hat = data.iloc[:, 0: cols - 1]  # 取dataframe的x：前3列
data_y = data.iloc[:, [cols - 1]]  # 取dataframe 的y

data.insert()

data.insert(0, 'Ones', 1)  # 在第0列，插入一列属性值全为1的列，列名Ones

完整代码

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2022/4/5 20:52
# @Author : cc
# @File : multi-variable-gd.py
# @Software: PyCharm

# 房价预测。 ex1data2.txt：面积、卧室数、房价
import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
from mpl_toolkits.mplot3d import Axes3D


# 代价函数，返回该模型w，b参数下的代价
def cost_function(w_hat_matrix, X_matrix, y_matrix) -> float:
    """ 此方法不管几维都固定不变
    :param w_hat_matrix: 二维matrix，1 * 3
    :param X_matrix: 二维matrix，47 * 3
    :param y_matrix: 二维matrix，47 * 1
    :return:  代价
    """
    m = len(X_matrix)  # 样本数
    return np.sum(np.power(X_matrix * w_hat_matrix.T - y_matrix, 2)) / (2 * m)


# 梯度下降函数
def gradientDescent(alpha, iters, w_hat_matrix, X_matrix, y_matrix) -> tuple:
    """
    :param alpha: 梯度下降学习率/步长
    :param iters:   梯度下降次数
    :param w_hat_matrix:   二维matrix，1 * 3；
                    一般初始设置为[[0, 0, 0]]，初值对梯度下降收敛速度影响大
    :param X_matrix: 二维matrix，47 * 3。就是公式推导里记的那个超大矩阵X.存放扩展了1的所有样本
    :param y_matrix: 二维matrix，47 * 1。存放真实标记
    :return:
    """
    parameters = int(w_hat_matrix.shape[1])  # 3个参数
    m = len(X_matrix)  # 样本数47
    cur_w_mat_matrix = np.matrix(np.zeros(w_hat_matrix.shape))  # 暂存每次迭代得到的w_hat1*3
    cost = np.zeros(iters)  # 记录每次迭代后的新的代价cost
    # 迭代iters次
    for i in range(iters):
        # 所有样本x_i预测输出 和真实标记 y_i的误差。第i行记录了样本x_i的误差
        error_matrix = X_matrix * w_hat_matrix.T - y_matrix  # 97*1
        # 梯度下降公式：得到新的w_hat：j指向每一列，进行更新（w_1, w_2,..,w_j,...w_d, b）
        for j in range(parameters):
            # np.multiply：m*n和m*n的相同下标元素元素相乘，结果还是m*n的矩阵。可以看成多个数乘
            s = np.sum(np.multiply(error_matrix, X_matrix[:, j]))  # 公式：error矩阵和x的第j列相乘
            cur_w_mat_matrix[0, j] = cur_w_mat_matrix[0, j] - alpha * s / m
        w_hat_matrix = cur_w_mat_matrix  # 每次下降更新w_hat
        cost[i] = cost_function(w_hat_matrix, X_matrix, y_matrix)  # 更新代价，用于观察梯度下降的代价变化曲线
    return w_hat_matrix, cost


# 画结果图
def plot_res(transform_w_hat, data_origin, mins, maxs):
    """
    :param transform_w_hat: 符合缩放前原始样例的 b,w1,w2,...wm
            二维array：[[88307.21151185   138.22534685 -7709.05876589]]
    :param data_origin: 原始数据每列的值：也是二维array形式
            属性x1列的所有值array：data_origin[:, 0]
            属性x2...            data_origin[:, 1]
    :param mins:    原始数据每列最小值
                    array: [   852      1 169900]
    :param maxs:    原始数据每列最大值
                    array: [  4478      5 699900]
    :return:  画出拟合模型图和散点图
    """
    # 建立三维模型
    fig = plt.figure() # Create a new figure, or activate an existing figure.
    ax = Axes3D(fig, auto_add_to_figure=False) # 三维坐标轴
    fig.add_axes(ax) # 给图形fig添加坐标轴 an Axes to the figure.

    # 设置三维图角度
    ax.view_init(elev=25, azim=125) # 10 80观察更好

    # 设置三根轴的名称
    ax.set_xlabel('Size')
    ax.set_ylabel('Bedrooms')
    ax.set_zlabel('Prices')

    # 设置x1 x2轴范围
    x1 = np.arange(mins[0], maxs[0] + 1, 1) # x1轴的范围：步长为1
    x2 = np.arange(mins[1], maxs[1] + 1, 1) # x2轴的范围：步长为1
    x1, x2 = np.meshgrid(x1, x2) # 生成网格点坐标矩阵，这句话必须有


    # 画线性回归模型：平面图
    b, w1, w2 = transform_w_hat[0, 0], transform_w_hat[0, 1], transform_w_hat[0, 2]# 获取系数
    f = b + w1 * x1 + w2 * x2     # 模型：映射关系
    ax.plot_surface(x1, x2, f, rstride=1, cstride=1, color='red') # 创建平面图（模型）

    # 创画样例散点图
    ax.scatter(data_origin[:, 0], data_origin[:, 1], data_origin[:, 2])

    plt.show()


# 每次梯度下降的代价变化图
def plot_cost(cost, iters: int):
    """
    :param cost: 一维array，第i个元素存放第i次梯度下降时的代价
    :param iters: 迭代次数，固定1000次
    :return:
    """
    # 二维坐标轴直接Plt：设置坐标轴名称和标题
    plt.xlabel("iterations")
    plt.ylabel("Cost")
    plt.title("Error vs Traning Epoch")

    # 画直线，x变化范围为0~迭代次数，y为每次的代价
    plt.plot(range(iters), cost, color='red')
    plt.show()


# 把数据经过特征缩放（均值标准化）的w_hat变成 符合原始数据的w_hat_transform
def w_hat_transform(arr_w_hat_T, means_T, stds_T):
    """ 同型array相乘相除：对应位置元素相乘，返回矩阵仍然是原型
    :param arr_w_hat:  3*1 的二维array
                array([[-1.11069546e-16],
                    [ 8.78503652e-01],
                    [-4.69166570e-02]])
    :param means_T: 3*1 的二维array
    :param stds_T: 3*1 的二维array
    :return:  咱也不知道为啥这么缩放，抄就完事了。。。。
        标准化的公式 ： data = (data - data.mean()) / data.std()
        转化：
            1. temp = y的均值  * w / y的标准差
            2. 转化的b = (b - sum(temp)) * y的标准差  + y的均值
            3. 转化的w = w * y的标准差 / x的标准差
        最后把w_hat_T恢复成 1 * 3返回
    """
    # data = (data - data.mean()) / data.std()
    temp = means_T[:-1] * arr_w_hat_T[1:] / stds_T[:-1]
    arr_w_hat_T[0] = (arr_w_hat_T[0] - np.sum(temp)) * stds_T[-1] + means_T[-1]
    arr_w_hat_T[1:] = arr_w_hat_T[1:] * stds_T[-1] / stds_T[:-1]
    return arr_w_hat_T.reshape(1, -1)


if __name__ == '__main__':
    """ pandas得到dataframe类型的数据data    
            Size	Bedrooms	Price  3列
    """
    path = 'ex1data2.txt'
    data = pd.read_csv(path, names=["Sizes", "Bedrooms", "Prices"])

    # 获取原始数据data的一些描述
    data_origin = data.values  # 二维array，每个子array存放样例的数据
    means = data.mean().values # 一维array，第i个元素：第i列的 均值
    stds = data.std().values  # 一维array，第i个元素：第i列的 标准差
    mins = data.min().values  # 一维array，第i个元素：第i列的 最小值
    maxs = data.max().values # 一维array，第i个元素：第i列的 最大值

    '''data特征缩放：均值标准化，让不同特征值差异不要太大，否则梯度下降收敛会很慢'''
    data = (data - data.mean()) / data.std()


    '''添加列，用于获得x_hat组成的X：详情见公式推导，为了计算省略b
            Ones    Size	Bedrooms	Price  4列
    '''
    data.insert(0, 'Ones', 1)  # 在第0列，插入一列属性值全为1的列，列名Ones
    cols = data.shape[1]  # 列数4

    """对于dataframe对象使用iloc
    [p1, p2]
    p1:表示取哪些行：  
        a:b：提取行a~b-1
        [c]：提取行c
    p2:表示取哪些列
        a:b：提取列a~b-1
        [c]：提取列c
    输出形式都是：dataframe的形式
    """
    data_x_hat = data.iloc[:, 0: cols - 1]  # 取dataframe的x：前3列
    data_y = data.iloc[:, [cols - 1]]  # 取dataframe 的y

    # 获取matrix类型的所有样本X和真实标记y_matrix：有的计算只能二维matrix做
    X = np.matrix(data_x_hat) # 47 * 3
    y_matrix = np.matrix(data_y) # 47 * 1
    w_hat_matrix = np.matrix([0, 0, 0])  # 1*3 初始w一般设置为0

    # 看看获取的matrix是几行几列： (47, 3) (47, 1) (1, 3)
    # print(X.shape, y_matrix.shape, w_hat_matrix.shape)

    # 设置步长和下降次数
    alpha = 0.01 # 常考率 0.01， 0.03， 0.1， 0.3， 1， 3， 10
    iters = 1000  # 迭代次数
    # 梯度下降iters次后，我们获得的res_w_hat能使得代价函数获得【局部最小值】
    res_w_hat, cost = gradientDescent(alpha, iters, w_hat_matrix, X, y_matrix)
    print("res_w_hat：", res_w_hat)
    # 用能使得代价函数获得【局部最小值】的res_w_hat，带入计算局部最小代价
    res_cost = cost_function(res_w_hat, X, y_matrix)
    print("res_cost：", res_cost)


    """之前获得的res_w_hat，是数据缩放后得到的res_w_hat
    最终我们要把res_w_hat恢复成与原始数据对应的transform_w_hat
    
    data = (data - data.mean()) / data.std()
    """
    """reshape(a, b)
    如：np.matrix w = [[-1.11069546e-16  8.78503652e-01 -4.69166570e-02]]
    a/b = -1表示不关心行数/列数
    w.reshape(-1,1) 表示把1行3列的matrix变成1列的matrix，形式为
    matrix([[-1.11069546e-16],
        [ 8.78503652e-01],
        [-4.69166570e-02]])
    pandas变成excel就是只有一列    
    """
    # 咋说呢，就是做了个转置
    res_w_hat_reshape = np.array(res_w_hat.reshape(-1, 1)) # 把1*3的二维matrix变成 3*1 的二维array
    means_reshape = means.reshape(-1, 1)  # 3 * 1 的二维array
    stds_reshape = stds.reshape(-1, 1) # 3*1 的二维array
    transform_w_hat = w_hat_transform(res_w_hat_reshape, means_reshape, stds_reshape)
    print("transform_w_hat:", transform_w_hat)

    plot_res(transform_w_hat, data_origin, mins, maxs) # 模型

    plot_cost(cost, iters) # 代价函数曲线

图

模型

在这里插入图片描述

在这里插入图片描述

代价函数梯度下降曲线：

在这里插入图片描述

一些参考:
https://blog.csdn.net/matafeiyanll/article/details/104125828

猜你喜欢

转载自blog.csdn.net/weixin_42810939/article/details/123979992
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022