吴恩达机器学习作业二——逻辑回归

有了作业一的铺垫，作业二的代码更容易理解了。

逻辑回归

题目描述：在训练的初始阶段，我们将要构建一个逻辑回归模型来预测，某个学生是否被大学录取。设想你是大学相关部分的管理者，想通过申请学生两次测试的评分，来决定他们是否被录取。现在你拥有之前申请学生的可以用于训练逻辑回归的训练样本集。对于每一个训练样本，你有他们两次测试的评分和最后是被录取的结果。为了完成这个预测任务，我们准备构建一个可以基于两次测试评分来评估录取可能性的分类模型。

导入数据库

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])]#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()

模型假设（ Sigmoid function）

代码实现：

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()

代价函数（ Cost function）

代码实现：

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

设置数据

data.insert(0, 'Ones', 1)#在数据第0列插入列名为ones的一列，值均为1.

# set X (training data) and y (target variable)#建立训练集和目标集
cols = data.shape[1]
X = data.iloc[:,0:cols-1]#X为所有行，0到倒数第二列
y = data.iloc[:,cols-1:cols]#y为所有行，最后一列

# convert to numpy arrays and initalize the parameter array theta
X = np.array(X.values)
y = np.array(y.values)#把x和y转化为数组
theta = np.zeros(3)#把θ初始化为全0一维矩阵

检查数据维度

X.shape, theta.shape, y.shape

计算代价函数初始值

cost(theta, X, y)#0.69314718055994529

梯度下降（gradient descent)

使用梯度下降算法最小化代价函数

def gradient(theta, X, y):
    theta = np.matrix(theta)
    X = np.matrix(X)
    y = np.matrix(y)
    
    parameters = int(theta.ravel().shape[1])#parameters为θ矩阵的列数
    grad = np.zeros(parameters)#grad为全0一维数组，1*3数组
    
    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 #grad即为代价函数的偏导数

计算结果

gradient(theta, X, y)
#array([ -0.1       , -12.00921659, -11.26284221])

注意，我们实际上没有在这个函数中执行梯度下降，我们仅仅在计算梯度。在练习中，一个称为“fminunc”的Octave函数是用来优化函数来计算成本和梯度参数。由于我们使用Python，我们可以用SciPy的“optimize”命名空间来做同样的事情。

这里我们使用的是高级优化算法SciPy’s truncated newton（TNC），运行速度通常远远超过梯度下降。方便快捷。
只需传入cost函数，已及所求的变量theta，和梯度。（cost函数定义变量时变量tehta要放在第一个，若cost函数只返回cost，则设置fprime=gradient）。
运用最高级优化算法求θ。

import scipy.optimize as opt
result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
result
#结果为array([-25.1613186 ,   0.20623159,   0.20147149]), 36, 0

此时代价函数计算结果

cost(result[0], X, y)
#0.20349770158947464

逻辑回归模型评估

接下来，我们需要编写一个函数，用我们所学的参数theta来为数据集X输出预测。

代码实现

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])
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)]#表示预测值，b表示实际值
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))
#accuracy = 89%

可以看到我们预测精度达到了89%

正则化逻辑回归

在训练的第二部分，我们将要通过加入正则项提升逻辑回归算法。正则化使算法更倾向于“更简单”的模型（在这种情况下，模型将更小的系数）。这个理论助于减少过拟合，提高模型的泛化能力。
题目描述：设想你是工厂的生产主管，你有一些芯片在两次测试中的测试结果。对于这两次测试，你想决定是否芯片要被接受或抛弃。为了帮助你做出艰难的决定，你拥有过去芯片的测试数据集，从其中你可以构建一个逻辑回归模型。

查看数据

path =  'ex2data2.txt'
data2 = pd.read_csv(path, header=None, names=['Test 1', 'Test 2', 'Accepted'])
data2.head()

绘制散点图

positive = data2[data2['Accepted'].isin([1])]
negative = data2[data2['Accepted'].isin([0])]

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

这个数据看起来可比前一次的复杂得多。特别地，你会注意到其中没有线性决策界限，来良好的分开两类数据。一个方法是用像逻辑回归这样的线性技术来构造从原始特征的多项式中得到的特征。让我们通过创建一组多项式特征入手吧。

创建多项式特征

degree = 5
x1 = data2['Test 1']
x2 = data2['Test 2']

data2.insert(3, 'Ones', 1)

for i in range(1, degree):
    for j in range(0, i):
        data2['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j)

data2.drop('Test 1', axis=1, inplace=True)
data2.drop('Test 2', axis=1, inplace=True)

data2.head()

正则化代价函数

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

梯度下降算法

如果我们要使用梯度下降法令这个代价函数最小化，因为我们未对 𝜃0 进行正则化，所以梯度下降算法将分两种情形：

计算梯度的函数

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

初始化变量

# set X and y (remember from above that we moved the label to column 0)
cols = data2.shape[1]
X2 = data2.iloc[:,1:cols]
y2 = data2.iloc[:,0:1]

# convert to numpy arrays and initalize the parameter array theta
X2 = np.array(X2.values)
y2 = np.array(y2.values)
theta2 = np.zeros(11)
#初始学习率到一个合理值
learningRate = 1

调用新的默认为0的theta的正则化函数，以确保计算工作正常。

costReg(theta2, X2, y2, learningRate)计算初始情况下代价函数值
#0.6931471805599454

调用函数计算初始梯度

gradientReg(theta2, X2, y2, learningRate)
'''
array([ 0.00847458,  0.01878809,  0.05034464,  0.01150133,  0.01835599,
        0.00732393,  0.00819244,  0.03934862,  0.00223924,  0.01286005,
        0.00309594])
'''

使用优化算法计算合适的θ参数

result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))
result2
'''
(array([  1.22702519e-04,   7.19894617e-05,  -3.74156201e-04,
         -1.44256427e-04,   2.93165088e-05,  -5.64160786e-05,
         -1.02826485e-04,  -2.83150432e-04,   6.47297947e-07,
         -1.99697568e-04,  -1.68479583e-05]), 96, 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))
#accuracy = 77%

优化

我们还可以使用高级Python库像scikit-learn来解决这个问题。

from sklearn import linear_model#调用sklearn的线性回归包
model = linear_model.LogisticRegression(penalty='l2', C=1.0)
model.fit(X2, y2.ravel())
'''
LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,
          verbose=0, warm_start=False)
'''

model.score(X2, y2)
#0.66101694915254239