标签：plt 机器 梯度 练习 cost 线性 theta data

练习1：线性回归

---

介绍

在本练习中，您将 实现线性回归并了解其在数据上的工作原理。

在开始练习前，需要下载如下的文件进行数据上传：

• ex1data1.txt -单变量的线性回归数据集
• ex1data2.txt -多变量的线性回归数据集

在整个练习中，涉及如下的必做作业，及标号*的选做作业：

• 实现简单示例函数----------（5分）
• 实现数据集显示的函数-------（5分）
• 计算线性回归成本的函数-----（40分）
• 运行梯度下降的功能函数-----（50分）
• 数据标准化*
• 多变量线性回归的梯度下降功能实现*

必做作业为实现单变量的线性回归；选做作业为实现多变量线性回归。

1 实现简单示例函数

在该部分练习中,将通过代码实现返回一个5*5的对角矩阵。输出与如下相同：

1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

1.1 提交解决方案

在以下代码框中进行如上的实现，完成部分练习后，得到如上的相同结果即为通过。

import numpy as np

def create_identity_matrix(size):
    matrix = []
    for i in range(size):
        row = [0] * size  # 初始化
        row[i] = 1  # 将对角线上的元素设置为1
        matrix.append(row)
    return matrix  # 返回矩阵

def print_matrix(matrix):
    # 打印矩阵
    for row in matrix:
        print(' '.join(map(str, row)))

identity_matrix = create_identity_matrix(5)
print_matrix(identity_matrix)

1 0 0 0 0
0 1 0 0 0
0 0 1 0 0
0 0 0 1 0
0 0 0 0 1

2 单变量线性回归

在该部分练习中，将实现单变量线性回归并用来预测餐车的利润。

假设你是一家餐厅的领导，正在考虑在不同的城市开设新的分店。该连锁店已经在不同的城市有了餐车，并且你能够获得每个城市的人口和利润数据。

现在需要使用这些数据来帮助你选择下一个被扩展的城市。

文件ex1data1.txt包含线性回归问题的数据集。第一列数据对应城市人口，第二列数据对应那座城市的餐车的利润。利润为负时表示亏损。

2.1 绘制数据

在开始进入练习之前，对数据进行可视化通常很有用。对于该数据集，可以使用散点图进行可视化，因为它只有两个属性（人口、利润）。

# 引入所需要的库文件
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os

%matplotlib inline

# 数据存储路径
path = 'ex1data1.txt'

# 读入相应的数据文件
data = pd.read_csv(path, header=None,names=['Population','Profit'])

#查看数据的前五条
data.head(5)

	Population	Profit
0	6.1101	17.5920
1	5.5277	9.1302
2	8.5186	13.6620
3	7.0032	11.8540
4	5.8598	6.8233

接下来需要实现数据可视化的代码，该部分数据绘制出的图像应与如下相同。

要点：

• 实现散点图可视化
• 数据分布为红色点
• 标清横纵坐标名称

###在这里填入代码###
# 绘制散点图
plt.figure(figsize=(8, 6))
plt.scatter(data['Population'], data['Profit'], color='red')

# 设置图表标题和坐标轴标签
plt.title('Population vs Profit', fontsize=14)
plt.xlabel('Population', fontsize=12)
plt.ylabel('Profit', fontsize=12)

# 显示图表
plt.show()

2.2 梯度下降

在该部分中，将使用梯度下降来选择合适的线性回归参数θ用以拟合给定数据集。

2.2.1 更新公式

线性回归的目的是最小化成本函数：

假设$h_{\theta}(X)$由以下线性模型给出：

回顾一下，模型的参数是$\theta_j$的值，这些将用来调整以最小化成本$J(\theta)$。

其中一种方法是使用批量梯度下降算法，在批量梯度下降中，每次迭代地执行更新，随着梯度下降的每一步计算，参数$\theta_j$越来越接近能够使得成本$J(\theta)$达到最低的最佳值。

(同时更新所有的$\theta_j$）

2.2.2 实现

在上一部分的练习中，我们已经将所需要用到的数据加载至变量data中，并为其列分别进行命名。

接下来，我们在数据中添加了一个维度来拟合截距项$\theta_0$。并将初始参数值设为0，学习率$\alpha$设为0.01。

#在列索引为0处添加数据列，该列值均为1
data.insert(0, 'Ones', 1)

#获取数据列数
cols = data.shape[1]

#对变量X和y进行初始化,并将其数据类型转换为矩阵
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]
X = np.matrix(X.values)
y = np.matrix(y.values)

#学习率、迭代次数的初始化
alpha = 0.01
iterations = 1500

#看看特征属性
print(X.shape, type(X))
print(X)
print(X.shape, type(X))
print(X)

(97, 2) <class 'numpy.matrix'>
[[ 1.      6.1101]
 [ 1.      5.5277]
 [ 1.      8.5186]
 [ 1.      7.0032]
 [ 1.      5.8598]
 [ 1.      8.3829]
 [ 1.      7.4764]
 [ 1.      8.5781]
 [ 1.      6.4862]
 [ 1.      5.0546]
 [ 1.      5.7107]
 ...
 [ 1.      5.0594]
 [ 1.      5.7077]
 [ 1.      7.6366]
 [ 1.      5.8707]
 [ 1.      5.3054]
 [ 1.      8.2934]
 [ 1.     13.394 ]
 [ 1.      5.4369]]
(97, 2) <class 'numpy.matrix'>
[[ 1.      6.1101]
 [ 1.      5.5277]
 [ 1.      8.5186]
 [ 1.      7.0032]
 ...
 [ 1.      7.6366]
 [ 1.      5.8707]
 [ 1.      5.3054]
 [ 1.      8.2934]
 [ 1.     13.394 ]
 [ 1.      5.4369]]

2.2.3 计算成本J(θ)

在执行梯度下降最小化成本函数$J(\theta)$时，通过计算成本来监视收敛状态是有帮助的。

在该部分练习任务中，你需要实现一个计算成本$J(\theta)$的函数computeCost，用于检查梯度下降实现的收敛性。

其中，X和y不是标量值，而是矩阵，其行代表训练集中的示例。

要点：
完成该函数后，将$\theta$值初始化为0并进行成本的计算，将得到的成本值打印出来。

如果结果为32.07，则计算通过。

###在这里填入代码###
theta = np.zeros((X.shape[1],1))
# Cost Function
# X: R(m * n) 特征矩阵
# y: R(m * 1) 标签值矩阵
# theta: R(n) 线性回归参数
def computeCost(theta, X, y):
    # m 为样本数
    m = len(y)
    
    # 误差 = theta * x - y
    inner = X @ theta - y
    
    # 将平方计算转换为：行向量 * 列向量
    square_sum = np.sum(np.square(inner))
    
    # 缩小成本量大小
    cost = square_sum / (2 * m)
    
    return cost;
# 当 theta 初始为 0 时，计算当前成本 cost
cost = computeCost(theta, X, y)
print(cost)

32.072733877455676

2.2.4 梯度下降

接下来，我们将实现梯度下降，给出的代码已经实现了循环结构，你只需要在每次的迭代中提供$\theta$的更新。

在进行代码实现时，请确保你了解要优化的内容，和正在更新的内容。

请记住，成本$J(\theta)$为参数-被向量$\theta$终止，而不是$X$和$y$。也就是说，我们将$J(\theta)$的值最小化通过改变矢量$\theta$的值，而不是通过改变$X$或$y$。

验证梯度下降是否正常工作的一种好方法是查看$J(\theta)$的值，并检查该值每步是否减小。每次迭代时，代码都会调用computeCost函数并打印成本。假设你实现了梯度下降，正确地计算成本，$J(\theta)$值永远不会增加，并且应该在算法结束时收敛到稳定值。

要点：

实现梯度下降后，需要使用最终的参数值将线性回归的拟合结果进行可视化，绘图结果需要类似如下图所示。

###在这里填入代码###
# 计算偏导数
def gradient(theta, X, y):
    m = X.shape[0]
    
    inner = X.T @ (X @ theta - y)
    
    return inner / m
# 批量梯度下降
# epoch: 下降迭代次数
# alpha: 初始学习率
def batch_gradient_decent(theta, X, y, iterations, alpha):
    # 计算初始成本：theta 都为 0
    cost_data = [computeCost(theta, X, y)]
    
    # 创建新的 theta 变量，不与原来的混淆
    _theta = theta.copy()
    
    for _ in range(iterations):
        _theta = _theta - alpha * gradient(_theta, X, y)
        cost_data.append(computeCost(_theta, X, y))
        
    return _theta, cost_data

# 计算最终的参数所得到的成本值
_theta, cost_data = batch_gradient_decent(theta, X, y, iterations, alpha)
print(_theta)
computeCost(_theta, X, y)

[[-3.63029144]
 [ 1.16636235]]





4.483388256587726

cost_data

[32.072733877455676,
 6.737190464870006,
 5.931593568604956,
 5.901154707081388,
 5.895228586444221,
 5.89009494311733,
 5.885004158443647,
 5.879932480491418,
 5.874879094762575,
 ...
 4.516522271846125,
 4.516379811801644,
 4.516237864890023,
 4.516096429262984,
 ...]

###在这里填入代码###
#对拟合曲线进行绘制
plt.scatter(data['Population'], data['Profit'], color='red', label='Training data')
plt.plot(data['Population'], X @ _theta, label='Linear regression fit', color='blue')

plt.xlabel('Population')
plt.ylabel('Profit')
plt.title('Linear Regression Fit')
plt.legend()
plt.show()

2.3 可视化成本函数

为了更好地理解成本函数的迭代计算，将每一步计算的cost值进行记录并绘制。

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(np.arange(iterations+1), cost_data, 'r')
ax.set_xlabel('Iterations')
ax.set_ylabel('Cost')
ax.set_title('Cost Function Convergence')

Text(0.5, 1.0, 'Cost Function Convergence')

选做练习

---

3 多变量线性回归

在该部分中，将使用多个变量来实现用线性回归预测房屋价格。假设你目前正在出售房屋，想知道什么是好的市场价格。

一种方法是首先收集最近出售房屋的信息，其次是建立房屋价格模型。

文件ex1data2.txt包含俄勒冈州波特兰市的房屋价格及相关信息。第一列是房屋的大小（以平方英尺为单位），第二列是卧室的个数，第三列是房屋的价格。

3.1 特征标准化

以下代码将从文件ex1data2.txt文件中加载并显示该数据集。

通过观察这些数据，可以发现房屋的大小大约是卧室数量的1000倍。而当不同的特征值之间相差几个数量级时，将特征进行缩放可以使梯度下降收敛得更快。

path = 'ex1data2.txt'
data2 = pd.read_csv(path, header=None, names=['Size', 'Bedrooms', 'Price'])
data2.head()

	Size	Bedrooms	Price
0	2104	3	399900
1	1600	3	329900
2	2400	3	369000
3	1416	2	232000
4	3000	4	539900

在该部分练习中，你的任务是编写代码并实现数据集中的数据标准化。

要点：

• 从数据集中减去每个特征的平均值。
• 减去平均值后，再将新的特征值除以各自的“标准差”

标准差是一种衡量特定特征的值的范围内有多大变化的方法（大多数数据点将位于平均值的两个标准差内）；这是取值范围的替代方法。

当标准化特征时，需要存储用于标准化的值——平均值和标准差。从模型中学习参数后，经常需要预测新的房屋的价格。此时给定一个新的$x$值（房屋面积和卧室数量），必须首先使用先前从训练集中计算的平均值和标准差来对新的数据进行标准化。

###在这里填入代码###
# 读取数据特征
def get_X(df):
    # 创建 m 行 1 列的数据帧
    ones = pd.DataFrame({'ones': np.ones(len(df))})
    # 合并全 1 向量作为元素数据第一列，axis = 0 按行合并，anix = 1 按列合并
    data = pd.concat([ones, df], axis=1)
    
    return data.iloc[:, :-1].values

# 读取数据值，即数据标签
def get_y(df):
    # 返回原始数据最后一列组成的数组，df.iloc[:, -1] 指最后一列
    return np.array(df.iloc[:, -1])

# 特征缩放
def normalize_feature(df):
    # 对原始数据每一列应用一个 lambda 函数，mean() 求每列平均值，std() 求标准差
    return df.apply(lambda column: (column - column.mean()) / column.std())
# 对原始数据进行特征缩放
data = normalize_feature(data2)
data.head()

	Size	Bedrooms	Price
0	0.130010	-0.223675	0.475747
1	-0.504190	-0.223675	-0.084074
2	0.502476	-0.223675	0.228626
3	-0.735723	-1.537767	-0.867025
4	1.257476	1.090417	1.595389

3.2 梯度下降

在之前的练习中，我们使用单变量线性回归实现了梯度下降的问题。在该部分联系中，唯一的区别是，此时我们的数据变为矩阵$X$。

假设函数和批次梯度下降的更新规则保持不变，你的任务是代码实现多变量线性回归的成本函数和梯度下降。

要点：

• 确保你的代码中可以支持任何大小的数据，并且数据均已被向量化。
• 代码实现成本函数和梯度下降后，最终的成本值应大约为0.13。
• 请依照单变量线性回归练习中要求，绘制成本的变化曲线。

import seaborn as sns
###在这里填入代码###
# 输出特征数据维度和类型
X = get_X(data)
print(X.shape, type(X))
# 输出标签数据维度和类型
y = get_y(data)
print(y.shape, type(y))
# 初始化 theta 参数均为 0
theta = np.zeros(X.shape[1])
# 设置迭代次数
epoch = 1500
# 设置学习率
alpha = 0.01
# 多变量批量梯度下降
final_theta, cost_data = batch_gradient_decent(theta, X, y, epoch, alpha = alpha)
# 代价 - 迭代次数可视化
sns.tsplot(time = np.arange(len(cost_data)), data = cost_data)
plt.xlabel('epoch', fontsize = 18)
plt.ylabel('cost', fontsize = 18)
plt.show()
# 输出迭代的最优参数 theta
final_theta

(47, 3) <class 'numpy.ndarray'>
(47,) <class 'numpy.ndarray'>


/opt/conda/lib/python3.6/site-packages/seaborn/timeseries.py:183: UserWarning: The `tsplot` function is deprecated and will be removed in a future release. Please update your code to use the new `lineplot` function.
  warnings.warn(msg, UserWarning)
/opt/conda/lib/python3.6/site-packages/scipy/stats/stats.py:1713: FutureWarning: Using a non-tuple sequence for multidimensional indexing is deprecated; use `arr[tuple(seq)]` instead of `arr[seq]`. In the future this will be interpreted as an array index, `arr[np.array(seq)]`, which will result either in an error or a different result.
  return np.add.reduce(sorted[indexer] * weights, axis=axis) / sumval

array([-1.10833328e-16,  8.84042349e-01, -5.24551809e-02])

标签：plt,机器,梯度,练习,cost,线性,theta,data
From： https://www.cnblogs.com/hjdssj/p/18585819