004-python实现逻辑回归2/2

"""
    梯度计算：对J(θ)求θ的偏导
"""


def gradient(X, Y, theta):
    grad = np.zeros(theta.shape)  # 根据3个不同的θ求出对应的梯度
    error = (model(X, theta) - Y).ravel()  # 将J(θ)偏导xij之前的那一部分提出来
    for j in range(len(theta.ravel())):  # θ0~θ2，
        term = np.multiply(error, X[:, j])  # 这里计算的不是单个数值，而是一列的数值，每一步需要计算每个样的的θ0，下一次计算每一个样本的θ1...
        grad[0, j] = np.sum(term) / len(X)  # 填充每一个θ的梯度，[1,3]的结构
    return grad


"""
    比较3种不同梯度下降的方法
    批量，随机，小批量

"""

"""
    三种停止方法
"""
STOP_ITER = 0  # 迭代次数
STOP_COST = 1  # 损失值,差异非常小
STOP_GRAD = 2  # 梯度，梯度变化非常小


def stopCriterion(type, value, threshold):  # type=停止方式，value=实际值，threshold=阈值
    if type == STOP_ITER:
        return value > threshold  # 此处value是迭代次数
    elif type == STOP_COST:
        return abs(value[-1] - value[-2]) < threshold  # 此处value是损失值，用最后一个损失值减去倒数第二个损失值，看看是否小于阈值
    elif type == STOP_GRAD:
        return np.linalg.norm(value) < threshold  # 此处value是梯度，求矩阵的范数，看看是否收敛


"""
    洗牌，打乱数据顺序
"""


def shuffleData(data):
    np.random.shuffle(data)
    cols = data.shape[1]
    X = data[:, 0:cols - 1]  # 洗牌后取X
    Y = data[:, cols - 1:]  # 洗牌后取Y
    return X, Y


"""
    看时间的影响
"""

import time


def descent(data, theta, batchSize, stopType, thresh,
            alpha):  # 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 = k + batchSize
        if k >= n:  # 样本数
            k = 0
            X, Y = shuffleData(data)  # 洗牌
        theta = theta - alpha * grad  # 参数更新
        costs.append(cost(X, Y, theta))  # 计算新的损失值，要画图，所以要每一次的损失值
        i = 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)  # dur是用时
    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 + 'descentStop:'
    if stopType == STOP_ITER:
        strStop = "{}-iterations".format(thresh)
    elif stopType == STOP_COST:
        strStop = "cost 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


"""
    不同停止策略
"""
"""
    设定迭代次数
"""
# 选择梯度下降的方法是基于所有样本的
n = 100  # 样本数100
runExpe(orig_data, theta, n, STOP_ITER, thresh = 5000, alpha = 0.000001)  # 迭代次数5000次，

"""
    根据损失值停止
"""
n = 100
runExpe(orig_data, theta, n, STOP_COST, thresh = 0.000001, alpha = 0.001)

"""
    根据梯度下降值停止
"""
n = 100
runExpe(orig_data, theta, n, STOP_GRAD, thresh = 0.05, alpha = 0.001)

"""
    不同梯度下降方法
"""
# 随机样本
n = 1
runExpe(orig_data, theta, n, STOP_ITER, thresh = 5000, alpha = 0.001)

# 随机样本-调小学习率
n = 1
runExpe(orig_data, theta, n, STOP_ITER, thresh = 15000, alpha = 0.000002)

# 小批量样本
n = 16
runExpe(orig_data, theta, n, STOP_ITER, thresh = 15000, alpha = 0.001)

"""
    数据标准化：
        将其数据按列减去均值，然后除以方差，最后得到的结果是，对每个属性（按列）
        所有数据的均值都是0，方差为1
"""
from sklearn import preprocessing as pp
n = 1
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)

# 批量梯度下降
n = 100
runExpe(scaled_data, theta, n, STOP_GRAD, thresh = 0.02, alpha = 0.001)

# 小批量梯度下降
n = 16
runExpe(scaled_data, theta, n, STOP_GRAD, thresh = 0.02*2, alpha = 0.001)

"""
    精度
"""


# 设定阈值
def predict(X, theta):  # 分类函数
    return [1 if x >= 0.5 else 0 for x in model(X, theta)]  # 概率大于0.5能被录取，概率小鱼0.5则不能被录取


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('accurent ={0}%'.format(accuracy))