6 逻辑斯谛回归

一、算法
1、logistic回归用回归思想的分类算法
利用Logistic回归进行分类的主要思想是：根据现有数据对分类边界线建立回归公式，以此进行分类。
优点：计算代价不高，易于理解和实现。
缺点：容易欠拟合，分类精度可能不高。
适用数据类型：数值型和标称型。
2、Sigmoid函数
在Logistic回归中，我们需要的函数是，能接受所有的输入然后预测类别。
LR一般应用Sigmoid函数：

image

当x为0时，Sigmoid函数值为0.5，随着x的增大，对应的Sigmoid函数值将逼近于1；而随着x的减小，Sigmoid函数值将逼近于0。横坐标足够大时，Sigmoid函数看起来像一个阶跃函数。

image

为了实现LR回归分类器，我们在每个特征上都乘以一个回归系数，然后把所有的结果值相加，即z=w0x0+w1x1+w2x2+...+wnxn，代入到Sigmoid函数中，进而得到一个范围在0~1之间的数值。大于0.5的数据被分入1类，小于0.5即被分入0类。

二、目标函数
因为Sigmoid函数是非凸函数，如果采用平方误差和作为目标优化函数，则无法直接使用梯度上升法。于是我们应用极大似然估计法估计模型参数。
设：

image

得到目标函数：

image

对L(W)求极大值，得到w回归系数的估计值。

三、最优化方法

梯度上升法
确定分类器函数形式之后，现在问题变成了：找到最佳回归系数，从而使分类器尽可能地准确。
梯度上升法基于的思想是：要找到某函数的最大值，最好的方法是沿着该函数的梯度方向探寻。
迭代公式如下：
w：w+aDwf(w)
f为目标函数，D为梯度，a为步长。停止的条件是迭代次数达到某个指定值或者算法达到某个允许的误差范围。
类比梯度下降法：w：w-aDwf(w)

四、训练算法
伪代码如下：
（1）每个回归系数初始化为1
（2）重复R次：
计算整个数据集的梯度
使用alpha*gradient更新回归系数的向量
（3）返回回归系数
下面是梯度上升算法的具体实现逻辑斯谛回归：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
% matplotlib inline
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import math

# 生成鸢尾花数据
def create_data():
    iris = load_iris()
    df=pd.DataFrame(iris.data,columns=iris.feature_names)
    df['label']=iris.target
    df.columns=['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
    data=np.array(df.iloc[:100,[0,1,-1]])
    return data[:,:2], data[:,-1]

X,y=create_data()
X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.3)

# 梯度上升法更新权值向量w
class LogisticRegressionClassifier:
    def __init__(self, max_iter=200, learning_rate=0.01):
        self.max_iter=max_iter  # 迭代次数
        self.learning_rate = learning_rate  # 学习率
    
    def sigmoid(self,x):
        return 1/(1+math.exp(-x))     #sigmoid函数1/1+e(-x)
    
    def data_matrix(self, X): 
        data_mat=[]
        for d in X:
            data_mat.append([1.0,*d])  #解包, 第一列增加1，其实为计算b
        return data_mat
    
    def fit(self, X, y):
        data_mat=self.data_matrix(X)
        self.weights = np.zeros((len(data_mat[0]),1),dtype=np.float32)
        for iter_ in range(self.max_iter):
            for i in range(len(X)):
                result = self.sigmoid(np.dot(data_mat[i],self.weights))
                error = y[i]-result     #偏差
                self.weights += self.learning_rate*error* np.transpose([data_mat[i]])    #梯度上升进行更新w
        
    def score(self, X_test, y_test):
        # 计算测试样本预测正确率
        right=0
        X_test=self.data_matrix(X_test)
        for x, y in zip(X_test, y_test):
            result = np.dot(x, self.weights)
            if (result>0 and y==1) or (result<0 and y==0):
                right += 1
        return right/len(X_test)

lr_clf = LogisticRegressionClassifier()
lr_clf.fit(X_train, y_train)

lr_clf.score(X_test,y_test)
x_ponits = np.arange(4, 8)
y_fit = -(lr_clf.weights[1]*x_ponits + lr_clf.weights[0])/lr_clf.weights[2]
plt.plot(x_ponits, y_fit, c='r')

plt.scatter(X[:50,0],X[:50,1], label='0')
plt.scatter(X[50:,0],X[50:,1], label='1')
plt.legend()

image.png

scikit-learn实例：
sklearn.linear_model.LogisticRegression
solver参数决定了我们对逻辑回归损失函数的优化方法，有四种算法可以选择，分别是：

a) liblinear：使用了开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数。
b) lbfgs：拟牛顿法的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
c) newton-cg：也是牛顿法家族的一种，利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
d) sag：即随机平均梯度下降，是梯度下降法的变种，和普通梯度下降法的区别是每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候