从0开始实现逻辑回归算法(LogicRegression)

逻辑回归（LR）算法是一个比较常见的二元分类算法，通常只预测正例的概率，如给定一个样本x，预测出来的结果为0.4，那么表示方法就是p(y=1|x)=0.4，也就是说在给定样本x的情况下，通过LR预测出来正例的概率为0.4，反之,为负例的概率为0.6，即p(y=0|x)=0.6。

逻辑回归的数学表示为Y_hat=sigmoid(X*W+b)，函数原型和线性模型很相似，实质上LR本质上是一个线性模型，可以从广义线性模型和伯努利分布进行推导这个模型，本文就不做推导了。其实有一个问题一直摆在很多初学者的面前，为啥公式是这个样子的，为啥不是其它的。其实，机器学习的目标是什么，是找到一个参数，我们输入样本，输出结果。那么最简单的表示是通过一个式子来表示我们的这个过程。理论上，总有一个公式来拟合我们的数据，比如牛顿定律F=ma，其实也可以理解为一个模型，参数为a，质量m为样本，那么受到的力为F，F就是我们的目标。LR这个公式也可以这么理解。

想要实现LR并不难，主要要理解cost function和梯度的算法。如果用tensorflow这类的框架，甚至不用求梯度，只用给出cost function即可。下面我将给出LR的实现代码，这个代码是可以正常工作的，main函数就是用iris数据集进行的测试。

from sklearn import datasets
from sklearn import metrics

import matplotlib.pyplot as plt
import numpy as np


def softmax(X):
    return (np.exp(X) / (np.exp(X).sum(axis=0)))


def sigmod(X):
    return (1) / (1 + np.exp(-X))


def score(W, b, X_test, Y_test):
    m = X_test.shape[0]
    Y_ = predict(W, b, X_test)
    Y2 = np.array([1 if i > 0.5 else 0 for i in Y_]).reshape(m, 1)
    accuracy = metrics.accuracy_score(Y_test, Y2)
    return accuracy


def cost_gradient_descent(X, Y, W, b, learning_rate, lamda):
    Z = np.dot(X, W) + b
    Y_ = sigmod(Z)
    m = X.shape[0]

    Y2 = np.array([1 if i > 0.5 else 0 for i in Y_]).reshape(m, 1)
    accuracy = metrics.accuracy_score(Y, Y2)

#     J = -(Y.T.dot(np.log(Y_)) + (1 - Y).T.dot(np.log(1 - Y_))).sum() / m
#
#     W = W - (learning_rate *
#              (1 / m) * (X.T.dot(Y_ - Y)) + 0)

    J = -(Y.T.dot(np.log(Y_)) + (1 - Y).T.dot(np.log(1 - Y_))).sum() / \
        m + lamda * (np.square(W).sum(axis=0)) * (1 / (2 * m))

    W = W - (learning_rate *
             (1 / m) * (X.T.dot(Y_ - Y)) + (1 / m) * W * lamda)
    b = b - learning_rate * (1 / m) * ((Y_ - Y).sum(axis=0))
#     b = b - (learning_rate * (1 / m)
#              * ((Y_ - Y).sum(axis=0)) + (1 / m) * b * lamda)
    # b一般不进行正则化
    return J, W, b, accuracy


def predict(W, b, X):
    Z = np.dot(X, W) + b
    Y_ = sigmod(Z)
    m = X.shape[0]
    Y2 = np.array([1 if i > 0.5 else 0 for i in Y_]).reshape(m, 1)
    return Y2


def train(X, Y, iter_num=1000):
    # define parameter
    m = X.shape[0]
    n = X.shape[1]
    W = np.ones((n, 1))
    b = 0
    learning_rate = 0.01
    lamda = 0.01
    i = 0
    J = []
    Accuracy = []
    while i < iter_num:
        i = i + 1
        j, W, b, accuracy = cost_gradient_descent(
            X, Y, W, b, learning_rate, lamda)
        J.append(j)
        Accuracy.append(accuracy)
        print("step:", i, "cost:", j, "accuracy:", accuracy)
    print(W)
    print(b)
    plt.plot(J)
    plt.plot(Accuracy)
    plt.show()
    return W, b


def main():
    # construct data
    iris = datasets.load_iris()
    X, Y = iris.data, iris.target.reshape(150, 1)
    X = X[Y[:, 0] < 2]
    Y = Y[Y[:, 0] < 2]
    train(X, Y, 100)


def test():
    X = np.array([[1, 0.5], [1, 1.5], [2, 1], [3, 1]])
    m = (X.shape[0])
    n = (X.shape[1])
    Y = np.array([0, 0, 1, 0]).reshape(m, 1)
    print((Y.shape))
    print(train(X, Y, 1000))

if __name__ == '__main__':
    main()
#     test()

运行代码将输出如下：在64次迭代的时候就收敛了。代码里面实现了参数的L2正则化。

step: 62 cost: [ 0.33512973] accuracy: 0.97
step: 63 cost: [ 0.32701202] accuracy: 0.98
step: 64 cost: [ 0.31998367] accuracy: 1.0
step: 65 cost: [ 0.31388857] accuracy: 1.0

此代码是可用代码