导入需要使用的包
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
导入数据集。提醒大家：一定要把数据文件ex1data1.txt放在和程序同一个文件夹里，否则需要使用绝对路径访问文件 将csv文件读入并转化为数据框形式，路径，指定哪一行作为表头。默认设置为0（即第一行作为表头），如果没有表头的话，要修改参数，设置header=None，指定列的名称，用列表表示。一般我们没有表头，即header=None时，这个用来添加列名 在默认情况下，head命令显示文件的头5行内容。
path = 'ex1data1.txt'
data = pd.read_csv(path, header=None, names=['Population', 'Profit'])
data.head() # 预览数据
| 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 |
对于数值数据，结果的索引将包括计数(count)、平均值(mean)、标准差(std)、最小值(min)、最大值(max)以及较低的百分位数为50.默认情况下，较低的百分位数为25，较高的百分位数为75.50百分位数与中位数相同。
data.describe()
| Population | Profit | |
|---|---|---|
| count | 97.000000 | 97.000000 |
| mean | 8.159800 | 5.839135 |
| std | 3.869884 | 5.510262 |
| min | 5.026900 | -2.680700 |
| 25% | 5.707700 | 1.986900 |
| 50% | 6.589400 | 4.562300 |
| 75% | 8.578100 | 7.046700 |
| max | 22.203000 | 24.147000 |
数据可视化，绘制散点图kind：取值为line或者scatter，后者为默认值 图像大小
data.plot(kind='scatter', x='Population', y='Profit', figsize=(12,8))
plt.show()
现在让我们使用梯度下降来实现线性回归，义最小化成本函数。以下代码示例中实现的方程在“练习”文件夹中的“ex1.pdf”中有详细说明。
首先，我们将创建一个参数 θ \theta θ为特征函数的代价函数
np.power(x1,x2)数组的元素分别求n次方。x2可以是数字，也可以是数组，但是x1和x2的列数要相同
def computeCost(X, y, theta):
# your code here (appro ~2 lines)
inner = np.power(((X * theta.T)-y), 2)
return np.sum(inner) / (2 * len(X))
让我们在训练集中添加一列，以便我们可以使用向量化的解决方案来计算代价和梯度。在训练集的左侧插入一列全为“1”的列，以便计算即x0=1 loc为0，name为ones,value为1.
data.insert(0, 'Ones', 1)
现在我们来做一些变量初始化。 .shape[0]为第一维的长度， .shape[1]为第二维的查毒理解列。 pandas中利用iloc选取数据iloc’,‘前的部分标明选取的行，’,'后的部分标明选取的列 此时三列了
# set X (training data) and y (target variable)
cols = data.shape[1]
X = data.iloc[:,0:cols-1] # X是所有行，去掉最后一列 [0,2)
y = data.iloc[:,cols-1:cols] # [2,3)
观察下X(训练集) and y(目标变量)是否正确.
X.head() # head() 默认是观察前5行
| Ones | Population | |
|---|---|---|
| 0 | 1 | 6.1101 |
| 1 | 1 | 5.5277 |
| 2 | 1 | 8.5186 |
| 3 | 1 | 7.0032 |
| 4 | 1 | 5.8598 |
y.head()
| Profit | |
|---|---|
| 0 | 17.5920 |
| 1 | 9.1302 |
| 2 | 13.6620 |
| 3 | 11.8540 |
| 4 | 6.8233 |
代价函数是应该是numpy矩阵，所以我们需要转换X和Y，然后才能使用它们，我们还需要初始化theta，即把theta所有元素都设置为0.
X = np.matrix(X.values)
y = np.matrix(y.values)
# your code here (appro ~1 lines)
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初始值为0).
computeCost(X, y, theta)
32.072733877455676
def gradientDescent(X, y, theta, alpha, iters):
temp = np.matrix(np.zeros(theta.shape)) # 构建零值矩阵
parameters = int(theta.ravel().shape[1]) # ravel计算需要求解的参数个数 概念将多维数组降至一维
cost = np.zeros(iters) # 构建iters个0的数组
for i in range(iters):
# your code here (appro ~ 2 lines)
error = (X * theta.T) - y
for j in range(parameters):
# your code here (appro ~2 lines)
term = np.multiply(error, X[:,j]) # 计算两矩阵(hθ(x)-y)x
temp[0, j] = theta[0,j] - ((alpha / len(X)) * np.sum(term))
# your code here (appro ~2 lines)
theta = temp
cost[i] = computeCost(X, y, theta)
return theta, cost
初始化一些附加变量 - 学习速率α（alpha）和要执行的迭代次数（iters）。
alpha = 0.01
iters = 1000
现在让我们运行梯度下降算法来将我们的参数θ适合于训练集
g, cost = gradientDescent(X, y, theta, alpha, iters)
g
matrix([[-3.24140214, 1.1272942 ]])
最后，我们可以使用我们拟合的参数计算训练模型的代价函数（误差）。
computeCost(X, y, g)
4.515955503078914
现在我们来绘制线性模型以及数据，直观地看出它的拟合。fig代表整个图像，ax代表实例
subplots() 函数，它的使用方法和 subplot() 函数类似。其不同之处在于，subplots() 既创建了一个包含子图区域的画布，又创建了一个 figure 图形对象，而 subplot() 只是创建一个包含子图区域的画布。
subplots 的函数格式如下：
fig , ax = plt.subplots(nrows, ncols)
nrows 与 ncols 表示两个整数参数，它们指定子图所占的行数、列数。
函数的返回值是一个元组，包括一个图形对象和所有的 axes 对象。其中 axes 对象的数量等于 nrows * ncols，且每个 axes 对象均可通过索引值访问（从1开始）。
x = np.linspace(data.Population.min(), data.Population.max(), 100) # 抽100个样本
f = g[0, 0] + (g[0, 1] * x) # g[0, 0] 代表theta0 ,g[0, 1]代表theta1
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 = 4) # 显示标签位置
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
plt.show() # 显示图像
由于梯度方程式函数也在每个训练迭代中输出一个代价的向量，所以我们也可以绘制。请注意，代价总是降低 - 这是凸优化问题的一个例子。
arange()函数：类似于python的内置函数range()，通过指定开始值、终值和步长来创建表示等差数列的一维数组，返回给定间隔内的均匀间隔值，注意得到的结果数组不包含终值。
arange([start,] stop[, step,], dtype=None)
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()
练习1还包括一个房屋价格数据集，其中有2个变量（房子的大小，卧室的数量）和目标（房子的价格）。我们使用我们已经应用的计数来分析数据集。
path = 'ex1data2.txt'
data2 = pd.read_csv(path, header=None, names=['Size', 'Bedeooms', 'Price'])
data2.head()
| Size | Bedeooms | Price | |
|---|---|---|---|
| 0 | 2104 | 3 | 399900 |
| 1 | 1600 | 3 | 329900 |
| 2 | 2400 | 3 | 369000 |
| 3 | 1416 | 2 | 232000 |
| 4 | 3000 | 4 | 539900 |
对于此任务，我们添加了另一个预处理步骤 - 特征归一化。这个对于pandas来说很简单
如果这个房子价格不归一化，它的数量级和你输入值归一化数量级差别太大，几十万的数量级和个位小数做回归，就不能保证收敛了 预测的y和实际上y几十万差的太多了
data2 = (data2 - data2.mean()) / data2.std()
data2.head()
| Size | Bedeooms | 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 |
现在我们重复第1部分的预处理步骤，并对新数据集运行线性回归程序
# add ones column
data2.insert(0, 'Ones', 1)
# set X (training data) and y (target variable)
cols = data2.shape[1]
X2 = data2.iloc[:,0:cols-1]
y2 = data2.iloc[:,cols-1:cols]
# convert to matrices and initialine theta
X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
theta2 = np.matrix(np.array([0,0,0]))
#perform linear regression on the data set
g2, cost2 = gradientDescent(X2, y2, theta2, alpha, iters)
# get the cost (error) of the model
computeCost(X2, y2, g2)
0.1307033696077189
我们也可以快速查看这一个的训练进程
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()
正规方程是通过求解下面的方程来找出使得代价函数最小的参数的：
∂
J
(
θ
j
)
∂
θ
j
=
0
\frac{\partial J(\theta_j)}{\partial \theta_j}=0
∂θj∂J(θj)=0
假设我们的训练集特征矩阵为X（包含了
X
0
=
1
X_0=1
X0=1）并且我们的训练集结果为向量y，则利用正规方程解出向量
θ
=
(
X
T
X
)
−
1
X
T
y
\theta=(X^TX)^{-1}X^Ty
θ=(XTX)−1XTy。上标T表示矩阵转置，上标-1代表矩阵的逆。设矩阵
A
=
X
T
X
A=X^TX
A=XTX，则：
(
X
T
X
)
−
1
=
A
−
1
(X^TX)^{-1}=A^{-1}
(XTX)−1=A−1
梯度下降与正规方程的比较：
梯度下降：需要选择学习率α，需要多次迭代，当特征数量n大时也能较好适用，适用于各种类型的模型
正规方程：不需要选择学习率α，一次计算得出，需要计算
(
X
T
X
)
−
1
(X^TX)^{-1}
(XTX)−1，如果特征数量n较大则运算代价大，因为矩阵逆的计算时间复杂度为
O
(
n
3
)
O(n_3)
O(n3)，通常来说当n小于10000时还是可以接受的，只适用于线性模型，不适合逻辑回归模型等其他模型。
np.linalg.inv求逆 *** 作 @相对于dot(),dot函数可以通过numpy库调用，也可以由数组实例对象进行调用。a.dot(b)与np.dot(a,b)效果相同。
# 正规方程
def normalEqn(X, y):
# your code here (appro ~1 lines)
theta = np.linalg.inv(X.T@X)@X.T@y
return theta
final_theta2 = normalEqn(X, y) # 感觉和批量梯度下降的theta的值有点差距
final_theta2
matrix([[-3.89578088],
[ 1.19303364]])
# 梯度下降得到的结果是matrix([[-3.24140214, 1.1272942 ]])
在练习2中，我们将看看分类问题的逻辑回归。
TX$，则：$(XTX){-1}=A{-1}
<
b
r
>
梯
度
下
降
与
正
规
方
程
的
比
较
：
<
b
r
>
梯
度
下
降
：
需
要
选
择
学
习
率
α
，
需
要
多
次
迭
代
，
当
特
征
数
量
n
大
时
也
能
较
好
适
用
，
适
用
于
各
种
类
型
的
模
型
<
b
r
>
正
规
方
程
：
不
需
要
选
择
学
习
率
α
，
一
次
计
算
得
出
，
需
要
计
算
梯度下降与正规方程的比较：
梯度下降：需要选择学习率α，需要多次迭代，当特征数量n大时也能较好适用，适用于各种类型的模型
正规方程：不需要选择学习率α，一次计算得出，需要计算
<br>梯度下降与正规方程的比较：<br>梯度下降：需要选择学习率α，需要多次迭代，当特征数量n大时也能较好适用，适用于各种类型的模型<br>正规方程：不需要选择学习率α，一次计算得出，需要计算(XTX){-1}
，
如
果
特
征
数
量
n
较
大
则
运
算
代
价
大
，
因
为
矩
阵
逆
的
计
算
时
间
复
杂
度
为
，如果特征数量n较大则运算代价大，因为矩阵逆的计算时间复杂度为
，如果特征数量n较大则运算代价大，因为矩阵逆的计算时间复杂度为O(n_3)$，通常来说当n小于10000时还是可以接受的，只适用于线性模型，不适合逻辑回归模型等其他模型。
np.linalg.inv求逆 *** 作 @相对于dot(),dot函数可以通过numpy库调用，也可以由数组实例对象进行调用。a.dot(b)与np.dot(a,b)效果相同。
# 正规方程
def normalEqn(X, y):
# your code here (appro ~1 lines)
theta = np.linalg.inv(X.T@X)@X.T@y
return theta
final_theta2 = normalEqn(X, y) # 感觉和批量梯度下降的theta的值有点差距
final_theta2
matrix([[-3.89578088],
[ 1.19303364]])
# 梯度下降得到的结果是matrix([[-3.24140214, 1.1272942 ]])
在练习2中，我们将看看分类问题的逻辑回归。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）