线性回归、逻辑回归-学习笔记整理

线性回归

线性回归(Linear regression)是利用回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方式。
只有一个自变量的情况称为单变量回归，多于一个自变量情况的叫做多元回归

线性回归用矩阵表示举例

线性回归的特征与目标的关系

线性关系

• 单变量线性关系
  
• 多变量线性关系
  
  单特征与目标值的关系呈直线关系，或者两个特征与目标值呈现平面的关系
• 非线性关系
  
  如果是非线性关系，那么回归方程可以理解为：w₁x₁+w₂x₂²+w₃x₃²

线性回归API

sklearn.linear_model.LinearRegression()

• LinearRegression.coef_：回归系数（w₁,w₂,w₃,…,w_n)
• LinearRegression.intercept_：偏置 (b)

from sklearn.linear_model import LinearRegression
# 1.数据获取
x = [[80, 86],

[82, 80],

[85, 78],

[90, 90],

[86, 82],

[82, 90],

[78, 80],

[92, 94]]

y = [84.2, 80.6, 80.1, 90, 83.2, 87.6, 79.4, 93.4]
# 2.基本处理
# 3.特征工程
# 4.机器学习
# 4.1构建模型
estimator = LinearRegression()
# 4.2训练模型
estimator.fit(x,y)
# 5.模型评估

# 获取回归系数
estimator.coef_
# 获取偏置
estimator.intercept_

常见函数的导数

导数的四则运算

线性回归的损失和优化

损失函数

真实结果与预测的结果之间存在的一定误差。损失函数值越小，预测结果越接近真实结果。

• yi为第i个训练样本的真实值
• h(xi)为第i个训练样本特征值组合预测函数
• 又称最小二乘法

正规方程

X为特征值矩阵，y为目标值矩阵。直接求到最好的结果
缺点：当特征过多过复杂时，求解速度太慢并且得不到结果

正规方程推导
把该损失函数转换成矩阵写法：

其中y是真实值矩阵，X是特征值矩阵，w是权重矩阵
对其求解关于w的最小值，起止y,X 均已知二次函数直接求导，导数为零的位置，即为最小值。
求导：

梯度下降(Gradient Descent)

梯度下降法的基本思想可以类比为一个下山的过程。
假设这样一个场景：一个人被困在山上，需要从山上下来(i.e. 找到山的最低点，也就是山谷)。但此时山上的浓雾很大，导致可视度很低。因此，下山的路径就无法确定，他必须利用自己周围的信息去找到下山的路径。这个时候，他就可以利用梯度下降算法来帮助自己下山。具体来说就是，以他当前的所处的位置为基准，寻找这个位置最陡峭的地方，然后朝着山的高度下降的地方走，（同理，如果我们的目标是上山，也就是爬到山顶，那么此时应该是朝着最陡峭的方向往上走）。然后每走一段距离，都反复采用同一个方法，最后就能成功的抵达山谷。

梯度下降的基本过程就和下山的场景很类似。
首先，我们有一个可微分的函数。这个函数就代表着一座山。
我们的目标就是找到这个函数的最小值，也就是山底。
根据之前的场景假设，最快的下山的方式就是找到当前位置最陡峭的方向，然后沿着此方向向下走，对应到函数中，就是找到给定点的梯度 ，然后朝着梯度相反的方向，就能让函数值下降的最快！因为梯度的方向就是函数之变化最快的方向。 所以，我们重复利用这个方法，反复求取梯度，最后就能到达局部的最小值，这就类似于我们下山的过程。而求取梯度就确定了最陡峭的方向，也就是场景中测量方向的手段。

梯度

梯度是微积分中一个很重要的概念
​在单变量的函数中，梯度其实就是函数的微分，代表着函数在某个给定点的切线的斜率
​在多变量函数中，梯度是一个向量，向量有方向，梯度的方向就指出了函数在给定点的上升最快的方向
这也就说明了为什么我们需要千方百计的求取梯度！我们需要到达山底，就需要在每一步观测到此时最陡峭的地方，梯度就恰巧告诉了我们这个方向。梯度的方向是函数在给定点上升最快的方向，那么梯度的反方向就是函数在给定点下降最快的方向，这正是我们所需要的。所以我们只要沿着梯度的反方向一直走，就能走到局部的最低点！

梯度下降

• 单变量函数的梯度下降
  假设有一个单变量的函数 :J(θ) = θ²
  函数的微分:J`(θ) = 2θ
  初始化，起点为： θ₀= 1
  学习率：α = 0.4
  梯度下降的迭代计算过程:
  
  
• 多变量函数的梯度下降
  假设有一个目标函数 ：:J(θ) = θ₁² + θ₂²
  假设初始的起点为: θ₀ = (1, 3)
  初始的学习率为:α = 0.1
  函数的梯度为:▽:J(θ) =< 2θ₁ ,2θ₂>
  进行多次迭代:
  
  

梯度下降（Gradient Descent）公式

α在梯度下降算法中被称作为学习率或者步长,学习率太小，每次移动步长太小，收敛太慢。学习率太大，每次移动步长大，可能导致不收敛，错过最优解。

梯度下降和正规方程的对比

梯度下降	正规方程
需要选择学习率	不需要
需要迭代求解	一次运算得出
特征数量较大可以使用	需要计算方程，时间复杂度高O(n3)

• 选择：
  • 小规模数据：
    • LinearRegression(不能解决拟合问题)
    • 岭回归
  • 大规模数据：SGDRegressor

常见的梯度下降算法有：

• 全梯度下降算法(Full gradient descent）
• 随机梯度下降算法（Stochastic gradient descent）
• 随机平均梯度下降算法（Stochastic average gradient descent）
• 小批量梯度下降算法（Mini-batch gradient descent）

它们都是为了正确地调节权重向量，通过为每个权重计算一个梯度，从而更新权值，使目标函数尽可能最小化。其差别在于样本的使用方式不同。

全梯度下降算法（FG）

计算训练集所有样本误差，对其求和再取平均值作为目标函数。
权重向量沿其梯度相反的方向移动，从而使当前目标函数减少得最多。
因为在执行每次更新时，我们需要在整个数据集上计算所有的梯度，所以批梯度下降法的速度会很慢，同时，批梯度下降法无法处理超出内存容量限制的数据集。
批梯度下降法同样也不能在线更新模型，即在运行的过程中，不能增加新的样本。
其是在整个训练数据集上计算损失函数关于参数θ的梯度：

随机梯度下降算法（SG）

由于FG每迭代更新一次权重都需要计算所有样本误差，而实际问题中经常有上亿的训练样本，故效率偏低，且容易陷入局部最优解，因此提出了随机梯度下降算法。
其每轮计算的目标函数不再是全体样本误差，而仅是单个样本误差，即每次只代入计算一个样本目标函数的梯度来更新权重，再取下一个样本重复此过程，直到损失函数值停止下降或损失函数值小于某个可以容忍的阈值。
此过程简单，高效，通常可以较好地避免更新迭代收敛到局部最优解。其迭代形式为

每次只使用一个样本迭代，若遇上噪声则容易陷入局部最优解。
其中，x⁽ⁱ⁾表示一条训练样本的特征值，y⁽ⁱ⁾表示一条训练样本的标签值
但是由于，SG每次只使用一个样本迭代，若遇上噪声则容易陷入局部最优解。

小批量梯度下降算法（mini-bantch）

小批量梯度下降算法是FG和SG的折中方案,在一定程度上兼顾了以上两种方法的优点。
每次从训练样本集上随机抽取一个小样本集，在抽出来的小样本集上采用FG迭代更新权重。
被抽出的小样本集所含样本点的个数称为batch_size，通常设置为2的幂次方，更有利于GPU加速处理。
特别的，若batch_size=1，则变成了SG；若batch_size=n，则变成了FG.其迭代形式为

随机平均梯度下降算法（SAG）

在SG方法中，虽然避开了运算成本大的问题，但对于大数据训练而言，SG效果常不尽如人意，因为每一轮梯度更新都完全与上一轮的数据和梯度无关。
随机平均梯度算法克服了这个问题，在内存中为每一个样本都维护一个旧的梯度，随机选择第i个样本来更新此样本的梯度，其他样本的梯度保持不变，然后求得所有梯度的平均值，进而更新了参数。
如此，每一轮更新仅需计算一个样本的梯度，计算成本等同于SG，但收敛速度快得多。
梯度下降优化算法综述
（1）FG方法由于它每轮更新都要使用全体数据集，故花费的时间成本最多，内存存储最大。
（2）SAG在训练初期表现不佳，优化速度较慢。这是因为常将初始梯度设为0，而SAG每轮梯度更新都结合了上一轮梯度值。
（3）综合考虑迭代次数和运行时间，SG表现性能都很好，能在训练初期快速摆脱初始梯度值，快速将平均损失函数降到很低。但要注意，在使用SG方法时要慎重选择步长，否则容易错过最优解。
（4）mini-batch结合了SG的“胆大”和FG的“心细”，它的表现也正好居于SG和FG二者之间。在目前的机器学习领域，mini-batch是使用最多的梯度下降算法，正是因为它避开了FG运算效率低成本大和SG收敛效果不稳定的缺点。

线性回归api再介绍

• sklearn.linear_model.LinearRegression(fit_intercept=True)
  • 通过正规方程优化
  • fit_intercept：是否计算偏置
  • LinearRegression.coef_：回归系数
  • LinearRegression.intercept_：偏置
• sklearn.linear_model.SGDRegressor(loss=“squared_loss”, fit_intercept=True, learning_rate =‘invscaling’, eta0=0.01)
  • SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型。
  • loss:损失类型
    • loss=”squared_loss”: 普通最小二乘法
  • fit_intercept：是否计算偏置
  • learning_rate : string, optional
    • 学习率填充
    • ‘constant’: eta = eta0
    • ‘optimal’: eta = 1.0 / (alpha * (t + t0)) [default]
    • ‘invscaling’: eta = eta0 / pow(t, power_t)
      • power_t=0.25:存在父类当中
    • 对于一个常数值的学习率来说，可以使用learning_rate=’constant’ ，并使用eta0来指定学习率。
  • SGDRegressor.coef_：回归系数
  • SGDRegressor.intercept_：偏置

案例：波士顿房价预测

• 数据集
  
  
• 使用正规方程求解

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression  # 正规方程优化
from sklearn.metrics import mean_squared_error

# 1.获取数据
data = load_boston()

# 2.数据处理-数据集划分
x_train,x_test,y_train,y_test = train_test_split(data.data,data.target,test_size=0.2,random_state=10)

# 3.特征工作-标准化
# 实例化转换器
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.fit_transform(x_test)

# 4.机器学习-线性回归
# 4.1构建模型
# 实例化估计器
estimator = LinearRegression()
# 4.2训练模型
estimator.fit(x_train,y_train)

# 5.模型评估-MSE均方误差
# 衡量预测值和真实值的差距
# 5.1 获取预测值
y_predict = estimator.predict(x_test)
# MSE
mean_squared_error(y_pred=y_predict,y_true=y_test)

回归性能评估
均方误差(Mean Squared Error)MSE)评价机制：

注：yⁱ为预测值，¯y为真实值
sklearn.metrics.mean_squared_error(y_true, y_pred)
均方误差回归损失

• y_true:真实值

• y_pred:预测值

• return:浮点数结果

• 梯度下降法求解

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor  # 梯度下降
from sklearn.metrics import mean_squared_error

# 1.数据获取
data_T = load_boston()

# 2.数据处理-数据集划分
x_train,x_test,y_train,y_test = train_test_split(data_T.data,data_T.target,test_size=0.2,random_state=10)

# 3.特征工程-标准化
transform = StandardScaler()
x_train = transform.fit_transform(x_train)
x_test = transform.fit_transform(x_test)

# 4.机器学习-线性回归
# 4.1模型建立
estimator = SGDRegressor(max_iter=1000,tol=0.0001) # max_iter最大迭代次数 ,tol可接收的梯度最小值
# 4.2训练模型
estimator.fit(x_train,y_train)

# 5.模型评估
y_predict = estimator.predict(x_test)
# MSE 
mean_squared_error(y_pred=y_predict,y_true=y_test)

欠拟合和过拟合

• 过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
• 欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)

欠拟合原因以及解决办法
原因：学习到数据的特征过少
解决办法：

• 添加其他特征项，有时候我们模型出现欠拟合的时候是因为特征项不够导致的，可以添加其他特征项来很好地解决。例如，“组合”、“泛化”、“相关性”三类特征是特征添加的重要手段，无论在什么场景，都可以照葫芦画瓢，总会得到意想不到的效果。除上面的特征之外，“上下文特征”、“平台特征”等等，都可以作为特征添加的首选项。
• 添加多项式特征，这个在机器学习算法里面用的很普遍，例如将线性模型通过添加二次项或者三次项使模型泛化能力更强。

过拟合原因以及解决办法
原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点
解决办法：

• 重新清洗数据，导致过拟合的一个原因也有可能是数据不纯导致的，如果出现了过拟合就需要我们重新清洗数据。
• 增大数据的训练量，还有一个原因就是我们用于训练的数据量太小导致的，训练数据占总数据的比例过小。
• 正则化
• 减少特征维度，防止维灾难

正则化

在学习的时候，数据提供的特征有些影响模型复杂度或者这个特征的数据点异常较多，所以算法在学习的时候尽量减少这个特征的影响（甚至删除某个特征的影响），就是正则化.

正则化类别

• L2正则化
  • 作用：可以使得其中一些W的都很小，都接近于0，削弱某个特征的影响
  • 优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
  • Ridge回归
• L1正则化
  • 作用：可以使得其中一些W的值直接为0，删除这个特征的影响
  • LASSO回归

正则化线性模型

Ridge Regression (岭回归，又名 Tikhonov regularization)

岭回归是线性回归的正则化版本，即在原来的线性回归的 cost function 中添加正则项（regularization term）:

以达到在拟合数据的同时，使模型权重尽可能小的目的,岭回归代价函数:

α=0：岭回归退化为线性回归

Lasso Regression(Lasso 回归)

Lasso 回归是线性回归的另一种正则化版本，正则项为权值向量的ℓ1范数。
Lasso回归的代价函数 ：

注意

• Lasso Regression 的代价函数在 θ_i=0处是不可导的.
• 解决方法：在θ_i=0处用一个次梯度向量(subgradient vector)代替梯度，如下式
• Lasso Regression 的次梯度向量
  
  Lasso Regression 有一个很重要的性质是：倾向于完全消除不重要的权重。
  例如：当α 取值相对较大时，高阶多项式退化为二次甚至是线性：高阶多项式特征的权重被置为0。
  也就是说，Lasso Regression 能够自动进行特征选择，并输出一个稀疏模型（只有少数特征的权重是非零的）。

Elastic Net (弹性网络)

弹性网络在岭回归和Lasso回归中进行了折中，通过 混合比(mix ratio) r 进行控制：

• r=0：弹性网络变为岭回归
• r=1：弹性网络便为Lasso回归

弹性网络的代价函数 ：

• 常用：岭回归
• 假设只有少部分特征是有用的：
  • 弹性网络
  • Lasso
  • 一般来说，弹性网络的使用更为广泛。因为在特征维度高于训练样本数，或者特征是强相关的情况下，Lasso回归的表现不太稳定。

api:

from sklearn.linear_model import Ridge, ElasticNet, Lasso

线性回归的改进-岭回归

• sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True,solver=“auto”, normalize=False)
  • 具有l2正则化的线性回归
  • alpha:正则化力度，也叫 λ
    • λ取值：0~1 1~10
  • solver:会根据数据自动选择优化方法
  • sag:如果数据集、特征都比较大，选择该随机梯度下降优化
  • normalize:数据是否进行标准化
    • normalize=False:可以在fit之前调用preprocessing.StandardScaler标准化数据
  • Ridge.coef_:回归权重
  • Ridge.intercept_:回归偏置

Ridge方法相当于SGDRegressor(penalty=‘l2’, loss=“squared_loss”),只不过SGDRegressor实现了一个普通的随机梯度下降学习，推荐使用Ridge(实现了SAG)

• sklearn.linear_model.RidgeCV(_BaseRidgeCV, RegressorMixin)
  • 具有l2正则化的线性回归，可以进行交叉验证
  • coef_:回归系数

class _BaseRidgeCV(LinearModel):
    def __init__(self, alphas=(0.1, 1.0, 10.0),
                 fit_intercept=True, normalize=False,scoring=None,
                 cv=None, gcv_mode=None,
                 store_cv_values=False):

案例：岭回归-波士顿房价预测

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import Ridge

# 1数据获取
data = load_boston()

# 2.数据处理,划分数据集
x_train,x_test,y_train,y_test = train_test_split(data.data,data.target,test_size=0.2,random_state=10)

# 3.特征工程-标准化
transform = StandardScaler()
x_train = transform.fit_transform(x_train)
x_test = transform.fit_transform(x_test)

# 4.机器学习
# 4.1模型建立
# Rideg(alpha=正则化力度),正则化力度越小,越接近0,权重系数越大
estimator = Ridge(alpha=1.0)
# 4.2模型训练
estimator.fit(x_train,y_train)

# 5.模型评估
y_predict = estimator.predict(x_test)

print("预测值为:\n", y_predict)
print("模型中的系数为:\n", estimator.coef_)
print("模型中的偏置为:\n", estimator.intercept_)

# 均方误差
error = mean_squared_error(y_test, y_predict)
print("误差为:\n", error)

• 正则化力度越大，权重系数会越小
• 正则化力度越小，权重系数会越大

模型的保存和加载

sklearn模型的保存和加载API

• from sklearn.externals import joblib
  • 保存：joblib.dump(estimator, ‘test.pkl’)
  • 加载：estimator = joblib.load(‘test.pkl’)

def load_dump_demo():
    """
    线性回归:岭回归
    :return:
    """
    # 1.获取数据
    data = load_boston()

    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, random_state=22)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-线性回归(岭回归)
    # # 4.1 模型训练
    # estimator = Ridge(alpha=1)
    # estimator.fit(x_train, y_train)
    #
    # # 4.2 模型保存
    # joblib.dump(estimator, "./data/test.pkl")

    # 4.3 模型加载
    estimator = joblib.load("./data/test.pkl")

    # 5.模型评估
    # 5.1 获取系数等值
    y_predict = estimator.predict(x_test)
    print("预测值为:\n", y_predict)
    print("模型中的系数为:\n", estimator.coef_)
    print("模型中的偏置为:\n", estimator.intercept_)

    # 5.2 评价
    # 均方误差
    error = mean_squared_error(y_test, y_predict)
    print("误差为:\n", error)

逻辑回归

逻辑回归（Logistic Regression）是机器学习中的一种分类模型，逻辑回归是一种分类算法，虽然名字中带有回归，但是它与回归之间有一定的联系。由于算法的简单和高效，在实际中应用非常广泛。

逻辑回归的原理

逻辑回归的输入就是一个线性回归的结果。

激活函数
sigmoid函数

判断标准

• 回归的结果输入到sigmoid函数当中
• 输出结果：[0, 1]区间中的一个概率值，默认为0.5为阈值
  
  逻辑回归最终的分类是通过属于某个类别的概率值来判断是否属于某个类别，并且这个类别默认标记为1(正例),另外的一个类别会标记为0(反例)。（方便损失计算）
  输出结果解释(重要)：假设有两个类别A，B，并且假设我们的概率值为属于A(1)这个类别的概率值。现在有一个样本的输入到逻辑回归输出结果0.6，那么这个概率值超过0.5，意味着我们训练或者预测的结果就是A(1)类别。那么反之，如果得出结果为0.3那么，训练或者预测结果就为B(0)类别。
  

损失以及优化 损失

损失

逻辑回归的损失，称之为对数似然损失，公式如下：
分开类别：


综合完整损失函数

优化

同样使用梯度下降优化算法，去减少损失函数的值。这样去更新逻辑回归前面对应算法的权重参数，提升原本属于1类别的概率，降低原本是0类别的概率。

逻辑回归api

sklearn.linear_model.LogisticRegression(solver=‘liblinear’, penalty=‘l2’, C = 1.0)

• solver可选参数:{‘liblinear’, ‘sag’, ‘saga’,‘newton-cg’, ‘lbfgs’}，
  • 默认: ‘liblinear’；用于优化问题的算法。
  • 对于小数据集来说，“liblinear”是个不错的选择，而“sag”和’saga’对于大型数据集会更快。
  • 对于多类问题，只有’newton-cg’， ‘sag’， 'saga’和’lbfgs’可以处理多项损失;“liblinear”仅限于“one-versus-rest”分类。
• penalty：正则化的种类
• C：正则化力度

默认将类别数量少的当做正例
LogisticRegression方法相当于 SGDClassifier(loss=“log”, penalty=" "),SGDClassifier实现了一个普通的随机梯度下降学习。而使用LogisticRegression(实现了SAG)

案例：癌症分类预测

• 数据集
  
  数据描述
  （1）699条样本，共11列数据，第一列用语检索的id，后9列分别是与肿瘤
  相关的医学特征，最后一列表示肿瘤类型的数值。
  （2）包含16个缺失值，用”?”标出。

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

# 1.获取数据
names = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',
                   'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',
                   'Normal Nucleoli', 'Mitoses', 'Class']

data = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data",
                  names=names)
data.head()

# 2.基本数据处理
# 2.1 缺失值处理
data = data.replace(to_replace="?", value=np.NaN)
data = data.dropna()
# 2.2 确定特征值,目标值
x = data.iloc[:, 1:10]
x.head()
y = data["Class"]
y.head()
# 2.3 分割数据
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

# 3.特征工程(标准化)
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

# 4.机器学习(逻辑回归)
estimator = LogisticRegression()
estimator.fit(x_train, y_train)

# 5.模型评估
y_predict = estimator.predict(x_test)
y_predict
estimator.score(x_test, y_test)

分类评估方法

混淆矩阵

在分类任务下，预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合，构成混淆矩阵(适用于多分类)

精确率(Precision)与召回率(Recall)

精确率：预测结果为正例样本中真实为正例的比例

召回率：真实为正例的样本中预测结果为正例的比例（查得全，对正样本的区分能力）

F1-score

还有其他的评估标准，F1-score，反映了模型的稳健型

分类评估报告api

sklearn.metrics.classification_report(y_true, y_pred, labels=[], target_names=None )

• y_true：真实目标值
• y_pred：估计器预测目标值
• labels:指定类别对应的数字
• target_names：目标类别名称
• return：每个类别精确率与召回率

# 获取预测值
y_predict = estimator.predict(x_test)

# classification_report(y_true,y_pred,labels=以什么标记正例和假例, target_names=正假例标签名)
res = classification_report(y_true=y_test,y_pred=y_predict,labels=(2,4),target_names=('良性','恶性'))
print(res) # str类型

ROC曲线与AUC指标

TPR与FPR

• TPR = TP / (TP + FN) 正例召回率
  • 所有真实类别为1的样本中，预测类别为1的比例
• FPR = FP / (FP + TN) 1-假例召回率
  • 所有真实类别为0的样本中，预测类别为1的比例

ROC曲线

ROC曲线的横轴就是FPRate，纵轴就是TPRate，当二者相等时，表示的意义则是：对于不论真实类别是1还是0的样本，分类器预测为1的概率是相等的，此时AUC为0.5

AUC指标

• AUC的概率意义是随机取一对正负样本，正样本得分大于负样本的概率
• AUC的最小值为0.5，最大值为1，取值越高越好
• AUC=1，完美分类器，采用这个预测模型时，不管设定什么阈值都能得出完美预测。绝大多数预测的场合，不存在完美分类器。
• 0.5 最终AUC的范围在[0.5, 1]之间，并且越接近1越好

AUC计算API

from sklearn.metrics import roc_auc_score

• sklearn.metrics.roc_auc_score(y_true, y_score)
  • 计算ROC曲线面积，即AUC值
  • y_true：每个样本的真实类别，必须为0(反例),1(正例)标记
  • y_score：预测得分，可以是正类的估计概率、置信值或者分类器方法的返回值

# 0.5~1之间，越接近于1约好
y_test = np.where(y_test > 2.5, 1, 0)

print("AUC指标：", roc_auc_score(y_test, y_predict)

AUC只能用来评价二分类
AUC非常适合评价样本不平衡中的分类器性能

ROC曲线的绘制