首页 文章

使用逻辑回归分析R,statmodel,sklearn的分类任务

提问于
浏览
11

我在R,python statmodels和sklearn中进行了逻辑回归的一些实验 . 虽然R和statmodels给出的结果是一致的,但sklearn返回的结果有些不一致 . 我想了解为什么这些结果不同 . 据我所知,它可能与木材下使用的优化算法不同 .

具体来说,我使用标准 Default 数据集(在ISL book中使用) . 以下Python代码将数据读入数据帧 Default .

import pandas as pd
 # data is available here
Default = pd.read_csv('https://d1pqsl2386xqi9.cloudfront.net/notebooks/Default.csv', index_col=0)
 #
Default['default']=Default['default'].map({'No':0, 'Yes':1})
Default['student']=Default['student'].map({'No':0, 'Yes':1})
 #
I=Default['default']==0
print("Number of 'default' values :", Default[~I]['balance'].count())

“默认”值的数量:333 .

总共有10000个例子,只有333个阳性

R中的逻辑回归

我使用以下内容

library("ISLR")
data(Default,package='ISLR')
 #write.csv(Default,"default.csv")
glm.out=glm('default~balance+income+student', family=binomial, data=Default)
s=summary(glm.out)
print(s)
#
glm.probs=predict(glm.out,type="response") 
glm.probs[1:5]
glm.pred=ifelse(glm.probs>0.5,"Yes","No")
 #attach(Default)
t=table(glm.pred,Default$default)
print(t)
score=mean(glm.pred==Default$default)
print(paste("score",score))

结果如下

通话:glm(公式=“默认〜 balancer 收入学生”,家庭=二项式,数据=默认)偏差残差:最小1Q中位数3Q最大-2.4691 -0.1418 -0.0557 -0.0203 3.7383系数:估计标准 . 误差z值Pr(> | z |)
(拦截)-1.087e 01 4.923e-01 -22.080 <2e-16
balancer 5.737e-03 2.319e-04 24.738 <2e-16
收入3.033e-06 8.203e-06 0.370 0.71152
studentYes -6.468e-01 2.363e-01 -2.738 0.00619
(二项式族的色散参数为1)空偏差:9999自由度为2920.6残差
偏差:1599.5对9996自由度AIC:1579.5 Fisher评分迭代次数:8 glm.pred否是
No 9627 228
是40 105
1“分数0.9732”

我懒得剪切和粘贴使用statmodels获得的结果 . 足以说它们与R给出的非常相似 .

sklearn

对于sklearn,我运行了以下代码 .

  • 有一个参数class_weight用于考虑不 balancer 的类 . 我测试了class_weight = None(没有加重 - 我认为这是R中的默认值),而class_weight = 'auto'(用数据中的反向频率加权)

  • 我还把C = 10000,正则化参数的倒数,以便最小化正则化的效果 .

~~

import sklearn
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix

features = Default[[ 'balance', 'income' ]]
target = Default['default']
# 
for weight in (None,  'auto'):
    print("*"*40+"\nweight:",weight)

    classifier = LogisticRegression(C=10000, class_weight=weight, random_state=42) 
                #C=10000 ~ no regularization

    classifier.fit(features, target,)  #fit classifier on whole base
    print("Intercept", classifier.intercept_)
    print("Coefficients", classifier.coef_)

    y_true=target
    y_pred_cls=classifier.predict_proba(features)[:,1]>0.5
    C=confusion_matrix(y_true,y_pred_cls)

    score=(C[0,0]+C[1,1])/(C[0,0]+C[1,1]+C[0,1]+C[1,0])
    precision=(C[1,1])/(C[1,1]+C[0 ,1])
    recall=(C[1,1])/(C[1,1]+C[1,0])
    print("\n Confusion matrix")
    print(C)
    print()
    print('{s:{c}<{n}}{num:2.4}'.format(s='Score',n=15,c='', num=score))
    print('{s:{c}<{n}}{num:2.4}'.format(s='Precision',n=15,c='', num=precision))
    print('{s:{c}<{n}}{num:2.4}'.format(s='Recall',n=15,c='', num=recall))

结果如下 .

> **************************************** 
>weight: None 
>
>Intercept [ -1.94164126e-06] 
>
>Coefficients [[ 0.00040756 -0.00012588]]
> 
>  Confusion matrix 
>
>     [[9664    3]  
>     [ 333    0]]
> 
>     Score          0.9664 
>     Precision      0.0 
>     Recall         0.0
>
> **************************************** 
>weight: auto 
>
>Intercept [-8.15376429] 
>
>Coefficients 
>[[  5.67564834e-03   1.95253338e-05]]
> 
>  Confusion matrix 
>
>     [[8356 1311]  
>     [  34  299]]
> 
>     Score          0.8655 
>     Precision      0.1857 
>     Recall         0.8979

我观察到的是,对于 class_weight=None ,分数非常好但是 no 正面的例子被认可 . 精确度和召回率为零 . 找到的系数很小,尤其是截距 . 修改C不会改变事物 . 对于 class_weight='auto' 事情似乎更好但我仍然有一个非常低的精度(太多正面分类) . 再次,改变C没有帮助 . 如果我手动修改截距,我可以恢复R给出的结果 . 所以我怀疑这两种情况下的估计结果之间存在差异 . 由于这在threeshold的规范中具有结果(类似于对重复采样),这可以解释性能的差异 .

但是,我欢迎任何有关两种解决方案之间选择的建议,并帮助理解这些差异的根源 . 谢谢 .

2 回答

  • 1

    我遇到了类似的问题并最终posting about it on /r/MachineLearning . 事实证明,差异可归因于数据标准化 . 无论scikit-learn使用何种方法来查找模型的参数,如果数据标准化,将会产生更好的结果 . scikit-learn有一些文档讨论预处理数据(包括标准化),可以找到here .

    结果

    Number of 'default' values : 333
    Intercept: [-6.12556565]
    Coefficients: [[ 2.73145133  0.27750788]]
    
    Confusion matrix
    [[9629   38]
     [ 225  108]]
    
    Score          0.9737
    Precision      0.7397
    Recall         0.3243
    

    代码

    # scikit-learn vs. R
    # http://stackoverflow.com/questions/28747019/comparison-of-r-statmodels-sklearn-for-a-classification-task-with-logistic-reg
    
    import pandas as pd
    import sklearn
    
    from sklearn.linear_model import LogisticRegression
    from sklearn.metrics import confusion_matrix
    from sklearn import preprocessing
    
    # Data is available here.
    Default = pd.read_csv('https://d1pqsl2386xqi9.cloudfront.net/notebooks/Default.csv', index_col = 0)
    
    Default['default'] = Default['default'].map({'No':0, 'Yes':1})
    Default['student'] = Default['student'].map({'No':0, 'Yes':1})
    
    I = Default['default'] == 0
    print("Number of 'default' values : {0}".format(Default[~I]['balance'].count()))
    
    feats = ['balance', 'income']
    
    Default[feats] = preprocessing.scale(Default[feats])
    
    # C = 1e6 ~ no regularization.
    classifier = LogisticRegression(C = 1e6, random_state = 42) 
    
    classifier.fit(Default[feats], Default['default'])  #fit classifier on whole base
    print("Intercept: {0}".format(classifier.intercept_))
    print("Coefficients: {0}".format(classifier.coef_))
    
    y_true = Default['default']
    y_pred_cls = classifier.predict_proba(Default[feats])[:,1] > 0.5
    
    confusion = confusion_matrix(y_true, y_pred_cls)
    score = float((confusion[0, 0] + confusion[1, 1])) / float((confusion[0, 0] + confusion[1, 1] + confusion[0, 1] + confusion[1, 0]))
    precision = float((confusion[1, 1])) / float((confusion[1, 1] + confusion[0, 1]))
    recall = float((confusion[1, 1])) / float((confusion[1, 1] + confusion[1, 0]))
    print("\nConfusion matrix")
    print(confusion)
    print('\n{s:{c}<{n}}{num:2.4}'.format(s = 'Score', n = 15, c = '', num = score))
    print('{s:{c}<{n}}{num:2.4}'.format(s = 'Precision', n = 15, c = '', num = precision))
    print('{s:{c}<{n}}{num:2.4}'.format(s = 'Recall', n = 15, c = '', num = recall))
    
  • 5

    虽然这篇文章很老,但我想给你一个解决方案 . 在您的帖子中,您将苹果与橙子进行比较 . 在您的R代码中,您在“默认”上估算“余额,收入和学生” . 在您的Python代码中,您只是在“默认”上估算“余额和收入” . 当然,你不能得到相同的估计 . 此外,差异不能归因于特征缩放,因为与kmeans相比,逻辑回归通常不需要它 .

    你设置一个高C是正确的,所以没有正规化 . 如果要获得与R中相同的输出,则必须将解算器更改为“newton-cg” . 不同的求解器可以给出不同的结果,但它们仍然产生相同的目标值 . 只要你的求解器收敛,一切都会好起来的 .

    这里的代码可以为您提供与R和Statsmodels相同的估算:

    import pandas as pd
    from sklearn.linear_model import LogisticRegression
    from patsy import dmatrices # 
    import numpy as np
    
     # data is available here
    Default = pd.read_csv('https://d1pqsl2386xqi9.cloudfront.net/notebooks/Default.csv', index_col=0)
     #
    Default['default']=Default['default'].map({'No':0, 'Yes':1})
    Default['student']=Default['student'].map({'No':0, 'Yes':1})
    
    # use dmatrices to get data frame for logistic regression
    y, X = dmatrices('default ~ balance+income+C(student)',
                      Default,return_type="dataframe")
    
    y = np.ravel(y)
    
    # fit logistic regression
    model = LogisticRegression(C = 1e6, fit_intercept=False, solver = "newton-cg", max_iter=10000000)
    model = model.fit(X, y)
    
    # examine the coefficients
    pd.DataFrame(zip(X.columns, np.transpose(model.coef_)))
    

相关问题