线性回归与逻辑回归

---

介绍

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

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

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
A = np.eye(5)
print(A)

[[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

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

要点：

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

###在这里填入代码###
 
data.plot(kind='scatter', x='Population', y='Profit', figsize=(12,8))
plt.show()

2.2 梯度下降

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

2.2.1 更新公式

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

假设hθ(X)hθ(X)由以下线性模型给出：

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

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

(同时更新所有的θjθj）

2.2.2 实现

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

接下来，我们在数据中添加了一个维度来拟合截距项θ0θ0。并将初始参数值设为0，学习率αα设为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

2.2.3 计算成本J(θ)

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

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

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

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

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

###在这里填入代码###
 
def computeCost(X, y, w):
    inner = np.power(((X * w) - y), 2)
    return np.sum(inner) / (2 * len(X))
 
 
w = np.matrix(np.zeros((2,1)))
computeCost(X, y, w)

2.2.4 梯度下降

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

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

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

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

要点：

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

###在这里填入代码###
def gradientDescent(X, y, w, alpha, iters):
    temp = np.matrix(np.zeros(w.shape))
    parameters = int(w.ravel().shape[1])
    cost = np.zeros(iters)
    for i in range(iters):
        error = (X * w) - y
        for j in range(parameters):
            term = np.multiply(error, X[:,j])
            temp[j,0] = w[j,0] - ((alpha / len(X)) * np.sum(term))
        w = temp
        cost[i]=computeCost(X,y,w)
    return w, cost

# 计算最终的参数所得到的成本值
w_final, cost_final = gradientDescent(X, y, w, alpha, iterations)
# 计算最终的参数所得到的成本值
print('The weight vector:\n',w_final)
computeCost(X, y, w_final)

###在这里填入代码###
#对拟合曲线进行绘制
x = np.linspace(data.Population.min(), data.Population.max(), 100)
f = w_final[0,0] + (w_final[1,0] * x)
 
fig, ax = plt.subplots(figsize=(9,6))
ax.plot(x, f, 'b', label='Prediction')
ax.scatter(data.Population, data.Profit, c='red',label='Traning Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')

2.3 可视化成本函数

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

选做练习

3 多变量线性回归

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

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

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

3.1 特征标准化

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

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

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

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

要点：

从数据集中减去每个特征的平均值。
减去平均值后，再将新的特征值除以各自的“标准差”
标准差是一种衡量特定特征的值的范围内有多大变化的方法（大多数数据点将位于平均值的两个标准差内）；这是取值范围的替代方法。

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

###在这里填入代码###
 
data2 = (data2 - data2.mean()) / data2.std()
data2.head()

3.2 梯度下降

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

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

要点：

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

###在这里填入代码###
 
# 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 initialize theta
X2 = np.matrix(X2.values)
y2 = np.matrix(y2.values)
w2 = np.matrix(np.array([0,0,0]))
 
# perform linear regression on the data set
w2_final, cost2_final = gradientDescent(X2, y2, w2.T, alpha, iterations)
 
# perform linear regression on the data set
 
##============================================================= 
# get the cost (error) of the model
print('The weight vector:\n',w2_final)
computeCost(X2, y2, w2_final)
 
fig, ax = plt.subplots(figsize=(9,6))
ax.plot(np.arange(iterations), cost2_final, 'r')
ax.set_xlabel('Iterations')
ax.set_ylabel('Cost')
ax.set_title('Error vs. Iterations')

1 Logistic回归

在该部分练习中，将建立一个逻辑回归模型，用以预测学生能否被大学录取。

假设你是大学某个部门的负责人，你要根据两次考试的结果来决定每个申请人的入学机会。目前已经有了以往申请者的历史数据，并且可以用作逻辑回归的训练集。对于每行数据，都包含对应申请者的两次考试分数和最终的录取结果。

在本次练习中，你需要建立一个分类模型，根据这两次的考试分数来预测申请者的录取结果。

1.1 数据可视化

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

path = 'ex2data1.txt'
data = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted'])
data.head()

positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]

fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()
ax.set_xlabel('Exam 1 Score')
ax.set_ylabel('Exam 2 Score')
plt.show()

1.2 实现

在前部分练习中所绘制的数据分布图中可以看出，在不同标识的数据点间，有一个较为清晰的决策边界。现在需要实现逻辑回归，并使用逻辑回归来训练模型用以预测分类结果。

1.2.1 Sigmoid函数

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

nums = np.arange(-10, 10, step=1)

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(nums, sigmoid(nums), 'r')
plt.show()

1.2.2 代价函数和梯度

1.2.2.1 代价函数

###在这里填入代码###
def cost(theta,X,y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y,np.log(sigmoid(X* theta.T)))
    second = np.multiply((1-y),np.log(1-sigmoid(X*theta.T)))
    return np.sum(first-second)/(len(X))

###请运行并测试你的代码###
#增加一列值为1，这和我们在练习1中的操作很相似
data.insert(0, 'Ones', 1)

# 定义X为训练数据，y为目的变量
cols = data.shape[1]
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]

# 将X,y转换为numpy数组，并初始化theta值为0
X = np.array(X.values)
y = np.array(y.values)
theta = np.zeros(3)

cost(theta, X, y)

结果：

1.2.2.2 梯度下降

def gradient(theta, X, y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    
    parameters = int(theta.ravel().shape[1])
    grad = np.zeros(parameters)
    
    error = sigmoid(X * theta.T) - y
    
    for i in range(parameters):
        term = np.multiply(error, X[:,i])
        grad[i] = np.sum(term) / len(X)
    
    return grad

gradient(theta, X, y)

结果：

1.2.3 寻找最优参数

现在可以用SciPy’s truncated newton（TNC）实现寻找最优参数。

1.2.4 评估逻辑回归

def predict(theta, X):
    probability = sigmoid(X * theta.T)
    return [1 if x >= 0.5 else 0 for x in probability]

theta_min = np.matrix(result[0])
predict(theta_min, X)

结果：

predictions = predict(theta_min, X)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

结果：

二、逻辑回归

2 正则化逻辑回归

在本部分练习中，我们将要通过加入正则项提升逻辑回归算法。

正则化是成本函数中的一个术语，它使算法更倾向于“更简单”的模型。这个理论助于减少过拟合，提高模型的泛化能力。

设想你是工厂的生产主管，你有一些芯片在两次测试中的测试结果。对于这两次测试，你想决定芯片是要被接受或抛弃。为了帮助你做出艰难的决定，你拥有过去芯片的测试数据集，从其中你可以构建一个逻辑回归模型。

2.1 数据可视化

对于这部分数据，我们可以看出不同类别的数据点之间没有明显的线性决策界限用于划分两类数据。

因此，逻辑回归无法在此数据集上得到较好的效果，因为逻辑回归只能知道线性决策边界。

2.2 特征映射

2.3 代价函数和梯度

def costReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    first = np.multiply(-y, np.log(sigmoid(X * theta.T)))
    second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
    reg = (learningRate / (2 * len(X))) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))
    return np.sum(first - second) / len(X) + reg

def gradientReg(theta, X, y, learningRate):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    
    parameters = int(theta.ravel().shape[1])
    grad = np.zeros(parameters)
    
    error = sigmoid(X * theta.T) - y
    
    for i in range(parameters):
        term = np.multiply(error, X[:,i])
        
        if (i == 0):
            grad[i] = np.sum(term) / len(X)
        else:
            grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i])
    
    return grad

接下来，类似于第一部分的练习中，进行变量的初始化。

# 从数据集中取得对应的特征列和标签列
cols = data2.shape[1]
X2 = data2.iloc[:,1:cols]
y2 = data2.iloc[:,0:1]

# 转换为Numpy数组并初始化theta为零矩阵
X2 = np.array(X2.values)
y2 = np.array(y2.values)
theta2 = np.zeros(11)

# 设置初始学习率为1，后续可以修改
learningRate = 1

接下来，使用初始化的变量值来测试你实现的代价函数和梯度函数。

costReg(theta2, X2, y2, learningRate)

gradientReg(theta2, X2, y2, learningRate)

2.4 寻找最优参数

result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))
result2

2.5 评估正则化逻辑回归

最后，我们可以使用第1部分中的预测函数来查看我们的方案在训练数据上的准确度。

theta_min = np.matrix(result2[0])
predictions = predict(theta_min, X2)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y2)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))