A.深度学习基础入门篇[二]：机器学习常用评估指标:AUCmAPISFIDPerplexityBLEUROUGE等详解

Posted 2023-04-05 汀、人工智能

A.深度学习基础入门篇[二]：机器学习常用评估指标

1.基础指标简介

机器学习的评价指标有精度、精确率、召回率、P-R曲线、F1 值、TPR、FPR、ROC、AUC等指标，还有在生物领域常用的敏感性、特异性等指标。

在分类任务中，各指标的计算基础都来自于对正负样本的分类结果，用混淆矩阵表示，如 图1.1 所示：

• 准确率

$Accuracy=\frac{TP+TN}{TP+FN+FP+TN}$

即所有分类正确的样本占全部样本的比例。

• 精确率

精准率又叫做：Precision、查准率

• 召回率

召回率又叫：Recall、查全率

$Recall=\frac{TP}{TP+FN}$

即所有正例的样本中，被找出的比例.

• P-R曲线¶

P-R曲线又叫做：PRC

图2 PRC曲线图

根据预测结果将预测样本排序，最有可能为正样本的在前，最不可能的在后，依次将样本预测为正样本，分别计算当前的精确率和召回率，绘制P-R曲线。

• F1 值

$F1=\frac{2\ast P\ast R}{P+R}$

• TPR

$TPR=\frac{TP}{TP+FN}$

真正例率，与召回率相同

• FPR
  假正例率

$FPR=\frac{FP}{TN+FP}$

• ROC

根据预测结果将预测样本排序，最有可能为正样本的在前，最不可能的在后，依次将样本预测为正样本，分别计算当前的TPR和FPR，绘制ROC曲线。

• AUC

Area Under ROC Curve，ROC曲线下的面积：

• 敏感性

敏感性或者灵敏度（Sensitivity，也称为真阳性率）是指实际为阳性的样本中，判断为阳性的比例（例如真正有生病的人中，被医院判断为有生病者的比例），计算方式是真阳性除以真阳性+假阴性（实际为阳性，但判断为阴性）的比值（能将实际患病的病例正确地判断为患病的能力，即患者被判为阳性的概率）。公式如下：

$sensitivity=\frac{TP}{TP+FN}$

即有病（阳性）人群中，检测出阳性的几率。（检测出确实有病的能力）

• 特异性

特异性或特异度（Specificity，也称为真阴性率）是指实际为阴性的样本中，判断为阴性的比例（例如真正未生病的人中，被医院判断为未生病者的比例），计算方式是真阴性除以真阴性+假阳性（实际为阴性，但判断为阳性）的比值（能正确判断实际未患病的病例的能力，即试验结果为阴性的比例）。公式如下：

$specificity=\frac{TN}{TN+FP}$

即无病（阴性）人群中，检测出阴性的几率。（检测出确实没病的能力）

2. 目标检测任务重：mAP

在目标检测任务中，还有一个非常重要的概念是mAP。mAP是用来衡量目标检测算法精度的一个常用指标。目前各个经典算法都是使用mAP在开源数据集上进行精度对比。在计算mAP之前，还需要使用到两个基础概念：准确率（Precision）和召回率（Recall）

2.1准确率和召回率

• 准确率：预测为正的样本中有多少是真正的正样本。

• 召回率：样本中的正例有多少被预测正确。

具体计算方式如图2.1所示。

如图2.1准确率和召回率计算方式

其中，上图还存在以下几个概念：

• 正例：正样本，即该位置存在对应类别的物体。

• 负例：负样本，即该位置不存在对应类别的物体。

• TP（True Positives）：正样本预测为正样本的数量。

• FP（False Positives）：负样本预测为正样本的数量。

• FN（False Negative）：正样本预测为负样本的数量。

• TN（True Negative）：负样本预测为负样本的数量。

这里举个例子来说明准确率和召回率是如何进行计算的：假设我们的输入样本中有某个类别的10个目标，我们最终预测得到了8个目标。其中6个目标预测正确（TP），2个目标预测错误（FP），4个目标没有预测到（FN）。则准确率和召回率的计算结果如下所示：

• 准确率：6/（6+2） = 6/8 = 75%

• 召回率：6/（6+4） = 6/10 = 60%

2.2 PR曲线

上文中，我们学习了如何计算准确率（Precision）和召回率（Recall），得到这两个结果后，我们使用Precision、Recall为纵、横坐标，就可以得到PR曲线，这里同样使用一个例子来演示如何绘制PR曲线。

假设我们使用目标检测算法获取了如下的24个目标框，各自的置信度（即网络预测得到的类别得分）按照从上到下进行排序后如 图2 所示。我们通过设置置信度阈值可以控制最终的输出结果。可以预想到的是：

1. 如果把阈值设高，则最终输出结果中大部分都会是比较准确的，但也会导致输出结果较少，样本中的正例只有部分被找出，准确率会比较高而召回率会比较低。

2. 如果把阈值设低，则最终输出结果会比较多，但是输出的结果中包含了大量负样本，召回率会比较高而准确率率会比较低。

图2.2 准确率和召回率列表

这里，我们从上往下每次多包含一个点，就可以得到最右边的两列，分别是累加的recall和累加的precision。以recall为自变量、precision为因变量可以得到一系列的坐标点（Recall，Precision）。将这些坐标点进行连线可以得到 图2.3 。

图2.3 PR曲线

而最终mAP的计算方式其实可以分成如下两步：

• AP（Average Precision）：某一类P-R曲线下的面积。

• mAP（mean Average Precision）：所有类别的AP值取平均。

3.GAN评价指标（评价生成图片好坏）

生成器G训练好后，我们需要评价生成图片的质量好坏，主要分为主观评价和客观评价，接下来分别介绍这两类方法：

• 主观评价：人眼去观察生成的样本是否与真实样本相似。但是主观评价会存在以下问题：

  • 生成图片数量较大时，观察一小部分图片可能无法代表所有图片的质量；

  • 生成图片非常真实时，主观认为是一个好的GAN，但可能存在过拟合现象，人眼无法发现。

• 客观评价：因为主观评价存在一些问题，于是就有很多学者提出了GAN的客观评价方法，常用的方法：

  • IS（Inception Score）

  • FID（Fréchet Inception Distance）

  • 其他评价方法

3.1 IS

IS全称是Inception Score，其名字中 Inception 来源于Inception Net，因为计算这个 score 需要用到 Inception Net-V3（第三个版本的 Inception Net）。对于一个在ImageNet训练好的GAN，IS主要从以下两个方面进行评价：

• **清晰度：**把生成的图片 x 输入Inception V3模型中，将输出 1000 维(ImageNet有1000类)的向量 y ，向量每个维度的值表示图片属于某类的概率。对于一个清晰的图片，它属于某一类的概率应该非常大。

• **多样性：**如果一个模型能生成足够多样的图片，那么它生成的图片在各个类别中的分布应该是平均的，假设生成了 10000 张图片，那么最理想的情况是，1000 类中每类生成了 10 张。

IS计算公式为：

$IS(G)=exp(E_{x\sim p_g}{D}_{KL}(p(y|x)||\hat{p}(y)))$

其中，$x\sim p$：表示从生成器生成的图片；$p(y|x)$：把生成的图片 x 输入到 Inception V3，得到一个 1000 维的向量 y ，即图片x属于各个类别的概率分布；

$pˆ(y)$：N 个生成的图片（N 通常取 5000），每个生成图片都输入到 Inception V3 中，各自得到一个的概率分布向量，然后求这些向量的平均，得到生成的图片在所有类别上的边缘分布，具体公式如下：

$\hat{p}(y)=\frac{1}{N}\sum _{i=1}^{N}p\left(y|x^{(i)}\right)$

$DKL$：表示对$p(y|x)$和$pˆ(y)$ 求KL散度，KL散度公式如下：

$D_{KL}\left(P\Vert Q\right)=\sum _{i}P\left(i\right)\log \frac{P\left(i\right)}{Q\left(i\right)}$

S不能反映过拟合、且不能在一个数据集上训练分类模型，用来评估另一个数据集上训练的生成模型。

3.2 FID

FID全称是Fréchet Inception Distance，计算真实图片和生成图片的Inception特征向量之间的距离。

首先将Inception Net-V3模型的输出层替换为最后一个池化层的激活函数的输出值，把生成器生成的图片和真实图片送到模型中，得到2048个激活特征。生成图像的特征均值$\mu g$和方差$C_g$，以及真实图像的均值$\mu r$和方差$Cr$，根据均值和方差计算特征向量之间的距离，此距离值即FID：

$FID\left(P_r,P_g\right)=||{\mu }_r-{\mu }_g||+T_r\left(C_r+C_g-2{\left(C_r{C}_g\right)}^{1/2}\right)$

其中Tr 指的是被称为「迹」的线性代数运算（即方阵主对角线上的元素之和）。

FID方法比较鲁棒，且计算高效。

3.3 其他评价方法

除了上述介绍的两种GAN客观评价方法 ，更多评价方法：

Mode Score、Modifified Inception Score、AM Score、MMD、图像、Image Quality Measures、SSIM、PSNR等

4. Perplexity:困惑度

Perplexity，中文翻译为困惑度，是信息论中的一个概念，其可以用来衡量一个随机变量的不确定性，也可以用来衡量模型训练的好坏程度。通常情况下，一个随机变量的Perplexity数值越高，代表其不确定性也越高；一个模型推理时的Perplexity数值越高，代表模型表现越差，反之亦然。

4.1 随机变量概率分布的困惑度

对于离散随机变量X，假设概率分布可以表示为p(x)那么对应的困惑度为：

$2^{H(p)}=2^{}$

文章目录

• 基本算法使用（Sklearn)
• • 算子API调用分步曲
  • 数据分析分步曲
  • 分类算法
  • • KNN 算法
    • 网格优化
    • • KNN 案例 （预测facebook签到位置）
      • • 数据清洗
        • KNN处理预测
        • 完整代码
    • 朴素贝叶斯算法
    • 决策树
    • • • 案例
        • 可视化决策树
    • 随机森林
  • 回归与聚类算法
  • • 线性回归
    • • 正规方程
      • 梯度下降
    • 岭回归
    • 逻辑回归与二分类
    • • 分类的评估
    • K-means 无监督聚类算法
• 模型加载与保存
• 总结导图（大致）

基本算法使用（Sklearn)

到目前这一步涉及到了具体的算法使用，也就是调用 sklearn 的一些基本集成算法，那么关于 sklearn 的算法调用可以有一下调用规范(这些都是统一的，由于操作类似所有形成了规范)

（Ps：此时对于一些基本算法将不再进行数学推导，不太会，东西多 ，有些我很熟悉不想写，本博文为学习总结笔记结合 B站学习的浓缩精简笔记）

算子API调用分步曲

estimator 预估器

estimator = 某个算子 API（）

estimator.fit(x_train,y_train) 进行运算，训练对应的模型

estimator.predict(x_test) 进行预测（调用模型）

estimator.score(x_test,y_test) 进行模型预估评价

数据分析分步曲

1.加载数据

2.数据标准化，归一化

3.数据特征提取，降维 etc

4.数据切割划分，划分训练集，测试集

5.使用对于算子API

6.使用estimator 进行训练

7.对数据进行预测评估

8.根据测试结果进行优化

9.保存优化后的算法模型

那么接下来就是关于数据处理的一些算子。

分类算法

KNN 算法

描述：

​ 如果一个样本在特征空间中的k个最相似（k值）的大对数属于某一个类别，则该样本也属于这个类别。

​ 用于做分类预测！例如对地图地点分类，预测用户最喜欢聚集的地方（然后投放广告，参考 facebook 案例 ：预测facebook签到位置）

原理：

​ 对于一个样本，计算对应某个相似值与其他点的距离（例如通过欧式距离等）从而找到近似的点进行划分。

优点：

• 易于实现，无需训练

缺点：

• 懒惰算法，对测试样本分类时的计算量大，内存开销大
• 必须指定K值，K值选择不当则分类精度不能保证（此时需要通过一定的自我修正，在这里是sklearn 的网格修正）

对应 API：

from sklearn.neighbors import KNeighborsClassifier

代码示例：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

#用KNN对鸢尾花进行分类
def knn_iris():
    """用KNN算法对鸢尾花进行分类"""
    #1.获取数据
    iris=load_iris()
    #2.划分数据集
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,random_state=6)
    #3.特征工程：标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    #4.KNN算法预估器
    estimator=KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train,y_train)
    #5.模型评估
        #5.1 方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\\n",y_predict)
    print("直接比对真实值和预测值：\\n",y_test==y_predict)
        #5.2 方法2：计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率为：\\n",score)

out:

y_predict:
[0 2 0 0 2 1 1 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
2]
直接比对真实值和预测值：
[ True True True True True True False True True True True True
True True True False True True True True True True True True
True True True True True True True True True True False True
True True]
准确率为：
0.9210526315789

网格优化

from sklearn.model_selection import GridSearchCV

这个作用呢其实很简单，就是前面说的自动参数设置，也就是前面 estimator=KNeighborsClassifier(n_neighbors=3)

这个 n_neighbors 的数值其实那啥也是要不断的去试试的，那么这里sklearn 提供了一个方法来帮助我们去试一试这个参数的设置

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV

def knn_iris_gsv():
    """用KNN算法对鸢尾花进行分类,添加网格搜索和交叉验证"""
    #1.获取数据
    iris=load_iris()
    #2.划分数据集
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,random_state=6)
    #3.特征工程：标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    #4.KNN算法预估器
    estimator=KNeighborsClassifier()

    '''加入网格搜索与交叉验证'''
    #参数准备
    param_dict={"n_neighbors":[1,3,5,7,9,11],}#估计器参数
    estimator=GridSearchCV(estimator,param_grid=param_dict,cv=10)#estimator：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率

    estimator.fit(x_train,y_train)
    #5.模型评估
        #5.1 方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\\n",y_predict)
    print("直接比对真实值和预测值：\\n",y_test==y_predict)
        #5.2 方法2：计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率为：\\n",score)

    '''查看网格搜索与交叉验证结果'''
    # 最佳参数：best_params_
    print("最佳参数：\\n", estimator.best_params_)
    # 最佳结果：best_score_
    print("最佳结果：\\n", estimator.best_score_)
    # 最佳估计器：best_estimator_
    print("最佳估计器:\\n", estimator.best_estimator_)
    # 交叉验证结果：cv_results_
    print("交叉验证结果:\\n", estimator.cv_results_)

重点在这：

param_dict={"n_neighbors":[1,3,5,7,9,11],}#估计器参数
    estimator=GridSearchCV(estimator,param_grid=param_dict,cv=10)#estimator：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率

KNN 案例 （预测facebook签到位置）

此案例为facebook 的定位 案例。

这个案例比较复杂的其实是数据清洗 也就是pandas 的数据清洗。这里详细说一下毕竟我觉得难点就是数据处理这一块。

数据集：

链接：https://pan.baidu.com/s/1nojpx6ovymtLJEr9CoBadw
提取码：6666

数据清洗

首先数据长这个样子：

   row_id       x       y  accuracy    time    place_id
0       0  0.7941  9.0809        54  470702  8523065625
1       1  5.9567  4.7968        13  186555  1757726713
2       2  8.3078  7.0407        74  322648  1137537235
3       3  7.3665  2.5165        65  704587  6567393236
4       4  4.0961  1.1307        31  472130  7440663949
(29118021, 6)

#1.获取数据 data = pd.read_csv("…/input/train.csv")

然后我们需要对数据进行基本处理，也就是说首先 要 把 time 进行格式转换，然后我们需要提取出训练集X 和 预测集Y

也就是提取之后长这个样子

Y 长这个样子

place_id
1014605271    28
1015645743     4
1017236154    31
1024951487     5
1028119817     4
Name: row_id, dtype: int64

那么具体代码是这样的：

	# 1)缩小数据范围
data=data.query(" x<2.5 & x>2 & y<1.5 & y>1.0")
	# 2)处理时间特征
time_value=pd.to_datetime(data["time"],unit="s")
data["day"]=date.day
data["weekdaty"]=date.weekday
data["hour"]=date.hour
	# 3)过滤掉次数少的地点
place_count=data.groupby("place_id").count()["row_id"]
data_final = data[data["place_id"].isin(place_count[place_count>3].index.values)]
	# 4)筛选特征值和目标值
x=data_final[["x","y","accuracy","day","weekdaty","hour"]]
y=data_final["place_id"]

KNN处理预测

这一步就是套口诀了：

	# 5)数据集划分
x_train,x_test,y_train,y_test=train_test_split(x,y)

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

#4.KNN算法预估器
estimator=KNeighborsClassifier()
'''加入网格搜索与交叉验证'''
#参数准备
param_dict={"n_neighbors":[3,5,7,9]}#估计器参数
estimator=GridSearchCV(estimator,param_grid=param_dict,cv=3)#estimator：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率
estimator.fit(x_train,y_train)

#5.模型评估
    #5.1 方法1：直接比对真实值和预测值
y_predict=estimator.predict(x_test)
print("y_predict:\\n",y_predict)
print("直接比对真实值和预测值：\\n",y_test==y_predict)
    #5.2 方法2：计算准确率
score=estimator.score(x_test,y_test)
print("准确率为：\\n",score)
'''查看网格搜索与交叉验证结果'''
# 最佳参数：best_params_
print("最佳参数：\\n", estimator.best_params_)
# 最佳结果：best_score_
print("最佳结果：\\n", estimator.best_score_)
# 最佳估计器：best_estimator_
print("最佳估计器:\\n", estimator.best_estimator_)
# 交叉验证结果：cv_results_
print("交叉验证结果:\\n", estimator.cv_results_)

完整代码

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 1.获取数据
data=pd.read_csv("./FBlocation/train.csv")

# 2.基本数据处理
	# 1)缩小数据范围
data=data.query(" x<2.5 & x>2 & y<1.5 & y>1.0")
	# 2)处理时间特征
time_value=pd.to_datetime(data["time"],unit="s")
data["day"]=date.day
data["weekdaty"]=date.weekday
data["hour"]=date.hour
	# 3)过滤掉次数少的地点
place_count=data.groupby("place_id").count()["row_id"]
data_final = data[data["place_id"].isin(place_count[place_count>3].index.values)]
	# 4)筛选特征值和目标值
x=data_final[["x","y","accuracy","day","weekdaty","hour"]]
y=data_final["place_id"]
	# 5)数据集划分
x_train,x_test,y_train,y_test=train_test_split(x,y)

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

#4.KNN算法预估器
estimator=KNeighborsClassifier()
'''加入网格搜索与交叉验证'''
#参数准备
param_dict={"n_neighbors":[3,5,7,9]}#估计器参数
estimator=GridSearchCV(estimator,param_grid=param_dict,cv=3)#estimator：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率
estimator.fit(x_train,y_train)

#5.模型评估
    #5.1 方法1：直接比对真实值和预测值
y_predict=estimator.predict(x_test)
print("y_predict:\\n",y_predict)
print("直接比对真实值和预测值：\\n",y_test==y_predict)
    #5.2 方法2：计算准确率
score=estimator.score(x_test,y_test)
print("准确率为：\\n",score)
'''查看网格搜索与交叉验证结果'''
# 最佳参数：best_params_
print("最佳参数：\\n", estimator.best_params_)
# 最佳结果：best_score_
print("最佳结果：\\n", estimator.best_score_)
# 最佳估计器：best_estimator_
print("最佳估计器:\\n", estimator.best_estimator_)
# 交叉验证结果：cv_results_
print("交叉验证结果:\\n", estimator.cv_results_)

朴素贝叶斯算法

这个其实是类似于用概率预测的方式进行运算预测分类，其实就是问某一个玩意属于某一个类别（或者范围）的概率

朴素：这个是指假设忽略数据集的影响（数据集可能不完整）也就是假设在数据集里面的每一个元素都是独立的！

1. 联合概率
   包含多个条件，且所有条件同时成立的概率
2. 条件概率
   就是时间A在另外一个时间B已经发生的条件下发生的概率
3. 相互独立
   如果P(A,B)=P(A)P(B)，则称事件A与事件B相互独立
4. 贝叶斯公式
   P(C|W)=( P(W|C)PC ) / P(W)
5. 朴素
   特征与特征之间相互独立
6. 朴素贝叶斯算法
   朴素 + 贝叶斯
7. 应用分类
   文本分类（单词作为特征）
8. 拉普拉斯平滑系数
   P(F1|C) = (分子+α) / (分母+αm)
   α:指定的系数
   m:训练文档出现的特征总个数

调用 API：

from sklearn.naive_bayes import MultinomialNB

这个咱们直接上例子：

from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    #1.获取数据
    news = fetch_20newsgroups(subset="all")#subset="all"获取所有数据，train获取训练数据
    #2.划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    #3.特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    #4.朴素贝叶斯算法预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)
    #5.模型评估
        # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\\n", y_predict)
    print("直接比对真实值和预测值:\\n", y_test == y_predict)
        # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\\n", score)

y_predict:
 [15  2 16 ... 11 10 18]
直接比对真实值和预测值:
 [False  True False ...  True  True  True]
准确率为：
 0.8503820033955858

(PS :这些玩意都是可以用网格优化的！)

决策树

这玩意懂的都懂！

参考 up:https://www.bilibili.com/video/BV1Xp4y1U7vW

[信息论基础]

1. 信息
   香农：消除随机不确定的东西
2. 信息的衡量 - 信息量 - 信息熵
   2.1 单位：bit
   2.2 信息增益
   g(D|A) = H(D)-H(D|A)
   2.3 决策树的划分依据之一 ------- 信息增益(越大越好)

优点：

• 可视化 - 可解释能力强

缺点：

• 决策树不能很好的用于过于复杂的树（过拟合）

改进：

• 减枝cart算法
• 随机森林

调用 ＡＰＩ

from sklearn.tree import DecisionTreeClassifier

案例

决策树对鸢尾花数据分类

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz

def decision_iris():
    """用决策树对决策树对鸢尾花进行分类"""
    #1.获取数据集
    iris = load_iris()
    #2.划分数据集
    x_train,x_test,y_train,y_test = train_test_split(iris.data,iris.target,random_state=22)
    #3.决策树预估器
    estimator = DecisionTreeClassifier(criterion="entropy")
    estimator.fit(x_train,y_train)
    #4.模型评估
        # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\\n", y_predict)
    print("直接比对真实值和预测值:\\n", y_test == y_predict)
        # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\\n", score)
    #可视化决策树
    export_graphviz(estimator,out_file="iris_tree.dot",feature_names=iris.feature_names)

可视化决策树

export_graphviz(estimator,out_file=“iris_tree.dot”,feature_names=iris.feature_names)

这个会生成一个文件然后你放到网站去解析就好了。

随机森林

参考 up:https://www.bilibili.com/video/BV1H5411e73F?spm_id_from=333.999.0.0

一句话总结： 让多个森林去跑，然后统一一下。

[集成学习方法]
集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。
[随机森林]
随机：训练集随机，特征随机
森林：包含多个决策树的分类器

API

from sklearn.ensemble import RandomForestClassifier

数据集：

链接：https://pan.baidu.com/s/1cocizyxtizZMCGoyZvgQOg
提取码：6666

随机森林对泰坦尼克号乘客的生存进行预测

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
#获取数据
path="./titanic.csv"
titanic=pd.read_csv(path)
#筛选特征值和目标值
x=titanic[["pclass","age","sex"]]
y=titanic["survived"]
#2.数据处理
	#2.1缺失值处理
x["age"].fillna(x["age"].mean(),inplace=True)
	#2.2转换成字典
x=x.to_dict(orient="records")
#3.数据集划分 
x_train,x_test,y_train,y_test=train_test_split(x,y,random_state=22)
#4.字典特征抽取
transfer=DictVectorizer()
x_train=transfer.fit_transform(x_train)
x_test=transfer.transform(x_test)
estimator=RandomForestClassifier()
#加入网格搜索与交叉验证
#参数准备
param_dict={"n_estimators":[120,200,300,500,800,1200],"max_depth":[5,8,15,25,30]}#估计器参数
estimator=GridSearchCV(estimator,param_grid=param_dict,cv=3)#estimator：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率
estimator.fit(x_train,y_train)
#5.模型评估
    #5.1 方法1：直接比对真实值和预测值
y_predict=estimator.predict(x_test)
print("y_predict:\\n",y_predict)
print("直接比对真实值和预测值：\\n",y_test==y_predict)
    #5.2 方法2：计算准确率
score=estimator.score(x_test,y_test)
print("准确率为：\\n",score)
'''查看网格搜索与交叉验证结果'''
# 最佳参数：best_params_
print("最佳参数：\\n", estimator.best_params_)
# 最佳结果：best_score_
print("最佳结果：\\n", estimator.best_score_)
# 最佳估计器：best_estimator_
print("最佳估计器:\\n", estimator.best_estimator_)
# 交叉验证结果：cv_results_
print("交叉验证结果:\\n", estimator.cv_results_)

回归与聚类算法

线性回归

参考up : https://www.bilibili.com/video/BV17T4y1J7SB?spm_id_from=333.999.0.0

这个老朋友了，来看老师给的定义：

[线性回归]

1. 回归问题
   目标值 - 连续型的数据
2. 定义
   函数关系(线性模型)：特征值和目标值建立关系
   y = w1x1 + w2x2 + w3x3 + … + wnxn + b = wTx + b
3. 广义线性模型
   a. 自变量一次(线性关系)
   y = w1x1 + w2x2 + w3x3 + … + wnxn + b = wTx + b
   b. 参数一次(非线性关系)
   y = w1x1 + w2x1^2 + w3x1^3 + w4x2^3 + … + b
4. 线性回归的损失和优化原理
   目标：求模型参数
   损失函数/cost/成本函数/目标函数 – 最小 – 最小二乘法
   优化损失（优化方法）
   a. 正规方程（天才）
   直接求解w
   b. 梯度下降（勤奋努力的普通人）
   试错、改进
   分类
   GD梯度下降：计算所有的样本的值才能得出梯度
   SGD随机梯度下降：在一次迭代只考虑一个样本
   SAG随机平均梯度法
5. 回归性能评估
   均方误差（MSE）评价机制

正规方程

API

from sklearn.linear_model import LinearRegression

特点：运算快，适合小样本数据

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,SGDRegressor
以上是关于A.深度学习基础入门篇[二]：机器学习常用评估指标:AUCmAPISFIDPerplexityBLEUROUGE等详解的主要内容，如果未能解决你的问题，请参考以下文章
 
 Sklearn机器学习基础（day02基础入门篇）
 （机器学习深度学习常用库框架|Pytorch篇）第三节：Pytorch之torchvision详解
 （机器学习深度学习常用库框架|Pytorch篇）第三节：Pytorch之torchvision详解
 深度学习实验二
 （机器学习深度学习常用库框架|Pytorch篇）第一节：Pytorch简介和其核心概念
 机器学习入门(4~9)