【ML】逻辑回归模型及其Python实现

逻辑回归是一种经典的二分类算法。

1 Sigmoid函数

  Sigmoid函数形如：
$$\sigma (z)=\frac{1}{1+e^{-z}},z\in \mathcal{R}$$
函数具有如下性质：

1. Sigmoid函数可将任意的输入映射到$[0,1]$区间，且是单增的，通过Sigmoid函数可将线性回归得到的预测值转换成概率；
2. ${\sigma }^{\prime }(z)=\frac{e^{-z}}{(1+e-z{)}^2}=\frac{1}{1+e^{-z}}(1-\frac{1}{1+e^{-z}})=\sigma (z)(1-\sigma (z))$
3. Sigmoid函数与Logit函数互为反函数。Logit函数形如：
   $$logit(x)=\log \frac{x}{1-x},x\in (0,1)$$

2 广义线性模型

2.1 广义线性模型

{ y i ∼ i n d e p . f Y i ( y i ∣ γ i , τ ) f Y i ( y i ∣ γ i , τ ) = e x p { [ y i γ i − b ( γ i ) ] / τ 2 − c ( y i , τ ) } E [ y i ] = μ i g ( μ i ) = x i T β \begin{cases} y_i\sim indep.f_{Y_i}(y_i|\gamma_i,\tau)\\ f_{Y_i}(y_i|\gamma_i,\tau)=exp\{[y_i\gamma_i-b(\gamma_i)]/\tau^2-c(y_i,\tau)\}\\ E[y_i]=\mu_i\\ g(\mu_i)=x_i^T\beta \end{cases} ⎩⎪⎪⎪⎨⎪⎪⎪⎧​yi​∼indep.fYi​​(yi​∣γi​,τ)fYi​​(yi​∣γi​,τ)=exp{[yi​γi​−b(γi​)]/τ2−c(yi​,τ)}E[yi​]=μi​g(μi​)=xiT​β​
  这里 { x i , y i } \{x_i,y_i\} {xi​,yi​}为第$i$个样本，$f_{Y_i}(y_i)$为$y_i$的概率密度函数；${\gamma }_i$、$\tau$是分布族参数；$g$为链接函数，将$y_i$与$x_i$的线性组合联系起来；$\beta$为模型参数，代表位置的固定效应。均值及方差，
$$\{\begin{array}{l}E[y]=\mu =\frac{\partial b(\gamma )}{\partial \gamma }\\ \\ var(y)={\tau }^{2}v(\mu ),v(\mu )=\frac{{\partial }^2\log f(y)}{{\partial }^2\gamma }\end{array}$$

参数$\gamma$被称为标准参数，为均值$\mu$的函数，$b(\gamma )$也是均值$\mu$的函数；$\tau$为离散参数，与$y$的方差有关。

  观测值$y_i$来自同一类型但不相同的分布族，链接函数将$x_i$与$y_i$的均值联系起来。广义线性模型以自变量的线性函数来预测因变量的条件平均数的某种函数，也就是说，因变量期望的某种函数，是根据其自变量而定的。

2.2 指数族分布

  指数族分布一般形式指数分布族 P = { P θ : θ ∈ Θ } \mathbb{P}=\{P_\theta:\theta\in\Theta\} P={Pθ​:θ∈Θ}，其概率密度函数，
f ( y ; θ ) = h ( y ) e x p { ∑ i = 1 s ξ i ( θ ) T i ( y ) − B ( θ ) } f(y;\theta)=h(y)exp\{\sum_{i=1}^s\xi_i(\theta)T_i(y)-B(\theta)\} f(y;θ)=h(y)exp{i=1∑s​ξi​(θ)Ti​(y)−B(θ)}

  指数族分布的自然参数形式： 指数分布族 P = { P ξ : ξ ∈ Ξ } , Ξ ∈ R s \mathbb{P}=\{P_\xi:\xi\in\Xi\},\quad \Xi\in\mathbb{R}^s P={Pξ​:ξ∈Ξ},Ξ∈Rs，其概率密度函数： f ( y ; ξ ) = h ( y ) e x p { ∑ i = 1 s ξ i T i ( y ) − A ( ξ ) } f(y;\xi)=h(y)exp\{\sum_{i=1}^s\xi_iT_i(y)-A(\xi)\} f(y;ξ)=h(y)exp{i=1∑s​ξi​Ti​(y)−A(ξ)}
并且，
$$E_{\xi }[T_k]=\frac{\partial A(\xi )}{\partial {\xi }_k}(1\le k\le s),co{v}_{\xi }(T_k,T_j)=\frac{{\partial }^{2}A(\xi )}{\partial {\xi }_k\partial {\xi }_j}(1\le k,j\le s)$$

当$T(x)=x$时，指数族分布称为标准（Canonial）分布，$\xi$称为标准分布的自然参数。标准分布有高斯分布、伯努利分布、多项分布、泊松分布等。

  单参数指数族分布族：
f ( y ; θ ) = h ( y ) e x p { ξ ( θ ) T ( y ) − B ( θ ) } f(y;\theta)=h(y)exp\{\xi(\theta)T(y)-B(\theta)\} f(y;θ)=h(y)exp{ξ(θ)T(y)−B(θ)}

f ( y ; ξ ) = h ( y ) e x p { ξ T ( y ) − A ( ξ ) } f(y;\xi)=h(y)exp\{\xi T(y)-A(\xi)\} f(y;ξ)=h(y)exp{ξT(y)−A(ξ)}
且，
$$E_{\xi }[T]=\frac{\partial A(\xi )}{\partial \xi },Va{r}_{\xi }(T)=\frac{{\partial }^{2}A(\xi )}{{\partial }^2\xi }$$

伯努利分布

  设$y$服从伯努利分布$y\sim indep.Bernoulli[\pi ]$，$E[y]=\pi$，密度函数
f ( y ∣ π ) = π y ( 1 − π ) 1 − y , y ∈ { 0 , 1 } f(y|\pi)=\pi^y(1-\pi)^{1-y}, y\in\{0,1\} f(y∣π)=πy(1−π)1−y,y∈{0,1}

可写伯努利分布密度函数，
f ( y ∣ π ) = π y ( 1 − π ) 1 − y = e x p { ln ⁡ [ π y ( 1 − π ) 1 − y ] } = e x p { y ln ⁡ π + ( 1 − y ) ln ⁡ ( 1 − π ) ] } = e x p { y [ ln ⁡ π − ln ⁡ ( 1 − π ) ] + ln ⁡ ( 1 − π ) } = e x p { y ln ⁡ π 1 − π + ln ⁡ ( 1 − π ) } \begin{aligned} f(y|\pi)&=\pi^y(1-\pi)^{1-y}=exp\{\ln [\pi^y(1-\pi)^{1-y}]\}\\ &=exp\{y\ln \pi+(1-y)\ln(1-\pi)]\}\\ &=exp\{y[\ln \pi-\ln(1-\pi)]+\ln (1-\pi)\}\\ &=exp\{y\ln \frac{\pi}{1-\pi}+\ln (1-\pi)\} \end{aligned} f(y∣π)​=πy(1−π)1−y=exp{ln[πy(1−π)1−y]}=exp{ylnπ+(1−y)ln(1−π)]}=exp{y[lnπ−ln(1−π)]+ln(1−π)}=exp{yln1−ππ​+ln(1−π)}​

对比有，
$$h(x)=1,\theta =\pi ,T(y)=y,\xi (\theta )=\ln \frac{\pi }{1-\pi },B(\theta )=-\ln (1-\pi )$$
即：伯努利分布是指数族分布 ，转换成自然参数形式，
$$\pi =\frac{1}{1+e^{-\xi }}$$

$$A(\xi )=-\ln (1-\pi )=-\ln (1-\frac{1}{1+e^{-\xi }})=\ln (1+e^{\xi })$$
则，
$$E_{\xi }[y]=E_{\xi }[T(y)]=\frac{\partial A(\xi )}{\partial \xi }=\frac{e^{\xi }}{1+e^{\xi }}=\frac{1}{1+e^{-\xi }}$$

3. 逻辑回归模型

逻辑回归之Sigmoid推导

逻辑回归模型是一种广义线性模型。

  特别地，广义线性模型中取，

1. $y_i\sim indep.Bernoulli[{\pi }_i]$
2. 链接函数取logit函数。

即得到逻辑回归模型，
{ y i ∼ i n d e p . f Y i ( y i ) f Y i ( y i ) = π i y ( 1 − π i ) 1 − y , y ∈ { 0 , 1 } E [ y i ] = π i l o g i t ( E [ y i ] ) = θ T x i \begin{cases} y_i\sim indep. f_{Y_i}(y_i)\\ f_{Y_i}(y_i)=\pi_i^{y}(1-\pi_i)^{1-y}, y\in\{0,1\}\\ E[y_i]=\pi_i\\ logit(E[y_i])=\theta^Tx_i \end{cases} ⎩⎪⎪⎪⎨⎪⎪⎪⎧​yi​∼indep.fYi​​(yi​)fYi​​(yi​)=πiy​(1−πi​)1−y,y∈{0,1}E[yi​]=πi​logit(E[yi​])=θTxi​​
Sigmoid函数是logit函数的反函数，可写，
$$\{\begin{array}{l}{y}_i\sim indep.Bernoulli[{\pi }_i]\\ {\pi }_i=E[y_i]=logi{t}^{-1}({\theta }^T{x}_i)=\sigma ({\theta }^T{x}_i)=\frac{1}{1+e^{-{\theta }^T{x}_i}}\end{array}$$
应用：
<1>预测：自变量为$x_i$时，响应变量$y_i$发生的概率（响应变量$y_i$的期望）。
预测函数，
$$h_{\theta }(x)={\pi }_i=\sigma ({\theta }^T{x}_i)=\frac{1}{1+e^{-{\theta }^T{x}_i}}$$
<2>判别：0-1分类任务，
$$\{\begin{array}{l}P(y_i=1|x_i,\theta )=h_{\theta }(x_i)\\ P(y_i=0|x_i,\theta )=1-h_{\theta }(x_i)\end{array}$$
可整合为，$P(y_i|x_i,\theta )=(h_{\theta }(x_i){)}^{y_i}(1-h_{\theta }(x_i){)}^{1-y_i}$。具体地：取定阈值$\alpha$，计算$P(y_i=1|x_i,\theta )$，当$P(y_i=1|x_i,\theta )>\alpha$，分类为1。

3 极大似然估计

  设样本 { ( x ( i ) , y ( i ) ) , 1 ≤ i ≤ n } \{(x^{(i)},y^{(i)}),\quad1\leq i\leq n\} {(x(i),y(i)),1≤i≤n}，似然函数：$$L(\theta )=\prod _{i=1}^{n}P(y^{(i)}|x^{(i)},\theta )=\prod _{i=1}^n(h_{\theta }(x^{(i)}){)}^{y^{(i)}}(1-h_{\theta }(x^{(i)}){)}^{1-y^{(i)}}$$
对数似然函数：
$$l(\theta )=\log L(\theta )=\sum _{i=1}^n[y^{(i)}\log h_{\theta }(x^{(i)})+(1-y^{(i)})\log (1-h_{\theta }(x^{(i)}))]$$
最大化对数似然函数，
$$\underset{\theta }{\max }l(\theta )\iff \underset{\theta }{\min }J(\theta )=-\frac{1}{n}l(\theta )$$
其中$J(\theta )$为平均损失函数，
$$\begin{array}{rl}J(\theta )& =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\log h_{\theta }(x^{(i)})+(1-y^{(i)})\log (1-h_{\theta }(x^{(i)}))]\\ & =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\log \sigma ({\theta }^T{x}^{(i)})+(1-y^{(i)})\log (1-\sigma ({\theta }^T{x}^{(i)}))]\\ & =\frac{1}{n}\sum _{i=1}^n[y^{(i)}\log (1+e^{{\theta }^T{x}^{(i)}})+(1-y^{(i)})\log (1+e^{{\theta }^T{x}^{(i)}})]\end{array}$$

• Logistic损失函数：交叉熵损失函数，$l(y_i,{\hat{y}}_i)=y_i\ln (1+e^{-{\hat{y}}_i})+(1-y_i)\ln (1+e^{{\hat{y}}_i})$
• 如果采用平方误差损失函数：$\frac{1}{2n}{\sum }_{i=1}^n(h_{\theta }(x^{(i)})-y^{(i)}{)}^2$，该函数是非凸的，不便于求解。并且，在距离最优值很远时，其梯度值仍很小。

求梯度，
$$\begin{array}{rl}\frac{\partial }{\partial {\theta }_j}J(\theta )& =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\frac{1}{\sigma ({\theta }^T{x}^{(i)})}\frac{\partial }{\partial {\theta }_j}\sigma ({\theta }^T{x}^{(i)})+(1-y^{(i)})\frac{1}{1-\sigma ({\theta }^T{x}^{(i)})}\frac{\partial }{\partial {\theta }_j}\sigma ({\theta }^T{x}^{(i)})]\\ & =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\frac{1}{\sigma ({\theta }^T{x}^{(i)})}\frac{\partial }{\partial {\theta }_j}\sigma ({\theta }^T{x}^{(i)})+(1-y^{(i)})\frac{1}{1-\sigma ({\theta }^T{x}^{(i)})}\frac{\partial }{\partial {\theta }_j}\sigma ({\theta }^T{x}^{(i)})]\\ & =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\frac{1}{\sigma ({\theta }^T{x}^{(i)})}+(1-y^{(i)})\frac{1}{1-\sigma ({\theta }^T{x}^{(i)})}]\frac{\partial }{\partial {\theta }_j}\sigma ({\theta }^T{x}^{(i)})\\ & =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\frac{1}{\sigma ({\theta }^T{x}^{(i)})}+(1-y^{(i)})\frac{1}{1-\sigma ({\theta }^T{x}^{(i)})}]\sigma ({\theta }^T{x}^{(i)})(1-\sigma ({\theta }^T{x}^{(i)}))\frac{\partial }{\partial {\theta }_j}{\theta }^T{x}^{(i)}\\ & =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}(1-\sigma ({\theta }^T{x}^{(i)}))+(1-y^{(i)})\sigma ({\theta }^T{x}^{(i)})]x_j^{(i)}\\ & =-\frac{1}{n}\sum _{i=1}^n(y^{(i)}-\sigma ({\theta }^T{x}^{(i)}))x_j^{(i)}\\ & =\frac{1}{n}\sum _{i=1}^n(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}\end{array}$$
梯度下降法参数更新，
$${\theta }_j^k={\theta }_j^k-\alpha \frac{1}{n}\sum _{i=1}^n(h_{{\theta }_j^k}(x^{(i)})-y^{(i)})x_j^{(i)}$$

L2正则化

$$\begin{array}{rl}J(\theta )& =-\frac{1}{n}\sum _{i=1}^n[y^{(i)}\log \sigma ({\theta }^T{x}^{(i)})+(1-y^{(i)})\log (1-\sigma ({\theta }^T{x}^{(i)}))]+\frac{\lambda }{2n}||\theta |{|}^2\\ & =\frac{1}{n}\sum _{i=1}^n[y^{(i)}\log (1+e^{{\theta }^T{x}^{(i)}})+(1-y^{(i)})\log (1+e^{{\theta }^T{x}^{(i)}})]+\frac{\lambda }{2n}||\theta |{|}^2\end{array}$$

$$\frac{\partial }{\partial {\theta }_j}J(\theta )=\frac{1}{n}\left[\sum _{i=1}^n(h_{\theta }(x^{(i)})-y^{(i)})x_j^{(i)}+\lambda {\theta }_j\right]$$

$${\theta }_j^k={\theta }_j^k-\alpha \frac{1}{n}\left[\sum _{i=1}^n(h_{{\theta }_j^k}(x^{(i)})-y^{(i)})x_j^{(i)}+\lambda {\theta }_j\right]$$

4. 多分类

Softmax函数：
$$h_{\theta }(x^{(i)})=\left(\begin{array}{c}P(y^{(i)}=1|x^{(i)},\theta )\\ P(y^{(i)}=2|x^{(i)},\theta )\\ ...\\ P(y^{(i)}=k|x^{(i)},\theta )\end{array}\right)=\frac{1}{{\sum }_{j=1}^k{e}^{{\theta }_j^T{x}^{(i)}}}\left(\begin{array}{c}{e}^{{\theta }_1^T{x}^{(i)}}\\ e^{{\theta }_2^T{x}^{(i)}}\\ ...\\ e^{{\theta }_k^T{x}^{(i)}}\end{array}\right)$$

---

Python实现逻辑回归模型

方法1：

#导入包
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
#读取数据并处理
pdData = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted'])#pdData为DataFrame类型
pdData.insert(0, 'Ones', 1)#第1列加上全1向量
orig_data = pdData.values#orig_data为ndarray类型
#数据标准化
from sklearn import preprocessing as pp
scaled_data = orig_data.copy()
scaled_data[:, 1:3] = pp.scale(orig_data[:, 1:3])
#参数占位
theta = np.zeros([1, 3])
#定义Sigmoid函数
def sigmoid(z):
    return 1 / (1 + np.exp(-z))
#定义模型$h_\theta(x)$
def model(X, theta): 
    return sigmoid(np.dot(X, theta.T))
#定义损失函数$J(\theta)$
def cost(X, y, theta):
    left = np.multiply(-y, np.log(model(X, theta)))
    right = np.multiply(1 - y, np.log(1 - model(X, theta)))
    return np.sum(left - right) / (len(X))
#计算损失函数的梯度
def gradient(X, y, theta):
    grad = np.zeros(theta.shape)
    error = (model(X, theta)- y).ravel()
    for j in range(len(theta.ravel())): #for each parmeter
        term = np.multiply(error, X[:,j])
        grad[0, j] = np.sum(term) / len(X)
    
    return grad
#设定三种停止策略
STOP_ITER = 0#迭代次数
STOP_COST = 1#损失函数下降幅度小（再迭代下降的差异可忽略）
STOP_GRAD = 2#梯度值小

def stopCriterion(type, value, threshold):
    if type == STOP_ITER:        return value > threshold
    elif type == STOP_COST:      return abs(value[-1]-value[-2]) < threshold
    elif type == STOP_GRAD:      return np.linalg.norm(value) < threshold
#数据洗牌
import numpy.random

def shuffleData(data):
    np.random.shuffle(data)
    cols = data.shape[1]
    X = data[:, 0:cols-1]
    y = data[:, cols-1:]
    return X, y
#梯度下降法求解（迭代）
import time
##batchSize=1随机梯度下降；batchSize=n批量梯度下降；batchSize指定1到n之间的数，minbatch小批量梯度下降
##stopType停止策略，thresh停止策略对应的阈值
def descent(data, theta, batchSize, stopType, thresh, alpha):    
    #初始化参数
    init_time = time.time()#返回当前时间的时间戳
    i = 0 # 当前迭代次数
    k = 0 # batch起始位置
    X, y = shuffleData(data)#数据
    grad = np.zeros(theta.shape) # 计算的梯度
    costs = [cost(X, y, theta)] # 损失值
    
    while True:
        grad = gradient(X[k:k+batchSize], y[k:k+batchSize], theta)
        ##################判断[k,k+batchSize]是否在样本范围内
        k += batchSize #取batch数量个数据
        if k >= n: 
            k = 0 
            X, y = shuffleData(data) #重新洗牌
        ##################
        theta = theta - alpha*grad # 参数更新
        costs.append(cost(X, y, theta)) # 计算新的损失
        i += 1 

        if stopType == STOP_ITER:       value = i
        elif stopType == STOP_COST:     value = costs
        elif stopType == STOP_GRAD:     value = grad
        if stopCriterion(stopType, value, thresh): break
    
    return theta, i-1, costs, grad, time.time() - init_time

#主程序（执行梯度下降算法，绘图：迭代次数-损失函数）
def runExpe(data, theta, batchSize, stopType, thresh, alpha):
    #import pdb; pdb.set_trace();
    theta, iter, costs, grad, dur = descent(data, theta, batchSize, stopType, thresh, alpha)
    name = "Original" if (data[:,1]>2).sum() > 1 else "Scaled"
    name += " data - learning rate: {} - ".format(alpha)
    
    if batchSize==n: strDescType = "Gradient"
    elif batchSize==1:  strDescType = "Stochastic"
    else: strDescType = "Mini-batch ({})".format(batchSize)
    name += strDescType + " descent - Stop: "
    
    if stopType == STOP_ITER: strStop = "{} iterations".format(thresh)
    elif stopType == STOP_COST: strStop = "costs change < {}".format(thresh)
    else: strStop = "gradient norm < {}".format(thresh)
    name += strStop
    
    print ("***{}\nTheta: {} - Iter: {} - Last cost: {:03.2f} - Duration: {:03.2f}s".format(
        name, theta, iter, costs[-1], dur))
    
    fig, ax = plt.subplots(figsize=(12,4))
    ax.plot(np.arange(len(costs)), costs, 'r')
    ax.set_xlabel('Iterations')
    ax.set_ylabel('Cost')
    ax.set_title(name.upper() + ' - Error vs. Iteration')#upper() 方法将字符串中的小写字母转为大写字母。
    return theta
#调用示例
n=100
runExpe(orig_data, theta, n, STOP_ITER, thresh=5000, alpha=0.000001)
runExpe(scaled_data, theta, n, STOP_ITER, thresh=5000, alpha=0.001)

方法2
class sklearn.linear_model.LogisticRegression(Args)
Args:

• penalty:‘l1’,‘l2’
  调参时如果主要是为了解决过拟合，选择’l2’正则化就够了。若选择’l2’正则化还是过拟合，可考虑’l1’正则化。
  若模型特征非常多，希望一些不重要的特征系数归零，可使用’l1’正则化。
• C: float, default: 1.0
  正则化系数。越小，正则化性越强。
• dual： bool, default: False
  即选择对偶公式(dual)或原始公式(primal)，bool类型默认是原始公式，当样本数大于特征数时，更倾向于原始公式，即False。
• tol: float, default: 1e-4
  对停止标准的容忍，即求解到多少的时候认为已经求得最优解，并停止。float类型，默认值为1e-4。
• solver： 逻辑回归损失函数的优化方法。默认情况是使用‘liblinear’算法。
  • ‘liblinear’：使用坐标轴下降法来迭代优化损失函数。
  • ‘lbfgs’：拟牛顿法的一种。利用损失函数二阶导数矩阵即海森矩阵来迭代优化损失函数。
  • ‘newton-cg’：牛顿法的一种。同上。
  • ‘sag’：随机平均梯度下降。每次迭代仅仅用一部分的样本来计算梯度，适合于样本数据多的时候。

• 多元逻辑回归有OvR(one-vs-rest)和MvM(many-vs-many)两种，而MvM一般比OvR分类相对准确一些。但是，'liblinear’只支持OvR。
• 对于小型数据集来说，选择‘liblinear’更好；对于大型数据集来说，‘saga’或者‘sag’会更快一些。
• 对于多类问题，只能使用‘newton-cg’, ‘sag’, ‘saga’ and ‘lbfgs’。
• 对于正则化来说，‘newton-cg’,‘lbfgs’和‘sag’只能用于L2正则化(因为这些优化算法都需要损失函数的一阶或者二阶连续导数，因此无法用于没有连续导数的L1正则化)；而‘liblinear’,‘saga’则可处理L1正则化。

• fit_intercept: bool, default: True
  即选择是否将偏差(也称截距)添加到决策函数中。bool类型，默认为True，添加。
• intercept_scaling float, default 1
  只在solver选择liblinear并且self.fit_intercept设置为True的时候才有用。float类型。在这种情况下x变为[[x,self.intercept_scaling]
• class_weight dict or ‘balanced’, default: None
  类型权重参数，用于标示分类模型中各种类型的权重。默认是None，即所有类型的权重都一样。

1. 直接输入字典{class_label: weight}来对每个类别权重进行赋值，如{0:0.3,1:0.7}就是指类型0的权重为30%，而类型1的权重为70%。
2. 选择‘balanced’来自动计算类型权重，实际计算公式为：$n_{samples}/(n_{classes}\ast np.bincount(y))$。

在出现误分类代价很高或类别不平衡的情况下，可以通过这个参数来调整权重
1、误分类代价很高：比如说对合法用户和非法用户进行分类，将非法用户分 类为合法用户的代价很高，我们宁愿将合法用户分类为非法用户，这时可 以人工再甄别。
2、类别不平衡：分类任务中不同类别的训练样例数目差别很大，这种情况 在《机器学习》这本书中3.6节有提到，并且提出了“再缩放”的基本策略。

• random_state: int, RandomState instance or None, optional, default: None
  随机数种子。仅在solver为‘sag’或者‘liblinear’时使用。int类型，默认为无。
• max_iter: int, default: 100
  算法收敛最大迭代次数，int类型，默认为100。 只在solver为‘newton-cg’，‘sag’和‘lbfgs’是有用。
• multi_class: str, {‘ovr’, ‘multinomial’}, default: ‘ovr’ 默认为‘ovr’。
  即选择分类方式的参数.

• ‘ovr’即one-vs-rest(OvR)，OvR每次将一个类的样例作为正例，所有其他类的样例作为反例来训练，在测试中若仅有一个分类器预测为正类，则对应的类别标记为最终结果；若有多个分类器预测为正类，则考虑每个分类器的置信度，置信度高的若有多个分类器预测为正类。
• ‘multinomial’即many-vs-many(MvM)。 MvM则是每次将若干类作为正例，若干其他类作为反例。

Attribute:

• coef_(决策函数中的特征系数)
• intercept_(决策函数的偏置)
• n_iter_(所有类的实际迭代次数)。

Methods:

• fit(X,y[,sample_weight]) 根据给定的训练集拟合模型。
  • X：{array-like, sparse matrix} of shape (n_samples, n_features)训练集中的特征
  • y：array-like of shape (n_samples,)训练集中与X相关的标签
  • sample_weight：array-like of shape (n_samples,) default=None默认等权重
  • Returns：self，Fitted estimator.
• predict(X) 预测样本X的类标签。
  • X：array_like or sparse matrix, shape (n_samples, n_features)要预测的样本特征
  • Returns：Carray, shape [n_samples]每个样本的预测标签
• score(X,y[,sample_weight]) 返回给定测试集和标签的平均精度。
• decision_function(X) Predict confidence scores for samples.
• densify() Convert coefficient matrix to dense array format.
• get_paramas([,deep]) Get parameters for this estimator.
• predict_log_proba(X) Predict logarithm of probability estimates.
• predict_proba(X) Probability estimates.
  • 返回的是一个 n 行 k 列的数组， 第 i 行 第 j 列上的数值是模型预测 第 i 个预测样本为某个标签的概率，并且每一行的概率和为1。（k为类别个数）
• set_params(**params) Set the parameters of this estimator.
• sparsify Convert coefficient matrix to sparse format.

LogisticRegression是一个类，使用时要先生成实例，再去调用方法。

from sklearn.linear_model import LogisticRegression
lr=LogisticRegression(penalty='l1', C=1.0)
lr.fit(x_train,y_train)
y_pre=lr.predict(X_validation)

参考：
方法1摘自唐宇迪机器学习系列课程
【机器学习实战】逻辑回归----sklearn库中的LogisticRegression类
sklearn.linear_model.LogisticRegression参数说明
LogisticRegression官方文档