06.逻辑回归介绍

【数学基础-各种熵的概念】

1. 联合熵：
   $H(X,Y)=-\sum _{y\in Y}\sum _{x\in X}p(x,y)logp(x,y)$
2. 条件熵：（记住结论，无须推导）
   条件熵为联合熵减去边缘熵，X发生的条件下，Y发生的这件事带来的信息熵。
   $H(Y|X)=H(X,Y)-H(X)$
3. 互信息（重点）：
   $I(X,Y)=H(X)+H(Y)-H(X,Y)$
   特性： 概率取负对数表征了当前概率发生所代表的信息量。上式表明，两事件的互信息为各自事件单独发生所代表的信息量之和减去两事件同时发生所代表的信息量之后剩余的信息量，这表明了两事件单独发生给出的信息量之和是有重复的，互信息度量了这种重复的信息量大小，最后再求概率和表示了两事件互信息量的期望。从式中也可以看出，当两事件完全独立时，互信息计算为 0，这也是与常识判断相吻合的。
   a）距离（比如cos函数/皮尔逊相关系数）是度量线性相关性，互信息也是度量两个随机变量之间的相关性，不过它站在的角度不是线性相关或者跟距离有关的度量方式，它是站在熵的角度去度量两个随机变量的相关性；
   b）含义：是度量一个随机变量中包含关于另一个随机变量的信息量。一个随机事件发生之后会对另一个随机事件发生它的信息量有一定的减少作用，就是说我们知道一件事件之后，另外一件事对我们的信息量就很低了，当两件事件完全相同，它们的互信息是最大的，互信息越大，它们之间的相关性就越大；
   c）互信息比线性相关性能更好的度量特征和标签的之间的关系。比如皮尔逊相关系数，如果两个变量之间没有线性的相关性，那么它无法度量，针对预测房价回归问题，房价是一个连续值，房价跟房间的面积可以很好的通过皮尔逊相关系数来度量，因为它们之间有线性相关性；但是如果是分类标签，那么皮尔逊相关系数就没有办法度量，因为标签是一个递增的关系，比如n类，那就是1~n的标签值，但是这个分类标签是没有任何含义的。这个时候互信息就可以发挥作用，当一个标签是分类标签时，它可以通过互信息来度量已知晓的特征之后对于标签的不确定性有多少减少，互信息它是经常在分析数据分布的一个指标；
   d）案例分析：房价分段，对于1000个特征，哪些特征对于我们的分类结果的不确定性减少的最多，这个值肯定有一个倒排，对于每个特征都有一个互信息值，对互信息值最大的topN个特征取出来做整个特征的模型训练建模，这个模型就会高效快很多，相当你使用了其中90%的信息量，但是性能却减少了80%损耗，可以达到这样一个效果【在特征筛选可以使用起来】；
4. 互信息、联合熵、条件熵之间的关系
   $H(X,Y)=H(X|Y)+H(Y|X)+I(X,Y)$
   $H(X|Y)+I(X,Y)=H(X)$
   $H(Y|X)+I(X,Y)=H(Y)$
   
5. 交叉熵（重点）：
   a）分类问题99%使用到的损失函数的度量都是交叉熵，在回归问题通常用到的损失函数的度量方式是欧式距离，度量的是两个连续的随机变量之间的距离，而交叉熵在离散的两个随机变量的距离度量上面会使用到；
   b）有两个概率分布，其中p(x)为真实分布，q(x)为非真实分布，在现实建模中，q(x)其实就是预测的那个概率分布，如果要使用非真实分布q(x)去预估这个真实p(x)分布的话，用这种替代关系下的熵的计算过程，其公式如下：
   $H(p,q)=-\sum _{x}p(x)\ast logq(x)$
   其中p(x)指的是它的一个真实概率的值，q(x)是一个预测概率值，所以这个是使用一个非真实分布来代表这个真实分布最终产生的这个真实的熵的结果是多少。因为用这个非真实的分布去预估的时候，非真实分布会产生一个信息量，然后用真实的分布对这个信息量进行加权，就得到最终这个结果。
6. 相对熵-KL散度（重点）：
   $D_{KL}(p||q)=\sum _{x}p(x)\ast log\frac{p(x)}{q(x)}$
   $=-\sum _{x}p(x)\ast logq(x)-[-\sum _{x}p(x)\ast logp(x)]$
   $=H(p,q)-H(p)$
   相对熵等于交叉熵减去真实分布的边缘熵。用预测的分布来表示真实分布之后的熵没有考虑到之前本来真实分布自己的信息熵，假如一个极端情况，p的概率和q的概率完全一样，说明没有差别，当我们的预测系统产生出来的分布q跟真实的分布p完全一样，这个相对熵是最小的为0，所以说相对熵也可以用来做损失函数的度量。也是一种对于离散的两个随机变量度量的分布，它也可以作为一个损失函数的度量方式，不过一般不用相对熵做损失函数，而是使用交叉熵做损失函数，其原因是相对熵是交叉熵减去原真实分布，因为原真实分布在拿到数据集时就已经确定了（比如测试西瓜数据集是不是好西瓜，其实拿到的整个数据集中的熵就已经成为常数了，这个常数在这里没啥意义）。

【逻辑回归】

逻辑回归是用来做分类算法的，线性回归的一般形式是$Y=aX+b$，y的取值范围是$[-\infty ,+\infty ]$，有这么多取值如何分类？可以把Y的结果带入一个非线性变换的sigmoid函数中，即可得到[0,1]之间的取值范围数S，S可以看成一个概率值，如果我们设置概率阀值为0.5，那么S大于0.5可以看成是正样本，小于0.5看成是负样本，就可以进行分类。

【sigmoid函数】

公式：
$S(t)=\frac{1}{1+e^{-t}}$

根据以上公式和图解读：

1. 函数中t无论取什么值，其结果都在[0,-1]的区间内，一个分类问题有两种：是（1）和否（0），假设分类阀值是0.5，那么大于0.5为1，反正为0，这个阀值可以设定；
2. 将Y带入到t中得到逻辑回归的一般模型方程：
   $H(a,b)=\frac{1}{1+e^{-(aX+b)}}$

【扩展：指标】

1. 召回率：
   真实标签【1 0 0 1 0 1 1 0 0 0 0 0】
   预测标签【1 0 0 0 1 0 1 1 1 0 0 0】
   真实的正样本被我们覆盖了多少？比如上面的数据，正样本1只有50%被覆盖。
2. 精准率：
   在我们预测的正样本中有多少是真正的正样本，上面案例只有2个是真正的正样本（$\frac{2}{5}$）。
3. 实际应用中：
   预测患病应该保的是召回率；
   预测地震应该保的是精准率；

【逻辑回归损失函数】

1. 逻辑回归的损失函数是log loss，即对数似然函数或者交叉熵损失，函数公式如下：
   $$Cost(h_{\theta }(x),y)=\{\begin{array}{rl}-log(h_{\theta }(x))& ,y=1\\ -log(1-h_{\theta }(x))& ,y=0\end{array}$$

• 以上公式中y=1表示真实值为1时用第一个公式，真实值为0时用第二个公式计算损失；
• 公式中为什么要加上log函数呢？因为当真实样本为1时，但h=0概率，那么$log0=\infty$，这是对模型最大的惩罚力度；当h=1时，那么$log1=0$，相当没有惩罚，也就是没有损失，达到最优结果，所以用log函数表示损失函数；
• 最后按照梯度下降法一样，求解极小值点，得到想要的模型效果；
• 关于正负样本以及h(x)关系详解：
  a）当样本实际为正样本时，h(x)为预测值，如果预测也是正的，就得到-log1=0，所以说损失为0；
  b）当样本实际为正样本时，但是h(x)预测为负样本，即h(x)=0把它预测错误了，此时log的自变量x取0，log0为负无穷，加个负号变成损失的正无穷；
  c）log(h(x))含义，其中h(x)是预测函数，也可以写成$y^{\prime }$：
  当它是一个正样本但是预测错了，损失很大需要优化，当是一个负样本也预测错了，损失也很大；但是如果预测对了，损失就会很小，所以就会使得h(x)在正样本时极其趋近于1的值，比如0.99，当h(x)是负样本时极其趋近于0的值，比如0.01，这就是希望优化成这样的；

2. 化整表达式（重要）：
   $Cost(h_{\theta }(x),y)=-y\ast log(h_{\theta }(x))-(1-y)\ast log(1-h_{\theta }(x))$
   $J(\theta )=\frac{1}{m}\sum _{i=1}^m[-y^{(i)}\ast log(h_{\theta }(x^{(i)}))-(1-y^{(i)})\ast log(1-h_{\theta }(x^{(i)}))]$
   $J(\theta )=-\frac{1}{m}\sum _{i=1}^m[y^{(i)}\ast log(h_{\theta }(x^{(i)}))+(1-y^{(i)})\ast log(1-h_{\theta }(x^{(i)}))]$
   代码实现：

def cost(theta, X, y):
	w = np.matrix(theta)
	X = np.matrix(X)
	y = np.matrix(y)
	first = np.multiply(y, np.log(sigmoid(X * theta.T)))
	second = np.multiply((1 - y), np.log(sigmoid(1 - X * theta.T)))
	J = -np.sum(first + second) / len(X)
	return J

带入假设函数，其中：
$h_{\theta }(x^{(i)})=\frac{1}{1+e^{-{\theta }^T{x}^{(i)}}}$
$y^{(i)}\ast log(h_{\theta }(x^{(i)}))+(1-y^{(i)})\ast log(1-h_{\theta }(x^{(i)}))$
$=y^{(i)}\ast log(\frac{1}{1+e^{-{\theta }^T{x}^{(i)}}})+(1-y^{(i)})\ast log(1-\frac{1}{1+e^{-{\theta }^T{x}^{(i)}}})$
$=-y^{(i)}\ast log(1+e^{-{\theta }^T{x}^{(i)}})+(1-y^{(i)})\ast log(\frac{e^{-{\theta }^T{x}^{(i)}}}{1+e^{-{\theta }^T{x}^{(i)}}})$
$=-y^{(i)}\ast log(1+e^{-{\theta }^T{x}^{(i)}})+(1-y^{(i)})\ast log(\frac{1}{e^{{\theta }^T{x}^{(i)}}+1})$
$=-y^{(i)}\ast log(1+e^{-{\theta }^T{x}^{(i)}})-(1-y^{(i)})\ast log(1+e^{{\theta }^T{x}^{(i)}})$

【添加正则化的损失函数】

$J(\theta )=-\frac{1}{m}\sum _{i=1}^m[y^{(i)}\ast log(h_{\theta }(x^{(i)}))+(1-y^{(i)})\ast log(1-h_{\theta }(x^{(i)}))]+\frac{\lambda }{2m}\sum _{j=1}^n{\theta }_j^2$
在线性回归时有正则化，正则化的目标是为了防止过拟合，在逻辑回归也适应，它指的是为损失函数添加一个约束的一个统称叫正则化，有L1和L2，不过L1对于参数求解的结果会有稀疏性的倾向，所以一般不会使用L1，只会在线性回归里面使用L1，特征工程性比较强的情况下使用，所以经常使用的是L2，如上公式，代码实现：

def re_cost(theta, X, y, learning_rate):
	theta = np.matrix(theta)
	X = np.matrix(X)
	y = np.matrix(y)
	first = np.multiply(y, np.log(sigmoid(X * theta.T)))
	second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))
	reg = (learning_rate / (2 * len(X)) * np.sum(np.power(theta[:, 1:theta.shape[1]], 2))
	J = (-np.sum(first - second) / len(X)) + reg

【从极大似然估计理解逻辑回归的损失函数】

逻辑回归的损失函数别名一：负对数似然损失
似然函数就是一整个事件发生的概率，每个样本与样本之间是独立的，所以整个似然函数的值就是每个样本发生的概率之间的连乘，一共有n个样本，在伯努利分布下（二分类，样本标签只有两种取值），函数的公式如下：
$\prod _{i=1}^n[h(x_i){]}^{y_i}\ast [1-h(x_i){]}^{1-y_i}$
其中$h(x_i)$表示某个样本属于哪个标签概率值的估计，y为分类标签1和0。
对数似然函数（其实就是给似然函数取了一个对数，这样连乘关系可以转换为连加关系）：
$L(W)=\sum _{i=1}^N[y_i\ast logh(x_i)+(1-y_i)\ast log(1-h(x_i))]$

【从交叉熵的角度理解逻辑回归的损失函数】

逻辑回归的损失函数别名二：交叉熵损失
$H(p,q)=-\sum _{x}p(x)\ast logq(x)$
使用一个估计的分布q(x)（即h(x)）去表示一个真实的分配p的时候，那么整个事件产生的交叉熵就是上面的公式。

【逻辑回归优化方法】

梯度下降，公式推导如下：
$J(\theta )=-\frac{1}{m}\sum _{i=1}^m[y^{(i)}\ast log{h}_{\theta }(x^{(i)})+(1-y^{(i)})\ast log(1-h_{\theta }(x^{(i)}))]$
$=-\frac{1}{m}\sum _{i=1}^m[-y^{(i)}\ast log(1+e^{-{\theta }^T{x}^{(i)}})-(1-y^{(i)})\ast log(1+e^{{\theta }^T{x}^{(i)}})]$
$\frac{\partial }{{\theta }_j}J(\theta )=-\frac{1}{m}\sum _{i=1}^m[-y^{(i)}\ast \frac{e^{-{\theta }^T{x}^{(i)}}\ast (-x_j^{(i)})}{1+e^{-{\theta }^T{x}^{(i)}}}-(1-y^{(i)})\ast \frac{e^{{\theta }^T{x}^{(i)}}\ast x_j^{(i)}}{1+e^{{\theta }^T{x}^{(i)}}}]$
$=-\frac{1}{m}\sum _{i=1}^m[\frac{y^{(i)}{x}_j^{(i)}\ast e^{-{\theta }^T{x}^{(i)}}}{\frac{e^{{\theta }^T{x}^{(i)}}+1}{e^{{\theta }^T{x}^{(i)}}}}-(1-y^{(i)})\ast \frac{e^{{\theta }^T{x}^{(i)}}\ast x_j^{(i)}}{1+e^{{\theta }^T{x}^{(i)}}}]$
$=-\frac{1}{m}\sum _{i=1}^m[\frac{y^{(i)}{x}_j^{(i)}}{1+e^{{\theta }^T{x}^{(i)}}}-(1-y^{(i)})\ast \frac{e^{{\theta }^T{x}^{(i)}}\ast x_j^{(i)}}{1+e^{{\theta }^T{x}^{(i)}}}]$
$=-\frac{1}{m}\sum _{i=1}^m[\frac{y^{(i)}{x}_j^{(i)}-x_j^{(i)}{e}^{{\theta }^T{x}^{(i)}}+y^{(i)}{x}_j^{(i)}\ast e^{{\theta }^T{x}^{(i)}}}{1+e^{{\theta }^T{x}^{(i)}}}]$
$=-\frac{1}{m}\sum _{i=1}^m[\frac{y^{(i)}\ast (1+e^{{\theta }^T{x}^{(i)}})-e^{{\theta }^T{x}^{(i)}}}{1+e^{{\theta }^T{x}^{(i)}}}\ast x_j^{(i)}]$
$=-\frac{1}{m}\sum _{i=1}^m[(y^{(i)}-\frac{e^{{\theta }^T{x}^{(i)}}}{1+e^{{\theta }^T{x}^{(i)}}})\ast x_j^{(i)}]$
$=-\frac{1}{m}\sum _{i=1}^m[(y^{(i)}-\frac{1}{1+e^{-{\theta }^T{x}^{(i)}}})\ast x_j^{(i)}]$
$=-\frac{1}{m}\sum _{i=1}^m[(y^{(i)}-h_{\theta }(x^{(i)}))\ast x_j^{(i)}]$
$=\frac{1}{m}\sum _{i=1}^m[(h_{\theta }(x^{(i)})-y^{(i)})\ast x_j^{(i)}]$
根据以上公式推导发现：

• 导数形式和线性回归很像（预测值-真实label，再乘以$x_j^{(i)}$这个样本的特征值，m就是针对批量的梯度下降，样本大于1，对所有的样本单独的梯度求平均）；
• 虽然梯度公式一样，但还有有本质区别，它们的决策函数不一样，线性回归为y=wx+b，逻辑回归为sigmoid(y)函数；

【逻辑回归代码实战】

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

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
print(df.head(5))

df['label'] = iris.target
print(df.columns)
data = np.array(df.iloc[:100, [0,1,-1]])
X, y = data[:, 0:2], data[:, -1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

def sigmoid(x):
    return 1 / (1 + math.exp(-x))
def data_matrix(X):
    data_mat = []
    for d in X:
        data_mat.append([1.0, *d]) # add bias
    return data_mat #(100,3)

learning_rate = 0.01
X_train = data_matrix(X_train)
X_test = data_matrix(X_test)

def fit_score(iters=10):
    theta = np.ones((len(X_train[0]), 1), dtype=np.float32)
    for j in range(iters):
        for i in range(len(X_train)):
            y_hat = sigmoid(np.dot(X_train[i], theta)) #scalar = (1,3) * (3,1)
            error = y_train[i] - y_hat #scalar
            theta += learning_rate * error * np.transpose([X_train[i]]) #(3,1) = scalar * scalar * (1,3).T
            theta_list = [theta[0][0], theta[1][0], theta[2][0]]
    print('theta = ', theta_list)

    right = 0
    for i in range(len(X_test)):
        result = np.dot(X_test[i], theta) # scalar = (1,3) * (3,1)
        result = result[0]
        y = y_test[i]
        if (result > 0 and y == 1) or (result < 0 and y == 0):
            right += 1
    print('iters = %d, right rate = %0.6f' %(iters, right / len(X_test)))

	x_points = np.arange(4, 8)
    #w1*x1+w2*x2+b=0 => x2=-(w1*x1+b)/w2
    y = -(theta_list[1] * x_points + theta_list[0]) / theta_list[2]
    plt.plot(x_points, y, 'r')
    plt.scatter(X[:50, 0], X[:50, 1], label='0')
    plt.scatter(X[50:, 0], X[50:, 1], label='1')
    plt.legend()
    plt.show()
    
fit_score(1)
fit_score(3)
fit_score(5)
fit_score(7)
fit_score(9)
fit_score(200)

运行结果：

【sklearn实现逻辑回归】

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

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
data = np.array(df.iloc[:100, [0,1,-1]])
X, y = data[:, 0:2], data[:, -1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(max_iter=200)
lr.fit(X_train, y_train)
score = lr.score(X_test, y_test)
print(score)
print(lr.coef_, lr.intercept_)

x_points = np.arange(4, 8)
w1 = lr.coef_[0][0]
w2 = lr.coef_[0][1]
b = lr.intercept_
y = -(w1 * x_points + b) / w2
plt.plot(x_points, y)

plt.plot(X[:50, 0], X[:50, 1], 'bo', color='blue', label='0')
plt.plot(X[50:, 0], X[50:, 1], 'bo', color='red', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.show()

1.0
[[ 2.63668516 -2.73264341]] [-5.74228817]]

【softmax】

在二元逻辑回归模型中，二分类使用的决策函数是sigmoid函数，如果预测多分类，则与sigmoid函数对应的决策函数为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)}=3|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 }_3^T{x}^{(i)}}\\ ...\\ e^{{\theta }_k^T{x}^{(i)}}\end{array}\right]$$

1. softmax为k维向量，一共有k个类别，分母为归一化项，使得总和为1；
2. softmax仿射函数为$e^{{\theta }_k^T{x}^{(i)}}$，这个值一般叫做Z值，就是整个线性部分得到的结果，这个值会做一个指数的变换，然后再做一个回归化处理；
3. softmax为什么要做指数的运算？原因是为了放大${\theta }_k^T{x}^{(i)}$这个值对于整个情况的影响，比如$2^2$和$10^2$，其中2和10是线性差别，但是$2^2$和$10^2$指数之间的差别就非常大了。所以指数的目的就是为了将差异放大，算出来最终的那个值会把整个数据更加偏向某一个值特别大，而其他值比较小的状态，这就是使用指数的原因，这个概念可以理解为softmax中max，就是为了突出多分类中其中一个类别的标签概率最大；
4. softmax中的soft，虽然说预测其中一个标签的概率值最大，但是其他标签的概率并不是0，也不能为0，因为为0梯度下降有连乘的效应，关于$\theta$所有的参数都没有办法进行更新，因为后面的学习率乘以导数的部分都为0，这样没法进行学习；
5. softmax一个极好特质：不但要保持其他概率值极小，而且真正的样本概率极大的情况下，还不能让它为0；
   
   损失函数公式如下：
   J ( θ ) = − 1 m [ ∑ i = 1 m ∑ j = 1 k 1 { y ( i ) = j } l o g e θ j T x ( i ) ∑ l = 1 k e θ i T x ( i ) ] J(\theta)=-{\frac{1}{m}}[\displaystyle\sum_{i=1}^m\displaystyle\sum_{j=1}^k1\{y^{(i)}=j\}log{\frac{e^{\theta_j^Tx^{(i)}}}{\displaystyle\sum_{l=1}^ke^{\theta_i^Tx^{(i)}}}}] J(θ)=−m1​[i=1∑m​j=1∑k​1{y(i)=j}logl=1∑k​eθiT​x(i)eθjT​x(i)​]
   其中大括号的取值规则为大括号内的表达式值为真时，取 1，为假时取 0。
   其导数公式如下：
   ∂ θ j J ( θ ) = − 1 m ∑ i = 1 m [ x ( i ) ( 1 { y ( i ) = j } − p ( y ( i ) = j ∣ x ( i ) ; θ ) ] \frac{\partial}{\theta_j}J(\theta)=-{\frac{1}{m}}\displaystyle\sum_{i=1}^m[x^{(i)}(1\{y^{(i)}=j\}-p(y^{(i)}=j|x^{(i)};\theta)] θj​∂​J(θ)=−m1​i=1∑m​[x(i)(1{y(i)=j}−p(y(i)=j∣x(i);θ)]

【逻辑回归有什么优点】

1. LR能以概率的形式输出结果，而非只是0,1判定；
2. LR的可解释性强，可控度高，可以拿到特征权值，进行重要性分析、正负型分析，哪些特征对于最终结果的计算是有比较强的共性的以及正负相关性如何，都是可以解释的；
3. 训练快，特征工程做好了，feature engineering之后效果赞，基本上深度学习模型在AUC上比逻辑回归的提升也只是提升个位数的点；
4. 因为结果是概率，可以做ranking model；

Ps：特征一般比模型更加能提升整个算法效果，比如做好特征工程可以将效果由60%提升到90%，但是在特征数据不变的情况下，改变模型算法一般只能提升个位数的效果，比如由60%提升到69%，无法做到大幅提升，所以一般公司会一直迭代数据和特征；

【逻辑回归有哪些应用】

1. CTR预估/推荐系统的learning to rank/各种分类场景。
2. 某搜索引擎厂的广告CTR预估基线版是LR。
3. 某电商搜索排序/广告CTR预估基线版是LR。
4. 某电商的购物搭配推荐用了大量LR。
5. 某电商一天广告赚1000w+的新闻app排序基线是LR。

【逻辑斯特回归为什么要对特征进行离散化】

1. 非线性！逻辑回归属于广义线性模型，表达能力受限；单变量离散化为N个后，每个变量有单独的权重，相当于为模型引入了非线性，能够提升模型表达能力，加大拟合； 离散特征 的增加和减少都很容易，易于模型的快速迭代；
2. 速度快！稀疏向量内积乘法运算速度快，计算结果方便存储，容易扩展；
3. 鲁棒性！离散化后的特征对异常数据有很强的鲁棒性：比如一个特征是年龄>30是1，否则0。如果特征没有离散化，一个异常数据“年龄300岁”会给模型造成很大的干扰；
4. 方便交叉与特征组合：离散化后可以进行特征交叉，由M+N个变量变为M*N个变量，进一步引入非线性，提升表达能力。比如电商用户：[女性+高收入]推荐高端发妆品，[女性+中等收入]推荐中等发妆品；
5. 稳定性：特征离散化后，模型会更稳定，比如如果对用户年龄离散化，20-30作为一个区间，不会因为一个用户年龄长了一岁就变成一个完全不同的人。当然处于区间相邻处的样本会刚好相反，所以怎么划分区间是门学问；
6. 简化模型：特征离散化以后，起到了简化了逻辑回归模型的作用，降低了模型过拟合的风险。

【逻辑回归的目标函数中增大L1正则化会是什么结果】

一般情况下，逻辑回归不推荐使用L1正则化，因为这样会导致我们得到一个非常稀疏的矩阵，可能所有的参数w都会变成0。