机器学习练习1 — 线性回归Linear Regression

阿里云2000元红包!本站用户参与享受九折优惠!

机器学习练习 1 — 线性回归Linear Regression

1.单变量线性回归

该任务的数据集是人口与利益,目标是想要通过线性回归了解人口作为自变量,利益作为因变量之间的单元关系。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
path =  'ex1data1.txt' #机器学习的官方作业数据集
data = pd.read_csv(path,  header=None,names=['Population', 'Profit'])#pandas读取两列数据
data.head() #看看数据集长什么样子
data.describe() # 顺便看看数据的一些基础属性

展示数据分布

data.plot(kind='scatter', x='Population', y='Profit', figsize=(12,8)) # kind为散点
plt.show()


在这里插入图片描述

目标函数J(\theta)的计算

首先,创建一个以参数\theta为特征函数的代价函数,参数\theta就是我们要用来优化的变量,J(\theta)可以定义为预测值与目标值的差值的平方和。除以\frac{1}{2m}的原因,除了是约定俗成之外,也是为了后续的发展做铺垫,其中的2正好可以与梯度下降算法中求导所产生的\frac{1}{2}约去
J\left( \theta \right)=\frac{1}{2m}\sum\limits_{i=1}^{m}{{{\left( {{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}} \right)}^{2}}}
其中:{{h}_{\theta }}\left( x \right)={{\theta }^{T}}X={{\theta }_{0}}{{x}_{0}}+{{\theta }_{1}}{{x}_{1}}+{{\theta }_{2}}{{x}_{2}}+...+{{\theta }_{n}}{{x}_{n}}

这就是线性回归中的基本假设,h就是hypothesis(假设),就是中学时代的线性函数的广义多元化。

在本例中就是{{h}_{\theta }}\left( x \right)={{\theta }^{T}}X={{\theta }_{0}}{{x}_{0}}+{{\theta }_{1}}{{x}_{1}}

一般将x_0设成值为1的列向量,就像下面这样将这个列向量插入X第一列中

data.insert(0, 'Ones', 1)#(插入位置,列名,列的数值)
data
# 定义J(θ)的函数
def computeCost(X, y, theta):
    inner = np.power(((X * theta.T) - y), 2) # X乘theta的转置,用来求和,不能混淆上文的theta转置乘以X
    return np.sum(inner) / (2 * len(X))

设置因变量与自变量

对于这个例子的变量,目标是给定一个population,想要预测相应的profit,所以将population记为因变量X,profit记为自变量y

cols = data.shape[1]# 列数 3
X = data.iloc[:,0:cols-1]# X是所有行,去掉最后一列
y = data.iloc[:,cols-1:cols]# y是所有行,最后一列
X,y
(    Ones  Population
 0      1      6.1101
 1      1      5.5277
 2      1      8.5186
 3      1      7.0032
 4      1      5.8598
 ..   ...         ...
 92     1      5.8707
 93     1      5.3054
 94     1      8.2934
 95     1     13.3940
 96     1      5.4369
 
 [97 rows x 2 columns],       Profit
 0   17.59200
 1    9.13020
 2   13.66200
 3   11.85400
 4    6.82330
 ..       ...
 92   7.20290
 93   1.98690
 94   0.14454
 95   9.05510
 96   0.61705
 
 [97 rows x 1 columns])
X.head()#head()是观察前5行
y.head()

代价函数是应该是numpy矩阵,所以我们需要转换Xy,然后才能使用它们。 我们还需要初始化\theta

X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix(np.array([0,0]))

theta 是一个(1,2)矩阵

theta
matrix([[0, 0]])

看下维度

X.shape, theta.shape, y.shape
((97, 2), (1, 2), (97, 1))
theta.T # 转置一下
matrix([[0],
        [0]])

计算代价函数 (theta初始值为0).

computeCost(X, y, theta)
32.072733877455676

Batch Gradient Descent(批量梯度下降)

梯度下降的过程就是不断逼近的过程
{{\theta }_{j}}:={{\theta }_{j}}-\alpha \frac{\partial }{\partial {{\theta }_{j}}}J\left( \theta \right)
对于本例子就是对于j=0以及j=1进行更新。

需要注意的地方就是在更新过程中要保持同步更新,否则就会出现更新后\theta_0的值会加之于未更新的\theta_1,导致错误的发生。

亦即:

tmp0 = \theta_0\alpha \frac {\partial}{\partial {{\theta }_{0}}} J(\theta_0,\theta_1)

tmp1 = \theta_1\alpha \frac {\partial}{\partial {{\theta }_{1}}} J(\theta_0,\theta_1)

\theta_0 = tmp0

\theta_1 = tmp1

紧接着定义梯度下降算法函数

def gradientDescent(X, y, theta, alpha, iters):# (自变量,因变量,优化参数,学习率,迭代次数)
    temp = np.matrix(np.zeros(theta.shape))# 0矩阵,1行2列的0矩阵
    parameters = int(theta.ravel().shape[1])# 扁平化,值为2
    cost = np.zeros(iters) # 代价列表
    
    for i in range(iters):
        error = (X * theta.T) - y # 得到这一迭代回合的 h(x_i)-y_i
        
        for j in range(parameters):
            term = np.multiply(error, X[:,j]) # (h(x_i) - y_i) * x_j 对于多元的重点就在于乘以的这个x_j
            temp[0,j] = theta[0,j] - ((alpha / len(X)) * np.sum(term))
            
        theta = temp # 待一切结束后更新θ
        cost[i] = computeCost(X, y, theta) # 计算每次迭代后的代价函数
        
    return theta, cost

初始化一些附加变量 – 学习速率\alpha和要执行的迭代次数。

alpha = 0.01
iters = 1000

运行梯度下降算法,得到相关参数\theta

g, cost = gradientDescent(X, y, theta, alpha, iters)
g
matrix([[-3.24140214,  1.1272942 ]])

最后使用拟合的参数计算训练模型的代价函数(误差)。

computeCost(X, y, g)
4.515955503078912

结果可视化

x = np.linspace(data.Population.min(), data.Population.max(), 100) #生成横轴点图
f = g[0, 0] + (g[0, 1] * x) #生成线性拟合函数,h(θ) = θ_0 + θ_1 * x_1
fig, ax = plt.subplots(figsize=(12,8))
ax.plot(x, f, 'r', label='Prediction') # 预测图
ax.scatter(data.Population, data.Profit, label='Traning Data') # 原始数据散点图
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
plt.show()


在这里插入图片描述

由于梯度方程式函数也在每个训练迭代中输出一个代价的向量,所以我们也可以绘制。 请注意,代价总是降低 – 这是凸优化问题的一个例子。

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(np.arange(iters), cost, 'r')
ax.set_xlabel('Iterations')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Training Epoch')
plt.show()


在这里插入图片描述

  • 可以比较一下不同学习率迭代的过程
base = np.logspace(-3, -5, num=4)
candidate = np.sort(np.concatenate((base, base*3)))
candidate
array([1.00000000e-05, 3.00000000e-05, 4.64158883e-05, 1.39247665e-04,
       2.15443469e-04, 6.46330407e-04, 1.00000000e-03, 3.00000000e-03])
fig, ax = plt.subplots(figsize=(12,8))
for alpha1 in candidate:
    g, costs = gradientDescent(X, y, theta, alpha1, iters)
    ax.plot(np.arange(iters), costs, label = alpha1)
ax.set_xlabel('epoch', fontsize=18)
ax.set_ylabel('cost', fontsize=18)
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
ax.set_title('learning rate', fontsize=18)
plt.show()


在这里插入图片描述

至此单变量线性回归告一段落。

2.多变量线性回归

另外还有一个房屋价格数据集,其中有2个自变量(房子的大小Size,卧室的数量Bedrooms)和目标亦即因变量(房子的价格Price),由于之前的方法已经囊括了多变量所以可以直接带入。

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

特征缩放Feature Scaling

由于SizeBedroomsPrice数据之间尺度不同,相差太大,所以一般需要进行缩放,将所有的数据都尽量缩放在-11之间。

方法:
x_n = \frac{x_n - \mu_n}{s_n}
其中\mu_n是平均值,s_n是样本标准差

data2 = (data2 - data2.mean()) / data2.std()
data2.head()

现在我们重复第1部分的预处理步骤,并对新数据集运行线性回归程序。

# 加一列
data2.insert(0, 'Ones', 1)
# 设置自变量X与因变量与y
cols = data2.shape[1]
X2 = data2.iloc[:,0:cols-1]
y2 = data2.iloc[:,cols-1:cols]
# 转换为矩阵,并初始化θ
X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
theta2 = np.matrix(np.array([0,0,0]))
# 运行梯度下降算法
g2, cost2 = gradientDescent(X2, y2, theta2, alpha, iters)
# 得到损失
computeCost(X2, y2, g2)
0.13070336960771892

我们也可以快速查看这一个的训练进程。

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(np.arange(iters), cost2, 'r')
ax.set_xlabel('Iterations')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Training Epoch')
plt.show()


在这里插入图片描述

  • 不同的学习率
fig, ax = plt.subplots(figsize=(12,8))
for alpha2 in candidate:
    _, costs = gradientDescent(X2, y2, theta2, alpha2, iters)
    ax.plot(np.arange(iters), costs, label = alpha2)
ax.set_xlabel('epoch', fontsize=18)
ax.set_ylabel('cost', fontsize=18)
ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.)
ax.set_title('learning rate 2', fontsize=18)
plt.show()


在这里插入图片描述

scikit-learn

我们也可以使用scikit-learn的线性回归函数,而不是从头开始实现这些算法。 我们将scikit-learn的线性回归算法应用于第1部分的数据,并看看它的表现。

from sklearn import linear_model
model = linear_model.LinearRegression()
model.fit(X, y)
LinearRegression(copy_X=True, fit_intercept=True, n_jobs=None, normalize=False)

scikit-learn model的预测表现

x = np.array(X[:, 1])
f = model.predict(X).flatten() #扁平化
fig, ax = plt.subplots(figsize=(12,8))
ax.plot(x, f, 'r', label='Prediction')
ax.scatter(data.Population, data.Profit, label='Traning Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
plt.show()


在这里插入图片描述

3. Normal Equation(正规方程)

正规方程是通过求解下面的方程来找出使得代价函数最小的参数的:\frac{\partial }{\partial {{\theta }_{j}}}J\left( {{\theta }_{j}} \right)=0
假设我们的训练集特征矩阵为 X(包含了{{x}_{0}}=1)并且我们的训练集结果为向量 y,则利用正规方程解出向量 \theta ={{\left( {{X}^{T}}X \right)}^{-1}}{{X}^{T}}y
上标T代表矩阵转置,上标-1 代表矩阵的逆。设矩阵A={{X}^{T}}X,则:{{\left( {{X}^{T}}X \right)}^{-1}}={{A}^{-1}}

梯度下降与正规方程的比较:

梯度下降:需要选择学习率\alpha,需要多次迭代,当特征数量n大时也能较好适用,适用于各种类型的模型

正规方程:不需要选择学习率\alpha,一次计算得出,需要计算{{\left( {{X}^{T}}X \right)}^{-1}},如果特征数量n较大则运算代价大,因为矩阵逆的计算时间复杂度为O(n3),通常来说当n小于10000时还是可以接受的,只适用于线性模型,不适合逻辑回归模型等其他模型

# 正规方程
def normalEqn(X, y):
    theta = np.linalg.inv(X.T@X)@X.T@y#X.T@X等价于X.T.dot(X)
    return theta
final_theta2=normalEqn(X, y)#和批量梯度下降的theta的值有点差距
final_theta2
matrix([[-3.89578088],
        [ 1.19303364]])
#梯度下降得到的结果是matrix([[-3.24140214,  1.1272942 ]])

https://www.jianshu.com/p/98bd7fec83b7

「点点赞赏,手留余香」

    还没有人赞赏,快来当第一个赞赏的人吧!
TensorFlow
0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论