统计学习方法中算法实现（基于Python） --- 逻辑回归

逻辑斯谛回归(LR)是经典的分类方法

1．逻辑斯谛回归模型是由以下条件概率分布表示的分类模型。逻辑斯谛回归模型可以用于二类或多类分类。

$$P(Y=k|x)=\frac{\exp \left(w_k\cdot x\right)}{1+{\sum }_{k=1}^{K-1}\exp \left(w_k\cdot x\right)},k=1,2,\cdots ,K-1$$$$P(Y=K|x)=\frac{1}{1+{\sum }_{k=1}^{K-1}\exp \left(w_k\cdot x\right)}$$
这里，$x$为输入特征，$w$为特征的权值。

逻辑斯谛回归模型源自逻辑斯谛分布，其分布函数$F(x)$是$S$形函数。逻辑斯谛回归模型是由输入的线性函数表示的输出的对数几率模型。

2．最大熵模型是由以下条件概率分布表示的分类模型。最大熵模型也可以用于二类或多类分类。

$$P_w(y|x)=\frac{1}{Z_w(x)}\exp \left(\sum _{i=1}^n{w}_i{f}_i(x,y)\right)$$$$Z_w(x)=\sum _y\exp \left(\sum _{i=1}^n{w}_i{f}_i(x,y)\right)$$
其中，$Z_w(x)$是规范化因子，$f_i$为特征函数，$w_i$为特征的权值。

3．最大熵模型可以由最大熵原理推导得出。最大熵原理是概率模型学习或估计的一个准则。最大熵原理认为在所有可能的概率模型（分布）的集合中，熵最大的模型是最好的模型。

最大熵原理应用到分类模型的学习中，有以下约束最优化问题：

$$\min -H(P)=\sum _{x,y}\tilde{P}(x)P(y|x)\log P(y|x)$$$$s.t.P\left(f_i\right)-\tilde{P}\left(f_i\right)=0,i=1,2,\cdots ,n$$
$$\sum _{y}P(y|x)=1$$

求解此最优化问题的对偶问题得到最大熵模型。

4．逻辑斯谛回归模型与最大熵模型都属于对数线性模型。

5．逻辑斯谛回归模型及最大熵模型学习一般采用极大似然估计，或正则化的极大似然估计。逻辑斯谛回归模型及最大熵模型学习可以形式化为无约束最优化问题。求解该最优化问题的算法有改进的迭代尺度法、梯度下降法、拟牛顿法。

回归模型：$f(x)=\frac{1}{1+e^{-wx}}$

其中wx线性函数：$wx=w_0\cdot x_0+w_1\cdot x_1+w_2\cdot x_2+...+w_n\cdot x_n,(x_0=1)$

from math import exp
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

# data
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]])
    # print(data)
    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)


class LogisticReressionClassifier:
    def __init__(self,max_iter=200,lr=0.01):
        self.max_iter=max_iter
        self.lr=lr
        self.weight=None
        
    def sigmoid(self,x):
        return 1/(1+exp(-x))
    
    def data_matrix(self,x): # 把x变成（x1，x2，x3,1）的形式，与w（w1,w2,w3,b）相乘
        data_matrix=[]
        for i in x:
            data_matrix.append([*i,1.0])
            
        return data_matrix
    
    def fit(self,x,y):
        data_matrix=self.data_matrix(x)  
        self.weight=np.zeros((len(data_matrix[0]),1),dtype=np.float32)
        for iter_ in range(self.max_iter):  # 迭代次数
            for i in range(len(x)):
                res=self.sigmoid(np.dot(data_matrix[i] , self.weight))
                error=y[i]-res
                self.weight+=self.lr*error*np.transpose([data_matrix[i]])  # 此处其实是利用梯度下降求解 w
        print('LogisticRegression Model(learning_rate={},max_iter={})'.format(
            self.lr, self.max_iter))
        
        
    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):
            res=np.dot(x,self.weight)
            if(res>=0 and y==1) or (res<0 and y ==0):
                right+=1
        return right/len(X_test)

# 验证：
lr_clf=LogisticReressionClassifier()
lr_clf.fit(X_train,y_train)

lr_clf.score(X_test,y_test)

# out  :  1.0

x_ponits = np.arange(4, 8)
y_ = -(lr_clf.weight[0]*x_ponits + lr_clf.weight[2])/lr_clf.weight[1]
plt.plot(x_ponits, y_)

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