机器学习入门-逻辑回归算法

梯度下降： 对theta1， theta2， theta3 分别求最快梯度下降的方向，然后根据给定的学习率，进行theta1， theta2， theta3的参数跟新

假定目标函数 J(theta) = 1/2m * np.sum(h(theta) - y)^2 / len(X)

梯度下降的策略分为3种，

批量梯度下降： 每次迭代输入全部的数据， 效果好，但耗时

随机梯度下降： 每次输入一个样本，时间快，迭代效果差

小批量梯度下降：每次输入部分数据，效果好，时间适中，一般都是16， 32， 64

逻辑回归： 是一种典型的二分类，也可以是多分类，主要在于cost的定义

逻辑回归的概率似然函数： h(theta)**y * (1-h(theta)) ** (1-y)

逻辑回归的对数似然函数 l(theta) = 1/ m * np.sum(y*logh(theta) - (1-y)*log(1-h(theta)))  # 及损失函数

依据theta对损失函数进行求导，求出梯度下降的方向，用于跟新参数

grad = 1/m np.sum(h(theta) - y) * xj    xj表示的是一列特征

theta = theta - grad

接下来进行代码分析

需要完成的函数

主要函数
sigmoid  #将数值映射为概率

model   # 构造h(theta) 即 sigmoid(np.dot(X, theta.T))

cost     # 计算损失值及对数似然函数  1/ m * np.sum(-y*logh(theta) - (1-y)*log(1-h(theta)))

gradient  # 用于计算梯度  grad = 1/m np.sum(h(theta) - y) * xj

descent  # 用于进行参数更新

runExpe  # 进行画图操作

predict  # 进行结果预测

次要函数
shuffledata  # 用于进行数据清洗

StopCriter   # 停止情况判断

代码：

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

pdData = pd.read_csv(‘data/LogiReg_data.txt‘, header=None, names=[‘exam1‘, ‘exam2‘, ‘admitted‘])

# 插入一列全1的数据, 为了和theta0进行匹配
pdData.insert(0, ‘ones‘, 1)
# 将数据转换的为numpy形式
orig_data = pdData.as_matrix()
# 获得列的维度
cols = orig_data.shape[1]
# 分出样本
X = orig_data[:, :cols-1]
# 分出标签
y = orig_data[:, cols-1:]
# 初始化theta
theta = np.zeros([1, 3])
# 定义sigmoid函数
def sigmoid(z):
    return (1 / (1 + np.exp(-z)))
# 定义H(theta)
def model(X, theta):
    return sigmoid(np.dot(X, theta.T))

# 定义损失函数即对数似然函数   1/ m * np.sum(-y*logh(theta) - (1-y)*log(1-h(theta)))
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)
# 定义数据洗牌的函数
def shuffle_data(data):
    # 进行数据洗牌
    np.random.shuffle(data)
    # 分离出X和y
    cols = data.shape[1]
    X = data[:, :cols-1]
    y = data[:, cols-1:]
    return X, y

# 定义停止条件的函数
Stop_iter = 0
Stop_cost = 1
Stop_grad = 2
def StopCriter(Stop_name, value, threshold):
    # 如果迭代条件是迭代次数，返回迭代比较的结果，真或者假
    if Stop_name == Stop_iter: return value > threshold
    # 如果迭代条件是损失值，返回最后两个损失值之差，如果低于阈值，返回为真
    elif Stop_name == Stop_cost: return value[-2] - value[-1] < threshold
    # 如果迭代条件是梯度下降的方向向量，返回的是梯度下降方向向量的模，如果低于阈值，则返回为真
    elif Stop_name == Stop_grad: return np.linalg.norm(value) < threshold

# 用于计算梯度下降方向的向量 grad = 1/m np.sum(h(theta) - y) * xj
def gradient(X, y, theta):
    # 初始化梯度值
    grad = np.zeros_like(theta)
    # 计算误差 ravel()函数将(100, 1)转换为(100, )
    error = (model(X, theta) - y).ravel()
    # 计算每一个方向上的梯度方向
    for j in range(X.shape[1]):
        term = np.multiply(error, X[:, j])
        grad[0, j] = np.sum(term) / len(X)
    return grad
# 在梯度方向上进行theta的参数更新
def descent(data, theta, batchsize, Stop_name, threshold, alpha):
    # 数据进行洗牌
    X, y = shuffle_data(data)
    k = 0
    # 获得损失值函数
    costs = [cost(X, y, theta)]
    # 迭代次数
    i = 0
    # 初始时间
    init_time = time.time()
    # 循环
    while True:
        # 获得batchsize的样本
        batch_x, batch_y = X[k:k+batchsize], y[k:k+batchsize]
        # 更新k
        k = k + batchsize
        # 如果k大于样本数，置0，重新获得洗牌后的X和y
        if k >= X.shape[0]:
            k = 0
            X, y = shuffle_data(data)
        # 计算梯度方向
        grad = gradient(batch_x, batch_y, theta)
        # 更新参数
        theta = theta - alpha * grad
        # 重新计算损失值
        costs.append(cost(X, y, theta))
        i = i + 1
        # 根据迭代的条件获得当前的value值
        if Stop_name == Stop_iter:value = i
        elif Stop_name == Stop_cost: value=costs
        elif Stop_name == Stop_grad: value=grad
        # 将value值输入，与阈值进行条件比较，满足即跳出循环
        if StopCriter(Stop_name, value, threshold):
            break
    # 返回
    return   data, theta, i, batchsize, Stop_name, threshold, alpha, time.time() - init_time, costs
# 进行画图操作
def runExpe(data, theta, batchsize, Stop_name, threshold, alpha):
    data, theta, i, batchsize, Stop_name, threshold, alpha, dur, costs = descent(data, theta, batchsize, Stop_name, threshold, 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 Stop_name == Stop_iter:
        strStop = "{} iterations".format(threshold)
    elif Stop_name == Stop_cost:
        strStop = "costs change < {}".format(threshold)
    else:
        strStop = "gradient norm < {}".format(threshold)
    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‘)

    return theta

# 预测函数
def predict(X, theta):
    # 代入h(theta) 即model中进行样本预测
    pre_y = model(X, theta)
    # 概率大于0.5的，输出为1， 小于0.5的输出为0
    pre_y[pre_y >= 0.5] = 1
    pre_y[pre_y < 0.5] = 0
    # 返回预测结果的向量
    return pre_y
# 表示样本的总个数
n = 100
# 获得迭代好以后的theta
theta = runExpe(orig_data, theta, 100, Stop_grad, 0.05, alpha=0.001)
# 进行数据归一化操作
import sklearn.preprocessing as pp
scale_data = orig_data.copy()
# 对第二列和第三列数据进行归一化操作
scale_data[:, 1:3] = pp.scale(scale_data[:, 1:3])
# 获得预测结果的向量
pre_y = predict(X, theta)
# 将预测结果与真实结果进行比较，返回0和1的数组，正确是1，错误是0
correct_array = np.array(pre_y == y, dtype=int)
# 准确率就是计算正确和错误的平均值
accurracy = correct_array.mean()
print(accurracy)

迭代次数与损失值cost的作图

原文地址：https://www.cnblogs.com/my-love-is-python/p/10260545.html