官方逻辑回归链接

sklearn.linear_model.LogisticRegression — scikit-learn 1.0.2 documentationhttps://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression

一，参数说明

1.1重要参数solver（求解器）详解

该参数用于优化问题，达到线性收敛的结果，相当于对逻辑回归进行优化

该参数对应的选项有

{‘newton-cg’，’lbfgs’，’liblinear’，’sag’，’saga’}，默认 =’lbfgs’

newton-cg

传统的牛顿法是每一次迭代都要求Hessian矩阵的逆，这个复杂度就很高，为了避免求矩阵的逆，Newton-CG就用CG共轭梯度法来求解线性方程组，从而避免了求矩阵逆。

lbfgs

有限内存中进行BFGS算法

L-BFGS算法是一种在牛顿法基础上提出的一种求解函数根的算法

一文读懂L-BFGS算法_激进的蜗牛-CSDN博客_lbfgs接前一篇:逻辑回归(logistics regression) 本章我们来学习L-BFGS算法.L-BFGS是机器学习中解决函数最优化问题比较常用的手段,本文主要包括以下六部分: 1-L-BFGS算法简介 2-牛顿法求根问题 3-牛顿法求函数的驻点 4-…https://blog.csdn.net/weixin_39445556/article/details/84502260

L-BFGS剖析_golden_xuhaifeng的博客-CSDN博客_lbfgs    机器学习中经常利用梯度下降法求最优解问题，通过大量的迭代来得到最优解，但是对于维度较多的数据，除了占用大量的内存还会很耗时，L-BFGS算法是一种在牛顿法基础上提出的一种求解函数根的算法，下面由简入深尽量用简洁的语言剖析算法的本质。一.牛顿法    解决函数求根问题 f(x)函数在x1点的导数，是该函数在x1点的切线的斜率y/x，f(x1)=f(x1)/(x1-x2) ,x1-x3=f(x…https://blog.csdn.net/golden_xuhaifeng/article/details/79817330这两篇文章也讲述了牛顿法

liblinear

官方网站

LIBLINEAR — A Library for Large Linear Classificationlogistic regression, support vector machines, linear classification, document classificationhttps://www.csie.ntu.edu.tw/~cjlin/liblinear/使用指南

https://www.csie.ntu.edu.tw/~cjlin/papers/liblinear.pdfhttps://www.csie.ntu.edu.tw/~cjlin/papers/liblinear.pdf是一个简单的解决大规模线性化分类和回归问题的软件包

是具有数百万个实例和特征的数据的线性分类器

sag

随机梯度下降算法

saga

SAGA算法是SAG算法的一个加速版本

如何区分两者

如何理解SAG,SVRG,SAGA三种优化算法 – 知乎最近在看Leon Bottou的大规模机器学习中的优化算法，发现里面有一些算法不太好理解，所以自己找了一些文章看了看，决定把SAG,SVRG,SAGA三种算法介绍一下。 对于这三种方法，我们主要目的是希望达到线性收敛的结果…https://zhuanlan.zhihu.com/p/51184012参数中与求解器（solver）相关的有

penalty，dual，intercept_scaling，max_iter

 1.2其他参数说明

对于是否再逻辑回归之前做归一化或者标准化

scaler = StandardScaler()
X_train = scaler.fit_transform(X)

逻辑回归模型中特征是否需要归一化？ – 简书从前向过程来看：逻辑回归模型的输出是经过softmax的概率值，概率值的排序不受归一化的影响。从另一个角度来看，softmax其实也就实现了归一化的目的。 从反向过程来看：逻…https://www.jianshu.com/p/544c457a9947

二、优化方法（一下优化仅个人观点）

2.1方法一，使用自编代码求解权重，让后将权重作为参数传入

参数优化参考文献

数据挖掘经典算法：Logistic(逻辑回归) python和sklearn实现_昆兰.沃斯 的博客-CSDN博客_sklearn 逻辑回归Logistic虽然不是十大经典算法之一，但却是数据挖掘中常用的有力算法，所以这里也专门进行了学习，以下内容皆为亲自实践后的感悟和总结（Logistic原理、代码实现和优化、真实样例数据、sklearn实现）。为了记录的比较清楚，所以内容可能有点多，但都比较浅显，下面进入正文。(运算数据来自机器学习第5章)Logistic原理：大体的思路：为了实现Logistic回归分类器，我们可以在每个…https://blog.csdn.net/qq_36523839/article/details/81604217

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

# 读取文本数据，返回数据集和目标值
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_curve, auc
from sklearn.preprocessing import StandardScaler


def loadDataSet():
    dataMat = []
    labelMat = []
    fr = open('testSet.txt')
    for line in fr.readlines():
        lineArr = line.strip().split()
        # 该数据集中，添加了一列并初始化为1，便于后续的计算，但是在其他数据集中，一般没有必要添加
        dataMat.append([1.0, float(lineArr[0]), float(lineArr[1])])
        labelMat.append(int(lineArr[2]))
    return dataMat, labelMat


# 运算的核心函数Sigmoid
def sigmoid(inX):
    return 1.0 / (1 + np.exp(-inX))

def stocGradAscent0(dataMatrix, classLabels):
    dataMatrix = np.array(dataMatrix)    #将列表转换格式
    m,n = np.shape(dataMatrix)
    alpha = 0.01
    weights = np.ones(n)
    for i in range(m):
        h = sigmoid(sum(dataMatrix[i]*weights))
        error = classLabels[i] - h
        weights = weights + alpha * error * dataMatrix[i]
    return weights

def stocGradAscent1(dataMatrix, classLabels, numIter=150):
    dataMatrix = np.array(dataMatrix)   #将列表转换格式
    m,n = np.shape(dataMatrix)
    weights = np.ones(n)
    for j in range(numIter):
        dataIndex = list(range(m))
        for i in range(m):
            alpha = 4/(1.0+j+i)+0.0001  #变化的alpha
            randIndex = int(np.random.uniform(0,len(dataIndex)))    #随机样本下标
            h = sigmoid(sum(dataMatrix[randIndex]*weights))
            error = classLabels[randIndex] - h
            weights = weights + alpha * error * dataMatrix[randIndex]
            del(dataIndex[randIndex])   #从整个数据中去除已经使用过的样本
    return weights

# 核心函数alpha*gradient更新回归系数
def gradAscent(dataMatIn, classLabels):
    # 为了便于计算，mat将两个列表数据转换为numpy的数组
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()  # transpose矩阵转置
    m, n = np.shape(dataMatrix)
    alpha = 0.001  # 设置步长
    maxCycles = 500  # 设置循环次数
    weights = np.ones((n, 1))  # 初始化每个特征的回归系数为1
    for k in range(maxCycles):
        # 得到每一行的sigmoid值 (两个相乘得到z值)
        h = sigmoid(dataMatrix * weights)  # 矩阵相乘 sigmoid(sum(每个特征*每个系数)) 行*列，由于是矩阵相乘，所以在相乘时便求和了
        # 用一直更新的回归系数求预测值，然后与真实值之间求误差，误差越来越小，则系数更新变化也越来越小，最后趋于稳定
        error = (labelMat - h)  # 每行分类与对应sigmoid相减 误差值越来越小了
        # 数据集转置*误差 每条样本*该样本的误差值
        weights = weights + alpha * dataMatrix.transpose() * error
    return weights



# 1.读取训练数据集
# 设置随机种子
random_state_model = 40
filepath = r"文件路径"
#特征因子个数
feature_number = 特征个数
data = pd.read_excel(filepath)  # reading file
data = np.array(data)
classifypointdata = data[:, 0:feature_number]
classifypointlabel = data[:, -1]

scaler = StandardScaler()
classifypointdata = scaler.fit_transform(classifypointdata)
# 切分数据，固定随机种子（random_state）时，同样的代码，得到的训练集数据相同。
# 此处运行完的结果可能是string类型之后用于计算时记得类型转换
train_data, test_data, train_label, test_label = model_selection.train_test_split(classifypointdata, classifypointlabel, random_state=random_state_model,
                                                                                      train_size=0.8, test_size=0.2)
train_data = np.array(train_data)
test_data = np.array(test_data)
train_label = np.array(train_label)
test_label = np.array(test_label)
#dataArr, labelMat = loadDataSet()
weights = gradAscent(train_data, train_label)
print(weights)
LC_model =  LogisticRegression(random_state=random_state_model,class_weight=weights)
LC_model.fit(train_data, train_label)
y_test_pred = LC_model.predict(test_data)
print("Accuracy %0.6f:" % (accuracy_score(test_label, y_test_pred)))
y_test_predict_proba = LC_model.predict_proba(test_data)[:, 1]
y_test_two_model = np.array(test_label, dtype=int)
test_fpr, test_tpr, test_thresholds = roc_curve(y_test_two_model, y_test_predict_proba, pos_label=1)
test_roc_auc = auc(test_fpr, test_tpr)
print("auc %0.6f:" % (test_roc_auc))

2.2方法二，综合以上基于求解器我们使用网格搜索进行参数优化，其主要是优化的参数是solver，penalty，max_iter

import pandas as pd
from sklearn import model_selection
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_curve, auc
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
import numpy as np
# 1.读取训练数据集
# 设置随机种子
random_state_model = 40
filepath = r"文件路径"
#特征因子个数
feature_number = 因子个数/特征值数
data = pd.read_excel(filepath)  # reading file
data = np.array(data)
classifypointdata = data[:, 0:feature_number]
classifypointlabel = data[:, -1]
# 1.标准化处理
#标准差标准化（standardScale）使得经过处理的数据符合标准正态分布，即均值为0，标准差为1
#概念
#标准化：缩放和每个点都有关系，通过均值μ和标准差σ体现出来；输出范围是负无穷到正无穷
#优点
#提升模型的收敛速度
#提升模型的精度
#使用场景
#如果数据存在异常值和较多噪音，用标准化，可以间接通过中心化避免异常值和极端值的影响
scaler = StandardScaler()
classifypointdata = scaler.fit_transform(classifypointdata)
# 切分数据，固定随机种子（random_state）时，同样的代码，得到的训练集数据相同。
# 此处运行完的结果可能是string类型之后用于计算时记得类型转换
train_data, test_data, train_label, test_label = model_selection.train_test_split(classifypointdata, classifypointlabel, random_state=random_state_model,
                                                                                      train_size=0.8, test_size=0.2)


# 2.构建RF模型
#参数是基于个人数据优化的结果
LC_model =  LogisticRegression(random_state=random_state_model)
param_grid = [{'solver':['newton-cg'],'penalty':['l2','none'],'max_iter':[10,50,100,1000,2000]},
              {'solver':['lbfgs'],'penalty':['l2','none'],'max_iter':[10,50,100,1000,2000]},
              {'solver':['liblinear'],'penalty':['l2','l1'],'max_iter':[10,50,100,1000,2000]},
              {'solver':['sag'],'penalty':['l2','none'],'max_iter':[10,50,100,1000,2000]},
              {'solver':['saga'],'penalty':['l2','none','elasticnet','l1'],'max_iter':[10,50,100,1000,2000]}]
LC_GSC = GridSearchCV(LC_model, param_grid, cv=10)
LC_GSC.fit(train_data, train_label)
print(LC_GSC.best_params_)
print(LC_GSC.best_score_)
optimal_LC = LC_GSC.best_params_

LC_model =  LogisticRegression(random_state=random_state_model,**optimal_LC)
LC_model.fit(train_data, train_label)

y_test_pred = LC_model.predict(test_data)
print("Accuracy %0.6f:" % (accuracy_score(test_label, y_test_pred)))
y_test_predict_proba = LC_model.predict_proba(test_data)[:, 1]
y_test_two_model = np.array(test_label, dtype=int)
test_fpr, test_tpr, test_thresholds = roc_curve(y_test_two_model, y_test_predict_proba, pos_label=1)
test_roc_auc = auc(test_fpr, test_tpr)
print("auc %0.6f:" % (test_roc_auc))

2.3结果

两者的auc是相同的，准确率相差0.05，但是方法一只相当于方法二的一部分