黑马程序员——三天快速入门python机器学习（四）

傅里叶不变坏

已于 2022-06-23 16:30:09 修改

阅读量516

点赞数 4

文章标签：分类机器学习 sklearn

于 2022-06-22 19:35:32 首次发布

本文链接：https://blog.csdn.net/m0_63273208/article/details/125368634

版权

sklearn转换器和预估器

转换器

特征工程的步骤

1）实例化一个转换器类（transformer）
2）调用fit_transform()

我们把特征工程的接口称之为转换器，其中转换器调用这几种形式：

fit_transform
fit
transform

3.1.2 估计器（sklearn机器学习算法的实现）
在sklearn中，估计器是一个重要的角色，是一类实现了算法的API

估计器（sklearn机器学习算法的实现）

在sklearn中，估计器（estimator）是一个重要角色，是一类实现了算法的API

用于分类的估计器：

sklearn.neighbors k近邻算法
sklearn.native_bayes 贝叶斯
sklearn.linear_model.LogisticRegression 逻辑回归
sklearn.tree 决策树与随机森林

用于回归的估计器

sklearn.linear_model.LinearRegression 线性回
sklearn.linear_model.Ridge 岭回归

用于无监督学习的估计器

sklearn.cluster.KMeans 聚类

估计器

1）实例化一个estimator

2）estimator.fi(x_train,y_train) 计算，调用完毕，模型生成

3）模型评估

直接对比真实值和预测值：
y_predict=estimator.predict(x_test)
y_test==y_predict
计算准确率：
accuracy=estimator.score（x_test,y_test）

在这里插入图片描述
（估计器的工作流程）

K—近邻算法（KNN）

K—近邻算法原理

定义：如果一个样本在特征空间总的K个最相近的特征空间中最邻近的样本中的大多数属于某一个类别，则该样本也属于这个类别

距离公式:
两个样本的距离：欧式距离
在这里插入图片描述

举例：电影分类

在这里插入图片描述
求未知电影？的类型：计算该未知电影与其余六个电影的距离：
结果分析：
K=1时，？离第二个电影近，属于爱情片
K=2时，？离第二、三部电影近，属于爱情片
K=6时，无法确定

结论：K值过大，容易受到样本不均衡的影响；K值过小，容易受到异常值影响

K—近邻算法API

sklearn.neighbor.KNeighborsClassifier(n_neighbors=5, algorithm=‘auto’)

n_neighbors：int型，可选（默认为5），k_neighbors查询默认使用的邻居数
algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}可选

案例1：鸢尾花种类预测

数据集介绍
流程分析
1）获取数据
2）数据集划分
3）特征工程：标准化
4）KNN预估器流程
5）模型评估
程序实现

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算法对鸢尾花进行分类
    :return:
    """
    # 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、模型评估
    # 方法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)

    return None


if __name__ == "__main__":
    knn_iris()


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.9210526315789473

K-近邻总结

优点：简单，易于实现，无需训练
缺点：懒惰算法，对测试样本分类时的计算量大，内存开销大；必须指定K值，K值选择不当则分类精度不能保证
使用场景：小数据场景，几千到几万样本

模型选择与调优

交叉验证（cross validation）

定义：将拿到的训练集数据，再分为训练和验证集。
理解：以下图为例，将训练集数据分成4份，其中一份作为验证集。然后经过4次的测试，每次都更换不同的验证集。即得到4组模型的结果，取平均值作为最终结果，又称4折交叉验证。

在这里插入图片描述
3. 目的：为了让被评估的模型更加准确可信

超参数搜索—网格搜索（Grid Search）

通常情况下，很多参数是需要手动指定的（如K-近邻算法中的K值），这种叫超参数。但是手动过程繁杂，所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型

模型选择与调优API
sklearn.model_selection.GridSearchCV(estimator, param_grid=None, cv=None)

对估计器的指定参数进行详尽搜索
estimator：估计器对象
param_grid：估计器参数（dict）{“n_neighbors”:[1,3,5]}
cv：指定几折交叉验证
fit()：输入训练数据
score()：准确率
结果分析：
最佳参数：best_params_
最佳结果：best_score_
最佳估计器：best_estimator_
交叉验证结果：cv_results_

鸢尾花案例增加K值调优

from sklearn.datasets import load_iris                  # 获取数据集
from sklearn.model_selection i mport train_test_split    # 划分数据集
from sklearn.preprocessing import StandardScaler        # 标准化
from sklearn.neighbors import KNeighborsClassifier      # KNN算法分类
from sklearn.model_selection import GridSearchCV
# 网格搜索和交叉验证

def knn_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类
    添加网格搜索和交叉验证
    :return:
    """
    # 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)  # 数据量不大，选10折

    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("准确率：", score)

    # 查看最佳参数：best_params_
    print("最佳参数：", estimator.best_params_)
    # 最佳结果：best_score_
    print("最佳结果：", estimator.best_score_)
    # 最佳估计器：best_estimator_
    print("最佳估计器：", estimator.best_estimator_)
    # 交叉验证结果：cv_results_
    print("交叉验证结果:", estimator.cv_results_)

    return None


if __name__ == "__main__":
    knn_iris_gscv()

运行结果


y_predict:
 [0 2 0 0 2 1 2 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  True  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.9473684210526315
最佳参数： {'n_neighbors': 11}
最佳结果： 0.9734848484848484
最佳估计器： KNeighborsClassifier(n_neighbors=11)
交叉验证结果: {'mean_fit_time': array([8.00156593e-04, 9.97543335e-05, 3.00335884e-04, 2.99954414e-04,
       4.98914719e-04, 2.00080872e-04]), 'std_fit_time': array([0.00040009, 0.00029926, 0.00045877, 0.00045819, 0.00049892,
       0.00040016]), 'mean_score_time': array([0.00130005, 0.00090084, 0.00079987, 0.00060012, 0.00060124,
       0.00070016]), 'std_score_time': array([0.00045538, 0.00030029, 0.00039997, 0.00049   , 0.00049092,
       0.00045837]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
             mask=[False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([1., 1., 1., 1., 1., 1.]), 'split1_test_score': array([0.91666667, 0.91666667, 1.        , 0.91666667, 0.91666667,
       0.91666667]), 'split2_test_score': array([1., 1., 1., 1., 1., 1.]), 'split3_test_score': array([1.        , 1.        , 1.        , 1.        , 0.90909091,
       1.        ]), 'split4_test_score': array([1., 1., 1., 1., 1., 1.]), 'split5_test_score': array([0.90909091, 0.90909091, 1.        , 1.        , 1.        ,
       1.        ]), 'split6_test_score': array([1., 1., 1., 1., 1., 1.]), 'split7_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 1.        ,
       1.        ]), 'split8_test_score': array([1., 1., 1., 1., 1., 1.]), 'split9_test_score': array([0.90909091, 0.81818182, 0.81818182, 0.81818182, 0.81818182,
       0.81818182]), 'mean_test_score': array([0.96439394, 0.95530303, 0.97272727, 0.96439394, 0.96439394,
       0.97348485]), 'std_test_score': array([0.04365767, 0.0604591 , 0.05821022, 0.05965639, 0.05965639,
       0.05742104]), 'rank_test_score': array([5, 6, 2, 3, 3, 1])}

案例：预测facebook签到位置

数据集介绍

在这里插入图片描述

流程分析：

获取数据
数据处理
1）缩小数据范围
特征值 x：2<x<2.5
目标值y：1.0<y<1.5
2）time -> 年与日时分秒
3）过滤签到次数少的地点
特征工程：标准化
KNN算法预估流程
模型选择与调优
模型评估


import pandas as pd
# 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") #Name: time, Length
date = pd.DatetimeIndex(time_value)
data["day"] = date.day  #年月对位置预测可能作用不大
data["weekday"] = date.weekday
data["hour"] = date.hour
data.head() #83197 rows × 9 columns
# 3)过滤签到次数少的地点
place_count = data.groupby("place_id").count()["row_id"] # 分组 计数
place_count[place_count > 3].head()  # 过滤掉次数少于3的地点
data_final = data[data["place_id"].isin(place_count[place_count>3].index.values)]
data_final.head() 

# 筛选特征值和目标值
x = data_final[["x", "y", "accuracy", "day", "weekday", "hour"]]
y = data_final["place_id"]

# 数据集划分
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y)

from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV

# 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=5)  # 10折，数据量不大，可以多折

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("准确率：", score)

# 查看最佳参数：best_params_
print("最佳参数：", estimator.best_params_)
# 最佳结果：best_score_
print("最佳结果：", estimator.best_score_)
# 最佳估计器：best_estimator_
print("最佳估计器：", estimator.best_estimator_)
# 交叉验证结果：cv_results_
print("交叉验证结果:", estimator.cv_results_)

朴素贝叶斯算法

概率基础知识

联合概率：包含多个条件，且所有条件同时成立。记作：P（A , B ）
条件概率：在事件B发生的条件下事件A发生的概率。记作：P（A | B）
相互独立：事件A是否发生对事件B没有影响。
即：如果P（A，B）=P（A）P（B），则事件A和事件B相互独立。

朴素贝叶斯算法介绍

朴素：假设特征与特征之间相互独立
贝叶斯公式：
朴素贝叶斯算法：朴素＋贝叶斯
应用场景：文本分类（单词作为特征）

拉普拉斯平滑系数

避免计算出的概率为0的情况。

在这里插入图片描述

API

sklearn.naive_bayes.MultinomialNB(alpha=1.0)

朴素贝叶斯分类
alpha：拉普拉斯平滑系数

案例:20类新闻分类

数据集介绍
步骤分析

1）获取数据
2）划分数据集
3）特征工程：文本特征抽取
4）朴素贝叶斯预估器流程
5）模型评估

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')

    # 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）模型评估
    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("准确率：", score)

    return None


if __name__ == "__main__":
    nb_news()

运行结果：

y_predict:
 [ 2  8 10 ... 11 11  7]
直接比对真实值和预测值：
 [ True  True  True ...  True False  True]
准确率： 0.8471986417657046

朴素贝叶斯算法总结

优点：

朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率
对缺失数据不太敏感，算法也比较简单，常用于文本分类
分类准确度高，速度快

缺点：

由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好

决策树

决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-else结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法

在这里插入图片描述
合理安排特征的先后顺序，能提高决策的效率。

信息论基础

信息：消除随机不定性的东西。
信息的衡量

1）信息熵：
在这里插入图片描述

2）信息增益：

在这里插入图片描述

3. 决策树划分依据之一：信息增益

ID3：信息增益最大准则
C4.5：信息增益比最大准则
CART：
分类树：基尼系数最小准则，在sklearn中可以选择划分的默认原则。
优势：划分更加细致。

决策树API

sklearn.tree.DecisionTreeClassifier(criterion=‘gini’, max_depth=None, random_state=None)

决策树分类器
criterion：默认是“gini”系数，也可以选择信息增益的熵‘entropy’
max_depth：树的深度大小
random_state：随机数种子

鸢尾花案例


from sklearn.datasets import load_iris                  # 获取数据集
from sklearn.model_selection import train_test_split    # 划分数据集
from sklearn.naive_bayes import MultinomialNB              # 朴素贝叶斯
from sklearn.tree import DecisionTreeClassifier
# 决策树


def decision_iris():
    """
    决策树对鸢尾花进行分类
    :return:
    """
    # 1）获取数据集 （sklearn里的数据，已经处理好，可以不用数据处理这一步）
    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）模型评估
    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("准确率：", score)

 # 可视化决策树
    export_graphviz(estimator, out_file='iris_tree.dot', feature_names=iris.feature_names)

    return None


if __name__ == "__main__":
    decision_iris()

运行结果

y_predict:
 [0 2 1 2 1 1 1 1 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 2 2 2 1 0 0 1 1 1 0 0
 0]
直接必读真实值和预测值：
 [ True  True  True  True  True  True  True False  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True  True  True  True False  True  True  True  True  True  True
  True  True]
准确率： 0.9210526315789473

决策树的可视化

sklearn.tree.export_graphviz()  # 该函数能够导入dot文件
tree.export.graphviz(estimator, out_file='tree.dot', feature_names=[","])

鸢尾花分类决策树可视化

from sklearn.datasets import load_iris                 
from sklearn.model_selection import train_test_split   
from sklearn.tree import DecisionTreeClassifier, export_graphviz, plot_tree
import matplotlib.pyplot as plt


def decision_iris():
    """
    决策树对鸢尾花进行分类
    :return:
    """
    # 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）模型评估
    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("准确率：", score)

    # 可视化决策树
    export_graphviz(estimator, out_file='iris_tree.dot', feature_names=iris.feature_names)
    plot_tree(decision_tree=estimator)
    plt.show()

    return None


if __name__ == "__main__":
    decision_iris()

将得到的dot文件复制到以下网站中：
网站: http://webgraphviz.com/
点击Generate Graph生成决策树图
在这里插入图片描述

决策树总结

优点：简单的理解和解释，树木可视化
缺点：决策树学习者可以创建不能很好地推广数据的过于复杂的树，这被称为过拟合
改进：1）剪枝cart算法（决策树API当中已经实现，随机森林参数调优有相关介绍）；2）随机森林。

import pandas as pd

# 1、获取数据
path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
titanic = pd.read_csv(path) 

# 筛选特征值和目标值
x = titanic[["pclass", "age", "sex"]]
y = titanic["survived"]

# 2、数据处理
# 1）缺失值处理
x["age"].fillna(x["age"].mean(), inplace=True)

# 2)转换成字典
x = x.to_dict(orient="records")

from sklearn.model_selection import train_test_split
# 3、数据集划分
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

# 4、字典特征抽取
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import DecisionTreeClassifier, export_graphviz
transfer = DictVectorizer()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)



# 3）决策树预估器
estimator = DecisionTreeClassifier(criterion='entropy')
estimator.fit(x_train, y_train)

# 4）模型评估
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("准确率：", score)

# 可视化决策树
export_graphviz(estimator, out_file='titanic_tree.dot', feature_names=transfer.get_feature_names())

import matplotlib.pyplot as plt
from sklearn.tree import plot_tree
plot_tree(decision_tree=estimator)
plt.show()

随机森林

集成学习方法

集成学习方法通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各种独立地学习和做出预测。这些预测最后结合成组合预测，因此优于任何一个单分类做出的预测

随机森林理解

森林：

在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别数输出的类别的众数而定。
例如：训练了5棵树，4棵树的结果是True ，1棵是False，那么最终结果为True

随机

用N来表示训练样本个数，M表示特征数

训练集随机：BoostStrap，N个样本中随机有放回抽样
特征值随机：从M个特征中随机抽取m个特征，M>>m

BootStrap抽样：随机有放回

为什么要随机抽样训练集？
如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的
为什么要有放回地抽样？
如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”，也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树的投票表决

API

sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion='gini', max_depth=None, bootstrap=True, random_state=None, min_samples_split=2)

随机森林分类器
n_estimators：integer，optional(default=10)森林里的树木数量，120，200，300，500，800，1200，可以用网格搜索。
criteria：string，可选（default=‘gini’）分割特征的测量方法
max_depth：integer或None，可选（默认=无），树的最大深度5，8，15，25，30 也可以用网格搜索
max_teatures=‘auto’，每个决策树的最大特征数量
if ‘auto’ ，then max_features = sqrt(n_features)
if ‘sqrt’ ，then max_features = sqrt(n_features)
if ‘log2’ ，then max_features = log2(n_features)
if None，then max_features = n_features
booststrap：boolean，optional（default=True）是否在构建树时使用放回抽样
min_samples_split：节点划分最少样本数
min_samples_leaf：叶子节点的最小样本数

超参数：n_estimator，max_depth，min_samples_split，min_samples_leaf

泰坦尼克号乘客的生存预测

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
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.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("准确率：", score)

# 查看最佳参数：best_params_
print("最佳参数：", estimator.best_params_)
# 最佳结果：best_score_
print("最佳结果：", estimator.best_score_)
# 最佳估计器：best_estimator_
print("最佳估计器：", estimator.best_estimator_)
# 交叉验证结果：cv_results_
print("交叉验证结果:", estimator.cv_results_)