Python实现逻辑回归算法，只使用python中的pandas和numpy库

---

前言

只使用最基础的python语言，只是用Numpy,Matplotlib 基础的库包去实现机器学习算法，有助于读者理解各机器学习算法的原理，以及算法实现的整个步骤。这期带来逻辑回归（Logistic）算法的实现。

• 希望通过基础的python代码去实现机器学习算法去提高我们的编程能力
• 希望通过代码的一步步的实现，来领会整个算法实现过程。

一、逻辑回归介绍

Logistic Regression 虽然被称为回归，但其实际上是分类模型，并常用于二分类

• 第一，逻辑回归与线性回归的区别

可以说，逻辑回归的输入是线性回归的输出，然后逻辑回归再通过sigmoid函数将数值映射为（0，1）之间

• 第二，z函数就是所谓的输入，其实就是线性回归的函数
  
• 第三，然后g(z)就是所谓的sigmoid 函数，就是将输入的值改变为分布（0，1）之间，且当g(z)接近0时样本的标签为类别0，当g(z)接近1时样本的标签为类别1，这样就得到一个分类模型。
  
  
• 第四，那么g(z)就是逻辑回归返回的标签值。此时y(x)的数值都在[0,1]之间，因此y(x)和1-y(x)相加必然为1。我们令y(x)除以1-y(x)可以得到形似几率（oods）的y(x)/1-y(x)，，在此基础上取对数，可以得到：

那么就会如下结论：

那么就是说：

请读者认真阅读以上内容，理解明白以上整个过程的意义，思考为什么要分析以上过程？

• 第五，极大似然估计
• 第六，求最小值时的w的两种方法
  第五第六请参考链接：
  https://blog.csdn.net/weixin_55073640/article/details/124683459

二、Python实现逻辑回归

1.引入库

import numpy as np
import pandas as pd

2.读入数据

数据来源：请点击然后下载 iris.csv

data = pd.read_csv(r"iris.csv")
data.head()

3.数据预处理

#删除重复值
data.drop_duplicates(inplace=True)
#Iris-setosa   Iris-versicolor   Iris-virginica
data["class"] = data["class"].map({"Iris-versicolor":0,"Iris-setosa":1,"Iris-virginica":2})
#只选取类别为0与1的数据   进行逻辑回归的二分类
data = data[data["class"]!=2]

4.创建逻辑回归LogisticRegression类

class LogisticRegression:
    """
    使用Python语言实现逻辑回归算法
    """
    def __init__(self,alpha,times):
        """
        初始化方法
        Parameter
        ----
        alpha:float
        学习率
        -----
        times:int
        迭代次数。
        
        """
        self.alpha = alpha
        self.times = times
    def sigmoid(self,z):
        """
        sigmoid函数的实现
        
        Parameters
        ----
        z:float
        自变量，值为z = w.T*x
        
        Returns
        ----
        p:float
        值为[0,1]之间 ，返回是样本属于类别1的概率值，用来作为结果的预测值
        当s>=0.5（即z>=0）时，判定为类别1，否则则判定为0
        """
        return 1.0/(1.0+np.exp(-z))
    def fit(self,X,y):
        """
        根据提供的数据，对模型进行训练
        Parameter
        ----
        X:类数组类型。形状为[样本数量，特征数量]
        待训练的样本特征属性
        
        ----
        y:类数组类型，形状为[样本数量]
        每一个样本的目标值。（标签）
        """
        X = np.asarray(X)
        y = np.asarray(y)
        #创建权重的向量，初始值为0
        self.v_ = np.zeros(1+X.shape[1])
        #创建损失列表，用来保存每次迭代后的损失值
        self.loss_ = []
        
        for i in range(self.times):
            z = np.dot(X,self.v_[1:])+self.v_[0]
            #计算一下概率值
            p = self.sigmoid(z)
            #根据逻辑回归的代价函数（目标函数），计算损失值
            #逻辑回归的目标函数  J(w) = -sum((yi*log(s(zi)))+(1-yi)*log(1-s(zi)))  [i从1到n,n为样本数量]
            cost = -np.sum(y*np.log(p)+(1-y)*np.log(1-p))
            self.loss_.append(cost)
            #调整权重值 调整为权重（j） = 权重（j）+学习率*sum((y-s(z))*x(j))
            self.v_[0] += self.alpha * np.sum(y-p)
            self.v_[1:]+= self.alpha*np.dot(X.T,y-p)
    def predict_proba(self,X):
        """
        根据参数传递的样本，对样本数据进行预测。
        Parameters
        ----
        X：类数组类型。形状为[样本数量，特征数量]
        待测试的样本特征属性
        
        Returns
        ----
        result:数组类型
        预测的结果（概率值）
        
        """
        X = np.asarray(X)
        z = np.dot(X,self.v_[1:])+self.v_[0]
        p = self.sigmoid(z)
        #将预测结果变成二维结构，便于后续的拼接
        p = p.reshape(-1,1)
        #将两个数组进行拼接，横向拼接
        return np.concatenate([1-p,p],axis =1)
    def predict(self,X):
        """
        根据参数传递的样本，对样本数据进行预测。
        
        Parameter
        ----
        X:类数组类型。[样本数量，特征数量]
        待测试的样本特征（属性）
        
        Returns
        ----
        result:数组类型
        预测的结果（分类值）
        
        
        """
        return np.argmax(self.predict_proba(X),axis=1)   #所有制为0或1
    
    
        

5.打乱数据集，割分训练集和测试集

t1 = data[data["class"]==0]
t2 = data[data["class"]==1]
t1.sample(len(t1),random_state=0)
t2.sample(len(t2),random_state=0)
train_X = pd.concat([t1.iloc[:40,:-1],t2.iloc[:40,:-1]],axis = 0)
train_y = pd.concat([t1.iloc[:40,-1],t2.iloc[:40,-1]],axis = 0)
test_X = pd.concat([t1.iloc[40:,:-1],t2.iloc[40:,:-1]],axis = 0)
test_y = pd.concat([t1.iloc[40:,-1],t2.iloc[40:,-1]],axis = 0)

6.实例化LogisticRegression，训练、预测

#各字段的特征列数据都在同一数量级，我们这里可以不进行标准化处理
lr = LogisticRegression(alpha=0.01,times=20)
lr.fit(train_X,train_y)
# lr.predict_proba(test_X)
lr.predict(test_X)

result = lr.predict(test_X)
np.sum(result == test_y)
#计算准确率
np.sum(result == test_y)/len(test_y)

准确率为100%

7.可视化

import matplotlib as mpl
import matplotlib.pyplot as plt
#可显示中文
mpl.rcParams['font.family'] = "SimHei"   #中文显示
mpl.rcParams['axes.unicode_minus'] = False  #中文字体下，可以显示中文符号

#绘制预测值
plt.plot(result,"ro",ms=15,label = "预测值")
#绘制真实值
plt.plot(test_y.values,"go",label="真实值")
plt.title("逻辑回归")
plt.xlabel("样本序号")
plt.ylabel("类别")
plt.legend()
plt.show()