04-梯度下降求解逻辑回归-学习

'''
梯度下降求解逻辑回归
数据：2科考试成绩，1个被学习录取与否（1-录取，0-未录取）


The logistic regression
目标：建立分类器（求解出三个参数01,02,03）
设定阀值，根据阀值判断录取结果（大于0.5，录取，小于0.5未录取）

要求完成模块：
    1、sigmoid：映射到概率的函数
    2、model：返回预测结果值
    3、cost：根据参数计算损失
    4、gradient：计算每个参数的梯度方向
    5、descent：进行参数更新
    6、accuracy：计算精度

'''
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import os
import time

# os.sep 用于系统路径中的分隔符
# Windows系统通过是“\\”，Linux类系统如Ubuntu的分隔符是“/”，而苹果Mac OS系统中是“:”
path = 'data' + os.sep + 'LogiReg_data.txt'
pdData = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted'])
# 因为当前数据第一行不是列明，hender=none不让其默认设置，然后，names--自己定义各个列的列名
# print(pdData.head())    # 默认显示5行rows
# print(pdData.shape)     # (100, 3)  有100个数据，每个数据有3个属性

positive = pdData[pdData['Admitted'] == 1]  # 满足要求
negative = pdData[pdData['Admitted'] == 0]  # 不满足要求

# fig, ax = plt.subplots(figsize=(10, 5))  # 画图域，长10 宽5
# scatter--散点图、label--标签、c=：颜色、marker--散点图图形形状
# ax.scatter(positive['Exam 1'], positive['Exam 2'], s=30, c='b', marker='o', label='Admitted')
# ax.scatter(negative['Exam 1'], negative['Exam 2'], s=30, c='r', marker='x', label='Not Admitted')
# ax.legend()
# ax.set_xlabel("Exam 1 Score")
# ax.set_ylabel("Exam 2 Score")
# plt.show()

# 1、sigmoid：映射到概率的函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

# sigmoid 图形
# nums=np.arange(-10,10,step=1)
# fig,ax=plt.subplots(figsize=(12,4))
# ax.plot(nums,sigmoid(nums),'r')
# plt.show()
# Sigmoid：
#       g:R-->[0,1]
#       g(0)=0.5
#       g(-∞)=0
#       g(+∞)=1

# 2、model：返回预测结果值
def model(X, theta):
    return sigmoid(np.dot(X, theta.T))

# 增加一列，列名为Ones，内容为 1
pdData.insert(0, 'Ones', 1)

# X(训练数据)和y(目标变量)
orig_data = pdData.as_matrix()  # 将数据的panda表示形式转换为对进一步计算有用的矩阵
cols = orig_data.shape[1]
X = orig_data[:, 0:cols - 1]
y = orig_data[:, cols - 1:cols]

# 构造一个1行3列的数组，相当于3个参数
theta = np.zeros([1, 3])


# print(X[:5])
# print(y[:5])
# print(theta)
# print(X.shape,y.shape,theta.shape)


# 3、cost：根据参数计算损失
# 定义损失函数
def cost(X, y, theta):
    left = np.multiply(-y, np.log(model(X, theta)))
    right = np.multiply(1 - y, np.log(1 - model(X, theta)))
    return np.sum(left - right) / (len(X))


# print(cost(X,y,theta))

# 4、gradient：计算每个参数的梯度方向

def gradient(X, y, theta):
    grad = np.zeros(theta.shape)  # 定义梯度
    error = (model(X, theta) - y).ravel()
    for j in range(len(theta.ravel())):  # 遍历参数
        term = np.multiply(error, X[:, j])
        grad[0, j] = np.sum(term) / len(X)
    return grad


# 5、Gradient descent：进行参数更新
# 比较3中不同梯度下降方法：（停止策略）
STOP_ITER = 0  # 根据跌代次数，指定值，停止
STOP_COST = 1  # 根据损失值目标函数的变化，没什么变化则停止
STOP_GRAD = 2  # 根据梯度，梯度变化小，停止


def stopCriterion(type, value, threshold):
    # 设定三种不同的停止策略
    if type == STOP_ITER:
        return value > threshold
    elif type == STOP_COST:
        return abs(value[-1] - value[-2]) < threshold
    elif type == STOP_GRAD:
        return np.linalg.norm(value) < threshold


# 洗牌----打乱顺序，再重新组合成X,y顺序
def shuffleData(data):
    np.random.shuffle(data)
    cols = data.shape[1]
    X = data[:, 0:cols - 1]
    y = data[:, cols - 1:]
    return X, y


# 查看时间对不同梯度变化结果的影响
# data-数据、theta-参数、
# batchSize-为1代表随机梯度下降  为整体值表示批量梯度下降  为某一数值时表示小批量梯度下降
# stopType-停止策略、
# thresh-策略对应的预值、
# alpha-学习率
def descent(data, theta, batchSize, stopType, thresh, alpha):
    # 梯度下降求解
    init_time = time.time()
    i = 0  # 迭代次数
    k = 0  # batch 批处理
    X, y = shuffleData(data)
    grad = np.zeros(theta.shape)  # 计算的梯度
    costs = [cost(X, y, theta)]  # 损失值

    while True:
        grad = gradient(X[k:k + batchSize], y[k:k + batchSize], theta)
        k += batchSize  # 取batch数量个数据
        if k >= n:      # n是在运行的时候指定的，为样本的个数
            k = 0
            X, y = shuffleData(data)  # 重新洗牌
        theta = theta - alpha * grad  # 参数更新
        costs.append(cost(X, y, theta))  # 计算新的损失
        i += 1

        if stopType == STOP_ITER:
            value = i
        elif stopType == STOP_COST:
            value = costs
        elif stopType == STOP_GRAD:
            value = grad
        if stopCriterion(stopType, value, thresh):
            break

    return theta, i - 1, costs, grad, time.time() - init_time


def runExpe(data, theta, batchSize, stopType, thresh, alpha):
    theta, iter, costs, grad, dur = descent(data, theta, batchSize, stopType, thresh, alpha)
    name = "Original" if (data[:, 1] > 2).sum() > 1 else "Scaled"
    name += " data - learning rate: {} - ".format(alpha)
    if batchSize == n:
        strDescType = "Gradient"
    elif batchSize == 1:
        strDescType = "Stochastic"
    else:
        strDescType = "Mini-batch ({})".format(batchSize)
    name += strDescType + " descent - Stop: "
    if stopType == STOP_ITER:
        strStop = "{} iterations".format(thresh)
    elif stopType == STOP_COST:
        strStop = "costs change < {}".format(thresh)
    else:
        strStop = "gradient norm < {}".format(thresh)
    name += strStop
    print("***{}\nTheta: {} - Iter: {} - Last cost: {:03.2f} - Duration: {:03.2f}s".format(
        name, theta, iter, costs[-1], dur))
    fig, ax = plt.subplots(figsize=(12, 4))
    ax.plot(np.arange(len(costs)), costs, 'r')
    ax.set_xlabel('Iterations')
    ax.set_ylabel('Cost')
    ax.set_title(name.upper() + ' - Error vs. Iteration')
    plt.show()
    return theta

不同的停止策略：

1、设定迭代次数

# 选择的梯度下降方法是基于所有样本的
n = 100
runExpe(orig_data, theta, n, STOP_ITER, thresh=5000, alpha=0.000001)

结果：
***Original data - learning rate: 1e-06 - Gradient descent - Stop: 5000 iterations
Theta: [[-0.00027127  0.00705232  0.00376711]] - Iter: 5000 - Last cost: 0.63 - Duration: 0.91s

2、根据损失值停止

# 设定阈值，1E-6，差不多需要110000次迭代
runExpe(orig_data,theta,n,STOP_COST,thresh=0.000001,alpha=0.001)

结果：
***Original data - learning rate: 0.001 - Gradient descent - Stop: costs change < 1e-06
Theta: [[-5.13364014  0.04771429  0.04072397]] - Iter: 109901 - Last cost: 0.38 - Duration: 22.28s

3、根据梯度变化停止

# 设定阈值0.05，差不多需要40000次迭代
runExpe(orig_data,theta,n,STOP_GRAD,thresh=0.05,alpha=0.001)

结果：
***Original data - learning rate: 0.001 - Gradient descent - Stop: gradient norm < 0.05
Theta: [[-2.37033409  0.02721692  0.01899456]] - Iter: 40045 - Last cost: 0.49 - Duration: 8.41s

对比不同的梯度下降方法：

1、Stochastic descent

runExpe(orig_data, theta, 1, STOP_ITER, thresh=5000, alpha=0.001)

结果：
***Original data - learning rate: 0.001 - Stochastic descent - Stop: 5000 iterations
Theta: [[-0.38754976 -0.00051819 -0.07081474]] - Iter: 5000 - Last cost: 3.41 - Duration: 0.33s

很不稳定,试试把学习率调小一些：

runExpe(orig_data, theta, 1, STOP_ITER, thresh=15000, alpha=0.000002)

结果：
***Original data - learning rate: 2e-06 - Stochastic descent - Stop: 15000 iterations
Theta: [[-0.00201906  0.01017018  0.0011356 ]] - Iter: 15000 - Last cost: 0.63 - Duration: 0.83s

速度快，但稳定性差，需要很小的学习率！！

2、Mini-batch descent

runExpe(orig_data, theta, 16, STOP_ITER, thresh=15000, alpha=0.001)

结果：
***Original data - learning rate: 0.001 - Mini-batch (16) descent - Stop: 15000 iterations
Theta: [[-1.03966524  0.04908123  0.03302126]] - Iter: 15000 - Last cost: 1.35 - Duration: 1.27s

浮动仍然比较大，我们来尝试下对数据进行标准化 将数据按其属性(按列进行)减去其均值，然后除以其方差。最后得到的结果是，对每个属性/每列来说所有数据都聚集在0附近，方差值为1。

 

from sklearn import preprocessing as pp

scaled_data = orig_data.copy()
scaled_data[:, 1:3] = pp.scale(orig_data[:, 1:3])

runExpe(scaled_data, theta, n, STOP_ITER, thresh=5000, alpha=0.001)

结果：
***Scaled data - learning rate: 0.001 - Gradient descent - Stop: 5000 iterations
Theta: [[0.3080807  0.86494967 0.77367651]] - Iter: 5000 - Last cost: 0.38 - Duration: 0.98s

原始数据，只能达到0.61，而次时我们得到了0.38！ 所以对数据做预处理是非常重要的！！

runExpe(scaled_data, theta, n, STOP_GRAD, thresh=0.02, alpha=0.001)

结果：
***Scaled data - learning rate: 0.001 - Gradient descent - Stop: gradient norm < 0.02
Theta: [[1.0707921  2.63030842 2.41079787]] - Iter: 59422 - Last cost: 0.22 - Duration: 13.31s

更多的迭代次数会使得损失下降的更多！！

theta = runExpe(scaled_data, theta, 1, STOP_GRAD, thresh=0.002/5, alpha=0.001)

结果：
***Scaled data - learning rate: 0.001 - Stochastic descent - Stop: gradient norm < 0.0004
Theta: [[1.14800304 2.79231051 2.56851242]] - Iter: 72642 - Last cost: 0.22 - Duration: 5.07s

随机梯度下降更快，但是我们需要迭代的次数也需要更多，所以还是用batch的比较合适！！

runExpe(scaled_data, theta, 16, STOP_GRAD, thresh=0.002*2, alpha=0.001)

结果：
***Scaled data - learning rate: 0.001 - Mini-batch (16) descent - Stop: gradient norm < 0.004
Theta: [[1.16423517 2.82728266 2.59887333]] - Iter: 3065 - Last cost: 0.21 - Duration: 0.32s

# 6、accuracy：计算精度
#设定阈值
def predict(X, theta):
    return [1 if x >= 0.5 else 0 for x in model(X, theta)]

scaled_X = scaled_data[:, :3]
y = scaled_data[:, 3]
predictions = predict(scaled_X, theta)
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))

结果：
accuracy = 89%

 

 

"""

视频学习笔记，侵权联系删除

"""