ex I-代码实现

单变量线性回归

在本部分的练习中，您将使用一个变量实现线性回归，以预测食品卡车的利润。假设你是一家餐馆的首席执行官，正在考虑不同的城市开设一个新的分店。该连锁店已经在各个城市拥有卡车，而且你有来自城市的利润和人口数据。

您希望通过使用这些数据来帮助您扩展到下一个城市；

Step1: Prepare datasets

按照吴老师上课时候所说的来准备数据,取最后一列为目标向量,剩余列为输入矩阵X,最重要的是记得在第一列加入新的一列,数值全部为1

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

'''
单变量线性回归
1.Prepare datasets
'''
path = 'ex1data1.txt'
data = pd.read_csv(path, header=None, names=['Population', 'Profit'])   # names添加列名，header用指定的行来作为标题，若原无标题且指定标题则设为None
data.head()         # head()查看前5行，若为-1，则查看至倒数第二行
# print(data.head())
data.describe()     # describe快速统计汇总数据内容 
# print(data.describe())
# 展示散点图，可视化理解数据
# data.plot(kind='scatter', x='Population', y='Profit', figsize=(8, 5))
# plt.show()

data.insert(0, 'Ones', 1)       # 加入至第一列，全部数值为1
# print(data)

# 变量初始化:set X (training data) and y (target variable)
cols = data.shape[1]  # 列数
X = data.iloc[:, 0:cols - 1]        # iloc根据位置索引选取数据，先行后列,取前cols-1列作为输入向量
y = data.iloc[:, cols - 1:cols]     # 取最后一列作为目标向量
# print(X.head())
# print(y.head())

X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix([0, 0])
print(X.shape, y.shape, theta.shape)  # 查看各自的行列数

Step2: Design model using Gradient Descent

首先, 我们将创建一个以参数$\theta$为特征函数的代价函数
$$J(\theta )=\frac{1}{2m}\sum _{i=1}^m{\left(h_{\theta }\left(x^{(i)}\right)-y^{(i)}\right)}^2$$
其中: $h_{\theta }(x)={\theta }^{T}X={\theta }_0{x}_0+{\theta }_1{x}_1+{\theta }_2{x}_2+\dots +{\theta }_n{x}_n$
计算代价函数 $J(\theta )$

'''
2.Design model using Gradient Descent
'''
def computeCost(X, y, theta):
    '''
    作用：计算代价函数,向量化来计算参数
    :param X: 输入矩阵
    :param y: 输出目标
    :param theta: parameters
    :return:
    '''
    inner = np.power(((X * theta.T) - y), 2)
    # print(inner)
    return sum(inner) / (2 * len(X))


# testing
# computeCost(X, y, theta)  # 32.07273388

注意：这里我使用的是matix而不是array，两者基本通用。

但是matrix的优势就是相对简单的运算符号，比如两个矩阵相乘，就是用符号*，但是array相乘不能这么用，得用方法.dot()
array的优势就是不仅仅表示二维，还能表示3、4、5…维，而且在大部分Python程序里，array也是更常用的。

两者区别：

对应元素相乘：matrix可以用np.multiply(X2,X1)，array直接X1X2
点乘：matrix直接X1X2，array可以 X1@X2 或 X1.dot(X2) 或 np.dot(X1, X2)
代价函数是应该是numpy矩阵，所以我们需要转换X和Y，然后才能使用它们。 我们还需要初始化theta。

优化:
$$\begin{array}{c}{\theta }_j:={\theta }_j-\alpha \frac{\partial }{\partial {\theta }_j}J(\theta )\\ {\theta }_j:={\theta }_j-\alpha \frac{1}{m}{\sum }_{i=1}^m\left(h_{\theta }\left(x^{(i)}\right)-y^{(i)}\right)x_j^{(i)}\end{array}$$
使用 vectorization同时更新所有的 $\theta$, 可以大大提高效率

def gradientDescent(X, y, theta, alpha, epoch):
    '''
    作用:获得最终梯度下降后的theta值以及cost
    :param X:
    :param y:
    :param theta:
    :param alpha:
    :param epoch:
    :return:
    '''
    # 变量初始化，储存数据
    temp = np.matrix(np.zeros(theta.shape))  # 初始化一个临时矩阵(1, 2)
    # flatten()即返回一个折叠成一维的数组。但是该函数只能适用于numpy对象，即array或者mat，普通的list列表是不行的。
    parameters = int(theta.flatten().shape[1])  # 参数theta的数量
    cost = np.zeros(epoch)  # 初始化一个ndarray, 包含每次训练后的cost
    counterTheta = np.zeros((epoch, 2))
    m = X.shape[0]  # 样本参数

    for i in range(epoch):
        '''
        使用 vectorization同时更新所有的θ，可以大大提高效率,此处都是相对应的进行计算
        X.shape, theta.shape, y.shape, X.shape[0]
        ((97, 2), (1, 2), (97, 1), 97)
        '''
        temp = theta - (alpha / m) * (X * theta.T - y).T * X

        # 以下是不用Vectorization求解梯度下降
        # error = (X * theta.T) - y  # (97, 1)
        # for j in range(parameters):
        #    term = np.multiply(error, X[:,j])  # (97, 1)
        #    temp[0,j] = theta[0,j] - ((alpha / m) * np.sum(term))  # (1,1)

        theta = temp
        counterTheta[i] = theta
        cost[i] = computeCost(X, y, theta)
        pass
    return counterTheta, theta, cost

Step3: Run model and Plot

最后一步就是将准备好的数据输入到相应的模型,得出两个图,第一个图是拟合数据图,第二个图是代价图

'''
3.Run model and Plot
'''

alpha = 0.01
epoch = 3800

counterTheta, final_theta, cost = gradientDescent(X, y, theta, alpha, epoch)
computeCost(X, y, final_theta)

x = np.linspace(data.Population.min(), data.Population.max(), 100)  # xlabel
f = final_theta[0, 0] + (final_theta[0, 1] * x)  # ylabel profit

fig1, ax = plt.subplots(figsize=(6, 4))
ax.plot(x, f, 'r', label='Prediction')
ax.scatter(data.Population, data.Profit, label='Training Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')

fig2, ax = plt.subplots(figsize=(8, 4))
ax.plot(np.arange(epoch), cost, 'r')
ax.set_xlabel('Iteration')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Training Epoch')
plt.show()

可以看出来拟合的相当不错

最后大概是收敛到4.47左右,如以下图

使用别的方法同样可以达到以上成果

1.normal equation(正规方程)

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

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

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

def normalEqu(X, y):
    theta = np.linalg.inv(X.T@X)@X.T@y      # X.T@X等价于X.T.dot(X)
    return theta

final_theta2 = normalEqu(X, y)

x = np.linspace(data.Population.min(), data.Population.max(), 100)  # xlabel
f = final_theta[0, 0] + (final_theta[0, 1] * x)  # ylabel profit

fig3, ax = plt.subplots(figsize=(6, 4))
ax.plot(x, f, 'r', label='Prediction')
ax.scatter(data.Population, data.Profit, label='Training Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
plt.show()

调用sklearn库来进行拟合

接着上面代码来

from sklearn import linear_model

'''
2.Design model using sklearn
'''
model = linear_model.LinearRegression()
model.fit(X, y)
# print(X)
# print(X[:, 1].A1.shape)
x = np.array(X[:, 1].A1)    # numpy.matrix[:, 1].A1-->取矩阵的第二列 转换成一维的
f = model.predict(X).flatten()  # 预测之后也转换成一维的

fig, ax = plt.subplots(figsize=(8, 5))
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()

多向量线性回归

这是ex1中另外一组数据,是多维的数据,其中包括房子的大小,以及卧室的多少,这个时候可以运用到一个小技巧就是特征值归一化

具体的不多说,看代码和图,可直接复制并且运行.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

'''
多变量线性回归
1.Prepare datasets
'''
path = 'ex1data2.txt'
data = pd.read_csv(path, header=None, names=['Size', 'Bedroom', 'Price'])   # names添加列名，header用指定的行来作为标题，若原无标题且指定标题则设为None
data.head()         # head()查看前5行，若为-1，则查看至倒数第二行
# print(data.head)
# 预处理-特征值归一化
data = (data - data.mean())/data.std()      # std为标准差
data.head()
# print(data.head)
# add ones column
data.insert(0, 'Ones', 1)

# set X (training data) and y (target variable)
cols = data.shape[1]
X = data.iloc[:, 0:cols - 1]
y = data.iloc[:, cols - 1:cols]

# convert to matrices and initialize theta
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix(np.array([0, 0, 0]))

'''
2.Design model using Gradient Descent
'''


def computeCost(X, y, theta):
    '''
    作用：计算代价函数,向量化来计算参数
    :param X: 输入矩阵
    :param y: 输出目标
    :param theta: parameters
    :return:
    '''
    inner = np.power(((X * theta.T) - y), 2)
    # print(inner)
    return sum(inner) / (2 * len(X))


# testing
# computeCost(X, y, theta)  # 32.07273388


def gradientDescent(X, y, theta, alpha, epoch):
    '''
    作用:获得最终梯度下降后的theta值以及cost
    :param X:
    :param y:
    :param theta:
    :param alpha:
    :param epoch:
    :return:
    '''
    # 变量初始化，储存数据
    temp = np.matrix(np.zeros(theta.shape))  # 初始化一个临时矩阵(1, 2)
    # flatten()即返回一个折叠成一维的数组。但是该函数只能适用于numpy对象，即array或者mat，普通的list列表是不行的。
    parameters = int(theta.flatten().shape[1])  # 参数theta的数量
    cost = np.zeros(epoch)  # 初始化一个ndarray, 包含每次训练后的cost
    counterTheta = np.zeros((epoch, 3))
    m = X.shape[0]  # 样本参数

    for i in range(epoch):
        '''
        使用 vectorization同时更新所有的θ，可以大大提高效率,此处都是相对应的进行计算
        X.shape, theta.shape, y.shape, X.shape[0]
        ((97, 2), (1, 2), (97, 1), 97)
        '''
        temp = theta - (alpha / m) * (X * theta.T - y).T * X

        # 以下是不用Vectorization求解梯度下降
        # error = (X * theta.T) - y  # (97, 1)
        # for j in range(parameters):
        #    term = np.multiply(error, X[:,j])  # (97, 1)
        #    temp[0,j] = theta[0,j] - ((alpha / m) * np.sum(term))  # (1,1)

        theta = temp
        counterTheta[i] = theta
        cost[i] = computeCost(X, y, theta)
        pass
    return counterTheta, theta, cost


'''
3.Run model and Plot
'''

alpha = 0.01
epoch = 3800

counterTheta, final_theta, cost = gradientDescent(X, y, theta, alpha, epoch)
computeCost(X, y, final_theta)

fig2, ax = plt.subplots(figsize=(8, 4))
ax.plot(np.arange(epoch), cost, 'r')
ax.set_xlabel('Iteration')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Training Epoch')
plt.show()

参考链接:
https://blog.csdn.net/Cowry5/article/details/80174130

多变量线性回归
题目：通过两个特征变量房子的大小和卧室的数量来预测房子的价格
编写程序的过程

一.要引进的库和导入数据集

1.要引进的库

import numpy as np
import pandas as pd
import matplotlib 
import matplotlib.pyplot as plt
matplotlib.rcParams['font.sans-serif']=['SimHei']#用黑体显示中文

2.导入数据集

df=pd.read_csv('C:/Users/Administrator/AppData/Local/Temp/Temp1_machine-learning-ex1.zip/machine-learning-ex1/ex1/ex1data2.txt',
               header=None,
               names=['房子的大小','卧室的数量','房子的价格'])
df.head()           

显示输出结果：

可以发现特征变量之间的值不在一个相近的范围内，所以要对特征变量进行特征缩放

X =df.loc[:,['房子的大小','卧室的数量']]
y=df.loc[:,'房子的价格']
X=(X-X.mean())/X.std()
X.insert(0,'ones',1)
X.head()

补充：1.X.mean()默认是跨行求均值。这里的X是指特征缩放前的X

2.特征缩放是要将特征变量的值在一个相似的范围内。
在运用梯度下降算法时，如果特征变量的值不在一个相似的范围内，要对特征变量进行特征缩放，否则会影响收敛

二.初始化变量

X=np.matrix(X.values)
y=np.matrix(y.values)
theta=(np.matrix([0,0,0])).T
X.shape   # 检查他们的维数
y.shape
theta.shape

三.定义代价函数和梯度下降算法

1.定义代价函数

def computeCost(x,y,theta):
    inner=np.sum(np.power((theta.T*x.T-y),2))
    return inner/(2*len(x))   

2.定义梯度下降函数

def gradientDescent(x,y,theta,alpha,iters):
    temp=np.matrix(np.zeros(theta.shape))
    cost=np.zeros(iters)
    for i in range(iters):
        temp=theta-(alpha/len(x))*((theta.T*x.T-y)*x).T
        theta=temp
        cost[i]=computeCost(x,y,theta)
    return theta,cost

3.调用梯度下降函数

alpha=0.001
iters=10000
finally_theta,cost=gradientDescent(X,y,theta,alpha,iters)

可以发现,theta的值很大

四.绘制代价函数随迭代次数增加的变化曲线

x=np.arange(iters)
fig,ax=plt.subplots()
ax.plot(x,cost,'r')
ax.set_xlabel('迭代次数')
ax.set_ylabel('代价函数值')
ax.set_title('代价函数随迭代次数增加的变化曲线')
plt.show()

输出结果为：
观察曲线，发现其收敛。
只对特征变量进行特征放缩以后，theta的取值比较大。
下面对对特征变量和标签变量同时进行特征缩放，然后运用梯度下降算法。
1.特征缩放

df.head()

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

2.初始化

df.insert(0,'ones',1)
X=df.loc[:,['ones','房子的大小','卧室的数量']]
y=df.loc[:,'房子的价格']
X=np.matrix(X.values)
y=np.matrix(y.values)
theta=(np.matrix([0,0,0])).T
X.shape
y.shape
theta.shape

输出结果为：

3.调用梯度下降算法

alpha=0.001
iters=10000
finally_theta,cost=gradientDescent(X,y,theta,alpha,iters)

可以发现，不对y进行特征缩放和对y进行特征缩放最后所得到的参数theta相差很大

x=np.arange(iters)
fig,ax=plt.subplots()
ax.plot(x,cost,'r')
ax.set_xlabel('迭代次数')
ax.set_ylabel('代价函数值')
ax.set_title('代价函数随迭代次数增加的变化曲线')
plt.show()

输出结果为：

补充：
学习速率alpha会影响收敛速度
当迭代次数—代价函数没有收敛时，可以适当增大alpha和iters.