2.机器学习-算法1

最新推荐文章于 2024-04-25 18:29:56 发布
最新推荐文章于 2024-04-25 18:29:56 发布
阅读量398 收藏
点赞数
分类专栏： 机器学习 文章标签： 机器学习 算法 sklearn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43732424/article/details/121156178
版权

文章目录


image-20211104211054521

1.转换器与预估器

1.转换器

想一下之前做的特征工程的步骤？

  • 1、实例化 (实例化的是一个转换器类(Transformer))
  • 2、调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

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

  • fit_transform
  • fit
  • transform

这几个方法之间的区别是什么呢？我们看以下代码就清楚了

In [1]: from sklearn.preprocessing import StandardScaler

In [2]: std1 = StandardScaler()

In [3]: a = [[1,2,3], [4,5,6]]

In [4]: std1.fit_transform(a)
Out[4]:
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])

In [5]: std2 = StandardScaler()

In [6]: std2.fit(a)
Out[6]: StandardScaler(copy=True, with_mean=True, with_std=True)

In [7]: std2.transform(a)
Out[7]:
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])

从中可以看出，fit_transform的作用相当于transform加上fit。但是为什么还要提供单独的fit呢, 我们还是使用原来的std2来进行标准化看看

In [8]: b = [[7,8,9], [10, 11, 12]]

In [9]: std2.transform(b)
Out[9]:
array([[3., 3., 3.],
       [5., 5., 5.]])

In [10]: std2.fit_transform(b)
Out[10]:
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])

2 估计器(sklearn机器学习算法的实现)

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

  • 1、用于分类的估计器：
    • sklearn.neighbors k-近邻算法
    • sklearn.naive_bayes 贝叶斯
    • sklearn.linear_model.LogisticRegression 逻辑回归
    • sklearn.tree 决策树与随机森林
  • 2、用于回归的估计器：
    • sklearn.linear_model.LinearRegression 线性回归
    • sklearn.linear_model.Ridge 岭回归
  • 3、用于无监督学习的估计器
    • sklearn.cluster.KMeans 聚类

3 估计器工作流程

估计器工作流程

2.K-近邻算法

1 什么是K-近邻算法

image-20211104123526085
  • 根据你的“邻居”来推断出你的类别

1.1 K-近邻算法(KNN)概念

K Nearest Neighbor算法又叫KNN算法，这个算法是机器学习里面一个比较经典的算法， 总体来说KNN算法是相对比较容易理解的算法

  • 定义

如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

来源：KNN算法最早是由Cover和Hart提出的一种分类算法

  • 距离公式

两个样本的距离可以通过如下公式计算，又叫欧式距离 ，关于距离公式会在后面进行讨论

img img

1.2 电影类型分析

假设我们现在有几部电影

image-20190316204421392

其中？ 号电影不知道类别，如何去预测？我们可以利用K近邻算法的思想

image-20190316204448303

分别计算每个电影和被预测电影的距离，然后求解

image-20190316204517137

1.3 KNN算法流程总结

1）计算已知类别数据集中的点与当前点之间的距离

2）按距离递增次序排序

3）选取与当前点距离最小的k个点

4）统计前k个点所在的类别出现的频率

5）返回前k个点出现频率最高的类别作为当前点的预测分类

K-近邻算法API

  • sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
    • n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数
    • algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

2.模型选择与调优

交叉验证目的：为了让被评估的模型更加准确可信

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

分析： 我们之前知道数据分为训练集和测试集，但是**为了让从训练得到模型结果更加准确。**做以下处理

  • 训练集：训练集+验证集
  • 测试集：测试集
交叉验证过程

问题：那么这个只是对于参数得出更好的结果，那么怎么选择或者调优参数呢？

超参数搜索-网格搜索(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：准确率
    • 结果分析：
      • bestscore:在交叉验证中验证的最好结果_
      • bestestimator：最好的参数模型
      • cvresults:每次交叉验证后的验证集准确率结果和训练集准确率结果

3 用KNN算法对鸢尾花进行分类

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
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=22, test_size=0.2)
    # 3.特征工程标准化  此数据不用做降维处理
    transfer = StandardScaler()
    # fit() 计算 每一列的平均值、标准差
    # transform() (x-mean)/std进行最终的转换
    x_train = transfer.fit_transform(x_train)
    # 对测试集进行标准化，训练集调用fit_transfor(),测试集调用transform用训练集的平均值、标准差带入公示进行最终的转换
    x_test = transfer.transform(x_test)
    # 4.KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=2)
    estimator.fit(x_train, y_train)
    # 5.模型评估
    # 方法1：直接对比真实值和与测试
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("y_test:\n", y_test)
    print("直接对比真实值和预测值:\n", y_predict == y_test)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)
    return None

image-20211104212207661

4 用KNN算法分类，添加网格搜索和交叉验证

def knn_iris_gscn():
    '''
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    :return:
    '''
    # 1.获取数据
    iris = load_iris()
    # 2.划分数据集
    # 返回 训练集特征值 测试集特征值  训练集目标值 测试集目标值
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22, test_size=0.2)
    # 3.特征工程标准化  此数据不用做降维处理
    transfer = StandardScaler()
    # fit() 计算 每一列的平均值、标准差
    # transform() (x-mean)/std进行最终的转换
    x_train = transfer.fit_transform(x_train)
    # 对测试集进行标准化，训练集调用fit_transfor(),测试集调用transform用训练集的平均值、标准差带入公示进行最终的转换
    x_test = transfer.transform(x_test)
    # 4.KNN算法预估器 p=1曼哈顿距离 p=2欧氏距离 默认欧氏距离
    estimator = KNeighborsClassifier()

    # 加入网格搜索和交叉验证
    # 参数准备
    params_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    # estimator:估计器对象 param_grid：估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
    estimator = GridSearchCV(estimator, param_grid=params_dict, cv=10)
    estimator.fit(x_train, y_train)
    # 5.模型评估
    # 方法1：直接对比真实值和与测试
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("y_test:\n", y_test)
    print("直接对比真实值和预测值:\n", y_predict == y_test)
    # 方法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_)
    return None



# 运行结果
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 2]
y_test:
 [0 2 1 2 1 1 1 2 1 0 2 1 2 2 0 2 1 1 2 1 0 2 0 1 2 0 2 2 2 2]
直接对比真实值和预测值:
 [ 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  True]
准确率为:
 0.9333333333333333
最佳参数
 {'n_neighbors': 5}
最佳结果
 0.9666666666666666
最佳估计器
 KNeighborsClassifier()
交叉验证结果
 {'mean_fit_time': array([0.00059471, 0.00040169, 0.00039732, 0.00049963, 0.00039873,
       0.00059736]), 'std_fit_time': array([0.00048576, 0.00049201, 0.00048692, 0.00049964, 0.00048834,
       0.00048775]), 'mean_score_time': array([0.00100403, 0.00099268, 0.00089741, 0.00099623, 0.0010962 ,
       0.0010021 ]), 'std_score_time': array([1.94739385e-05, 1.83725301e-05, 2.99643138e-04, 4.43773610e-04,
       2.95656031e-04, 1.20468404e-05]), '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.        , 1.        , 0.91666667,
       0.91666667]), 'split2_test_score': array([1.        , 0.91666667, 1.        , 1.        , 1.        ,
       1.        ]), 'split3_test_score': array([0.91666667, 0.91666667, 0.91666667, 0.91666667, 0.91666667,
       0.91666667]), 'split4_test_score': array([0.91666667, 1.        , 1.        , 1.        , 1.        ,
       1.        ]), 'split5_test_score': array([1., 1., 1., 1., 1., 1.]), 'split6_test_score': array([0.91666667, 0.91666667, 0.91666667, 0.91666667, 0.91666667,
       0.91666667]), 'split7_test_score': array([0.83333333, 0.83333333, 0.91666667, 0.91666667, 0.91666667,
       0.91666667]), 'split8_test_score': array([0.91666667, 0.91666667, 0.91666667, 0.91666667, 0.91666667,
       0.91666667]), 'split9_test_score': array([1., 1., 1., 1., 1., 1.]), 'mean_test_score': array([0.94166667, 0.94166667, 0.96666667, 0.96666667, 0.95833333,
       0.95833333]), 'std_test_score': array([0.05335937, 0.05335937, 0.04082483, 0.04082483, 0.04166667,
       0.04166667]), 'rank_test_score': array([5, 5, 1, 1, 3, 3])}

Process finished with exit code 0

5 facebook案例

FBlocation介绍

数据介绍：将根据用户的位置，准确性和时间戳预测用户正在查看的业务。

train.csv，test.csv 
row_id：登记事件的ID
xy：坐标
准确性：定位准确性 
时间：时间戳
place_id：业务的ID，这是您预测的目标

分析

  • 对于数据做一些基本处理（这里所做的一些处理不一定达到很好的效果，我们只是简单尝试，有些特征我们可以根据一些特征选择的方式去做处理）

    • 1、缩小数据集范围 DataFrame.query()

    • 4、删除没用的日期数据 DataFrame.drop（可以选择保留）

    • 5、将签到位置少于n个用户的删除

      place_count = data.groupby(‘place_id’).count()

      tf = place_count[place_count.row_id > 3].reset_index()

      data = data[data[‘place_id’].isin(tf.place_id)]

  • 分割数据集

  • 标准化处理

  • k-近邻预测

    import pandas as pd

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

    data.head()
    row_idxyaccuracytimeplace_id
    000.79419.0809544707028523065625
    115.95674.7968131865551757726713
    228.30787.0407743226481137537235
    337.36652.5165657045876567393236
    444.09611.1307314721307440663949
    # 2.基本的数据处理
# 1）缩小数据范围
data = data.query("x < 2.5 & x > 2 & y < 1.5 & y > 1.0")

    data.head()
    row_idxyaccuracytimeplace_id
    1121122.23601.3655666231747663031065
    1801802.20031.2541656101952358558474
    3673672.41081.3213745796676644108708
    8748742.08221.19733201435663229876087
    102210222.01601.1659652079933244363975
    # 2) 处理时间特征
time_value = pd.to_datetime(data["time"], unit="s")

    date = pd.DatetimeIndex(time_value.values)

    data["day"] = date.day

    data["weekday"] = date.weekday

    data["hour"] = date.hour

    data.head()
    row_idxyaccuracytimeplace_iddayweekdayhour
    1121122.23601.3655666231747663031065835
    1801802.20031.2541656101952358558474831
    3673672.41081.32137457966766441087087217
    8748742.08221.197332014356632298760872415
    102210222.01601.1659652079933244363975359
    # 3) 过滤签到次数少的地点
place_count = data.groupby("place_id").count()["row_id"]
data.groupby("place_id").count().head()
    row_idxyaccuracytimedayweekdayhour
    place_id
    101216585311111111
    101399173733333333
    10146052712828282828282828
    101564574344444444
    10172361543131313131313131
    place_count[place_count>3]

    place_id
1014605271     28
1015645743      4
1017236154     31
1024951487      5
1028119817      4
             ... 
9936666116    140
9954155328      8
9980625005     16
9994257798     25
9996671132     18
Name: row_id, Length: 950, dtype: int64

    data_final = data[data["place_id"].isin(place_count[place_count > 3].index.values)]
data_final.head()
    row_idxyaccuracytimeplace_iddayweekdayhour
    1121122.23601.3655666231747663031065835
    3673672.41081.32137457966766441087087217
    8748742.08221.197332014356632298760872415
    102210222.01601.1659652079933244363975359
    104510452.38591.166049850337864382408736119
    # 筛选特征值和目标值
x=data_final[["x","y","accuracy","day","weekday","hour"]]
y=data_final["place_id"]

    x.head()
    xyaccuracydayweekdayhour
    1122.23601.365566835
    3672.41081.3213747217
    8742.08221.19733202415
    10222.01601.165965359
    10452.38591.16604986119
    y.head()

    112     7663031065
367     6644108708
874     3229876087
1022    3244363975
1045    6438240873
Name: place_id, dtype: int64

    #数据集划分
from sklearn.model_selection import train_test_split

    x_train, x_test, y_train, y_test = train_test_split(x, y)

    x_train.head()
    xyaccuracydayweekdayhour
    131222222.31331.0623626111
    157035142.35841.090560720
    34043692.32671.0723714618
    57876112.35611.3800681318
    224099692.49311.2487562419
    x_test.head()
    xyaccuracydayweekdayhour
    101940682.33131.2534887216
    227262912.14791.2861158614
    146879702.32231.136265506
    132076372.03731.0999686113
    185143192.01601.3451196113
    x_train
    xyaccuracydayweekdayhour
    131222222.31331.0623626111
    157035142.35841.090560720
    34043692.32671.0723714618
    57876112.35611.3800681318
    224099692.49311.2487562419
    .....................
    82803412.47581.4988686110
    181688612.10591.352465357
    184174692.33391.141384616
    226522772.26251.3795568310
    11121622.38271.372063947

    60682 rows × 6 columns

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

        # 3.特征工程标准化  此数据不用做降维处理
    transfer = StandardScaler()
        # fit() 计算 每一列的平均值、标准差
        # transform() (x-mean)/std进行最终的转换
    x_train = transfer.fit_transform(x_train)
        # 对测试集进行标准化，训练集调用fit_transfor(),测试集调用transform用训练集的平均值、标准差带入公示进行最终的转换
    x_test = transfer.transform(x_test)
    # 4.KNN算法预估器 p=1曼哈顿距离 p=2欧氏距离 默认欧氏距离
    estimator = KNeighborsClassifier()

    # 加入网格搜索和交叉验证
    # 参数准备
    params_dict = {"n_neighbors":[5,7,9]}
    # estimator:估计器对象 param_grid：估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
    estimator = GridSearchCV(estimator, param_grid=params_dict, cv=3)
    estimator.fit(x_train, y_train)
    # 5.模型评估
        #方法1：直接对比真实值和与测试
    y_predict = estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("y_test:\n", y_test)
    print("直接对比真实值和预测值:\n",y_predict==y_test)
    #方法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_)

    E:\Program Files\Environment\Anaconda3\lib\site-packages\sklearn\model_selection\_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.
  warnings.warn(


y_predict:
 [2585551753 5111412226 3588028567 ... 6396652784 3157530019 8812115701]
y_test:
 10194068    2585551753
22726291    5111412226
14687970    6940115252
13207637    5781604363
18514319    6171384989
               ...    
6271017     5541564636
18742421    5529091830
15255113    6828787147
21947752    2809108094
26200146    8812115701
Name: place_id, Length: 20228, dtype: int64
直接对比真实值和预测值:
 10194068     True
22726291     True
14687970    False
13207637     True
18514319    False
            ...  
6271017     False
18742421    False
15255113    False
21947752    False
26200146     True
Name: place_id, Length: 20228, dtype: bool
准确率为:
 0.3637037769428515
最佳参数
 {'n_neighbors': 7}
最佳结果
 0.33497576141406077
最佳估计器
 KNeighborsClassifier(n_neighbors=7)
交叉验证结果
 {'mean_fit_time': array([0.07247265, 0.06882707, 0.06881801]), 'std_fit_time': array([1.24466489e-03, 1.65780462e-05, 1.75561285e-06]), 'mean_score_time': array([0.76148359, 0.78323086, 0.85836903]), 'std_score_time': array([0.02202489, 0.00621847, 0.07285544]), 'param_n_neighbors': masked_array(data=[5, 7, 9],
             mask=[False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}], 'split0_test_score': array([0.33710698, 0.33582163, 0.33112517]), 'split1_test_score': array([0.33227864, 0.33257527, 0.32817521]), 'split2_test_score': array([0.33391012, 0.33653038, 0.33217976]), 'mean_test_score': array([0.33443191, 0.33497576, 0.33049338]), 'std_test_score': array([0.0020054 , 0.00172189, 0.00169479]), 'rank_test_score': array([2, 1, 3])}

5 小结

  • K-近邻算法简介【了解】
    • 定义:就是通过你的"邻居"来判断你属于哪个类别
    • 如何计算你到你的"邻居"的距离：一般时候,都是使用欧氏距离

3 朴素贝叶斯算法

1 什么是朴素贝叶斯分类方法

垃圾邮件分类 文章分类

2 概率基础

2.1 概率(Probability)定义

  • 概率定义为一件事情发生的可能性
    • 扔出一个硬币，结果头像朝上
    • 某天是晴天
  • P(X) : 取值在[0, 1]

2.2 女神是否喜欢计算案例

在讲这两个概率之前我们通过一个例子，来计算一些结果：

计算概率
  • 问题如下：
image-20211104231718221

那么其中有些问题我们计算的结果不正确，或者不知道计算，我们有固定的公式去计算

image-20211104233253069

2.3 条件概率与联合概率

  • 联合概率：包含多个条件，且所有条件同时成立的概率
    • 记作：P(A,B)
    • 特性：P(A, B) = P(A)P(B)
  • 条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
    • 记作：P(A|B)
    • 特性：P(A1,A2|B) = P(A1|B)P(A2|B)

注意：此条件概率的成立，是由于A1,A2相互独立的结果(记忆)

这样我们计算结果为：

p(程序员, 匀称) =  P(程序员)P(匀称) =3/7*(4/7) = 12/49 
P(产品, 超重|喜欢) = P(产品|喜欢)P(超重|喜欢)=1/2 *  1/4 = 1/8

那么，我们知道了这些知识之后，继续回到我们的主题中。朴素贝叶斯如何分类，这个算法经常会用在文本分类，那就来看文章分类是一个什么样的问题？

文章分类引入

3 贝叶斯公式

3.1 公式

贝叶斯公式

那么这个公式如果应用在文章分类的场景当中，我们可以这样看：

贝叶斯公式理解

公式分为三个部分：

  • P©：每个文档类别的概率(某文档类别数／总文档数量)
  • P(W│C)：给定类别下特征（被预测文档中出现的词）的概率
    • 计算方法：P(F1│C)=Ni/N （训练文档中去计算）
      • Ni为该F1词在C类别所有文档中出现的次数
      • N为所属类别C下的文档所有词出现的次数和
  • P(F1,F2,…) 预测文档中每个词的概率

如果计算两个类别概率比较：

概率前面比较大小

所以我们只要比较前面的大小就可以，得出谁的概率大

3.2 文章分类计算

例一

image-20211104233809557

​ P(Tokyo|C)=0,这时要加入拉普拉斯平滑系数

image-20211104234159444

​ 比较最终算的两个值那个大救赎有哪一类

​ 例二

  • 假设我们从训练数据集得到如下信息
分类计算例子
  • 计算结果
科技：P(科技|影院,支付宝,云计算) = 𝑃(影院,支付宝,云计算|科技)∗P(科技)=(8/100)∗(20/100)∗(63/100)∗(30/90) = 0.00456109

娱乐：P(娱乐|影院,支付宝,云计算) = 𝑃(影院,支付宝,云计算|娱乐)∗P(娱乐)=(56/121)∗(15/121)∗(0/121)∗(60/90) = 0

思考:我们计算出来某个概率为0，合适吗？

3.3 拉普拉斯平滑系数

目的：防止计算出的分类概率为0

平滑系数公式 
P(娱乐|影院,支付宝,云计算) =P(影院,支付宝,云计算|娱乐)P(娱乐) =P(影院|娱乐)*P(支付宝|娱乐)*P(云计算|娱乐)

3.4 API

  • sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
    • 朴素贝叶斯分类
    • alpha：拉普拉斯平滑系数

4 案例

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, train_size=0.25)
    # 3.特征工程 特征抽取-TfidfVectorizer
    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)
        #方法二: 计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n",score)

    return None

# 运算结果
y_predict:
 [ 3  3  5 ... 11  6  7]
直接对比真实值和预测值:
 [False  True  True ... False  True  True]
准确率为：
 0.7384506544039618

4 决策树

1 认识决策树

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

怎么理解这句话？通过一个对话例子

相亲对话

想一想这个女生为什么把年龄放在最上面判断！！！！！！！！！

1.1 决策树分类原理详解

为了更好理解决策树具体怎么分类的，我们通过一个问题例子？

银行贷款数

问题：如何对这些客户进行分类预测？你是如何去划分？

有可能你的划分是这样的

贷款划分1

那么我们怎么知道这些特征哪个更好放在最上面，那么决策树的真是划分是这样的

贷款划分2

2 信息增益

如果一个系统是确定的为1，信息熵最小

如果一个系统每个概率相同，信息熵最大

定义与公式

特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差，即公式为：

信息增益公式

公式的详细解释：

信息增益公式详解

注：信息增益表示得知特征X的信息而息的不确定性减少的程度使得类Y的信息熵减少的程度

贷款特征重要计算

银行贷款数
  • 我们以年龄特征来计算：
1、g(D, 年龄) = H(D) -H(D|年龄) = 0.971-[5/15H(青年)+5/15H(中年)+5/15H(老年]  #属性的信息增益=系统的信息熵-属性的信息熵

2、H(D) = -(6/15log(6/15)+9/15log(9/15))=0.971 #系统的信息熵

3、#属性的信息熵
    H(青年) = -(3/5log(3/5) +2/5log(2/5))
	H(中年)=-(3/5log(3/5) +2/5log(2/5))
	H(老年)=-(4/5og(4/5)+1/5log(1/5))

我们以A1、A2、A3、A4代表年龄、有工作、有自己的房子和贷款情况。最终计算的结果g(D, A1) = 0.313, g(D, A2) = 0.324, g(D, A3) = 0.420,g(D, A4) = 0.363。所以我们选择A3 作为划分的第一个特征。找信息增益最大的，这样我们就可以一棵树慢慢建立

决策树的三种算法实现

当然决策树的原理不止信息增益这一种，还有其他方法。但是原理都类似，我们就不去举例计算。

  • ID3
    • 信息增益 最大的准则
  • C4.5
    • 信息增益比 最大的准则
  • CART
    • 分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的默认原则
    • 优势：划分更加细致（从后面例子的树显示来理解）

决策树API

  • class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,random_state=None)
    • 决策树分类器
    • criterion:默认是’gini’系数，也可以选择信息增益的熵’entropy’
    • max_depth:树的深度大小
    • random_state:随机数种子
  • 其中会有些超参数：max_depth:树的深度大小
    • 其它超参数我们会结合随机森林讲解

保存树的结构到dot文件

  • 1、sklearn.tree.export_graphviz() 该函数能够导出DOT格式
    • tree.export_graphviz(estimator,out_file='tree.dot’,feature_names=[‘’,’’])
  • 2、工具:(能够将dot文件转换为pdf、png)
    • 安装graphviz
    • ubuntu:sudo apt-get install graphviz Mac:brew install graphviz
  • 3、运行命令
    • 然后我们运行这个命令
    • dot -Tpng tree.dot -o tree.png

3 用决策树对鸢尾花进行分类

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz
def decision_iris():
    '''
    用决策树对鸢尾花进行分类

    :return:
    '''
    # 1.获取数据集
    iris = load_iris()
    # 2.划分数据集
    x_train,x_test,y_train,y_test = train_test_split(iris.data, iris.target)
    # 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_predict == y_test)
    # 方法2：计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)

    export_graphviz(estimator, out_file="decision_tree_ picture/iris_tree.dot", feature_names=iris.feature_names)

    return  None

image-20211105083550326

4 案例：泰坦尼克号乘客生存预测

  • 泰坦尼克号数据

在泰坦尼克号和titanic2数据帧描述泰坦尼克号上的个别乘客的生存状态。这里使用的数据集是由各种研究人员开始的。其中包括许多研究人员创建的旅客名 单，由Michael A. Findlay编辑。我们提取的数据集中的特征是票的类别，存活，乘坐班，年龄，登陆，home.dest，房间，票，船和性别。

1、乘坐班是指乘客班（1，2，3），是社会经济阶层的代表。

2、其中age数据存在缺失。

import pandas as pd
# 1.获取数据
titanic = pd.read_csv("../resource/titanic/titanic.csv")
# 2.数据处理
#     缺失值处理
#     特征值->字典类型
# 3.准备好特征值 目标值
# 4.划分数据集
# 5.特征工程
# 6.决策树预估器流程
# 7.模型评估

titanic.head()
row.namespclasssurvivednameageembarkedhome.destroomticketboatsex
011st1Allen, Miss Elisabeth Walton29.0000SouthamptonSt Louis, MOB-524160 L2212female
121st0Allison, Miss Helen Loraine2.0000SouthamptonMontreal, PQ / Chesterville, ONC26NaNNaNfemale
231st0Allison, Mr Hudson Joshua Creighton30.0000SouthamptonMontreal, PQ / Chesterville, ONC26NaN(135)male
341st0Allison, Mrs Hudson J.C. (Bessie Waldo Daniels)25.0000SouthamptonMontreal, PQ / Chesterville, ONC26NaNNaNfemale
451st1Allison, Master Hudson Trevor0.9167SouthamptonMontreal, PQ / Chesterville, ONC22NaN11male
# 筛选特征值和目标值
x = titanic[["pclass", "age", "sex"]]
y = titanic["survived"]

x
pclassagesex
01st29.0000female
11st2.0000female
21st30.0000male
31st25.0000female
41st0.9167male
............
13083rdNaNmale
13093rdNaNmale
13103rdNaNmale
13113rdNaNfemale
13123rdNaNmale

1313 rows × 3 columns

y.head()

0    1
1    0
2    0
3    0
4    1
Name: survived, dtype: int64

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

x.head()
pclassagesex
01st29.0000female
11st2.0000female
21st30.0000male
31st25.0000female
41st0.9167male
# 2）转换成字典
x = x.to_dict(orient="records")

x[:5]

[{'pclass': '1st', 'age': 29.0, 'sex': 'female'},
 {'pclass': '1st', 'age': 2.0, 'sex': 'female'},
 {'pclass': '1st', 'age': 30.0, 'sex': 'male'},
 {'pclass': '1st', 'age': 25.0, 'sex': 'female'},
 {'pclass': '1st', 'age': 0.9167, 'sex': 'male'}]

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

# 3.字典特征抽取
from sklearn.feature_extraction import DictVectorizer
transfer = DictVectorizer()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

KNN算法对泰坦尼克号的生存进行预测

from sklearn.tree import DecisionTreeClassifier,export_graphviz
# 4.决策树预估器
estimator = DecisionTreeClassifier(criterion="entropy",max_depth=5)
estimator.fit(x_train,y_train)
# 5.模型评估
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法2：计算准确率
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)

y_predict:
 [0 0 0 1 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 1 0 1 0 0 0
 0 1 1 1 0 0 0 1 0 1 1 0 1 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0
 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0
 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0
 0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0
 1 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0
 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 1]
直接对比真实值和预测值:
 590      True
1157     True
641     False
398      True
853      True
        ...  
563      True
358      True
121      True
1097     True
83       True
Name: survived, Length: 329, dtype: bool
准确率为:
 0.790273556231003

KNN算法对泰坦尼克号的生存进行预测

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 4.KNN算法预估器 p=1曼哈顿距离 p=2欧氏距离 默认欧氏距离
estimator = KNeighborsClassifier()
# 加入网格搜索和交叉验证
# 参数准备
params_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
# estimator:估计器对象 param_grid：估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
estimator = GridSearchCV(estimator, param_grid=params_dict, cv=10)
estimator.fit(x_train, y_train)
# 5.模型评估
# 方法1：直接对比真实值和与测试
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("y_test:\n", y_test)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法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_)

y_predict:
 [0 0 0 1 0 0 0 0 0 1 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0
 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0
 1 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0
 0 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 1
 1 1 0 1 0 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 0 0 1 0
 1 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0
 0 1 0 1 0 0 0 1 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 1 0 1 1 0 0 0 0 1 1 1 0 0 0
 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 0 1]
y_test:
 590     0
1157    0
641     1
398     1
853     0
       ..
563     0
358     1
121     0
1097    0
83      1
Name: survived, Length: 329, dtype: int64
直接对比真实值和预测值:
 590      True
1157     True
641     False
398      True
853      True
        ...  
563      True
358      True
121      True
1097     True
83       True
Name: survived, Length: 329, dtype: bool
准确率为:
 0.7872340425531915
最佳参数
 {'n_neighbors': 7}
最佳结果
 0.8039270253555969
最佳估计器
 KNeighborsClassifier(n_neighbors=7)
交叉验证结果
 {'mean_fit_time': array([0.00149481, 0.00090151, 0.00109046, 0.0009779 , 0.00118496,
       0.00090187]), 'std_fit_time': array([9.20082306e-04, 3.01925683e-04, 5.37038408e-04, 2.36335716e-05,
       7.34021641e-04, 3.00797672e-04]), 'mean_score_time': array([0.00553658, 0.00467844, 0.00538712, 0.00519798, 0.00479972,
       0.00488379]), 'std_score_time': array([0.00158095, 0.0009864 , 0.00118098, 0.00087649, 0.0004    ,
       0.00103625]), '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([0.80808081, 0.82828283, 0.7979798 , 0.83838384, 0.81818182,
       0.81818182]), 'split1_test_score': array([0.62626263, 0.56565657, 0.75757576, 0.75757576, 0.75757576,
       0.76767677]), 'split2_test_score': array([0.62626263, 0.5959596 , 0.76767677, 0.75757576, 0.76767677,
       0.76767677]), 'split3_test_score': array([0.55555556, 0.5959596 , 0.77777778, 0.7979798 , 0.80808081,
       0.80808081]), 'split4_test_score': array([0.52040816, 0.52040816, 0.84693878, 0.84693878, 0.82653061,
       0.79591837]), 'split5_test_score': array([0.6122449 , 0.60204082, 0.83673469, 0.83673469, 0.81632653,
       0.79591837]), 'split6_test_score': array([0.62244898, 0.63265306, 0.85714286, 0.83673469, 0.84693878,
       0.84693878]), 'split7_test_score': array([0.55102041, 0.55102041, 0.7755102 , 0.75510204, 0.75510204,
       0.73469388]), 'split8_test_score': array([0.6122449 , 0.62244898, 0.76530612, 0.82653061, 0.79591837,
       0.79591837]), 'split9_test_score': array([0.58163265, 0.58163265, 0.78571429, 0.78571429, 0.80612245,
       0.79591837]), 'mean_test_score': array([0.61161616, 0.60960627, 0.7968357 , 0.80392703, 0.79984539,
       0.79269223]), 'std_test_score': array([0.07428195, 0.07940273, 0.03473885, 0.03570535, 0.02912713,
       0.02913109]), 'rank_test_score': array([5, 6, 3, 1, 2, 4])}

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

from sklearn.ensemble import RandomForestClassifier
# 4.随机深林算法预估器 
estimator = RandomForestClassifier()
# 加入网格搜索和交叉验证
# 参数准备
params_dict = {"n_estimators": [100, 200, 300, 400, 500, 1200],"max_depth":[4,5,6,7,8],"criterion":["entropy"]}
# estimator:估计器对象 param_grid：估计器参数(dict){"n_neighbors":[1,9,11]} cv:指定几折交叉验证 fit():输入训练集数据 score()准确率
estimator = GridSearchCV(estimator, param_grid=params_dict, cv=2)
estimator.fit(x_train, y_train)
# 5.模型评估
# 方法1：直接对比真实值和与测试
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("y_test:\n", y_test)
print("直接对比真实值和预测值:\n", y_predict == y_test)
# 方法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_)

y_predict:
 [0 0 0 1 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0 1 1 0 0 0 0 0 1 0 1 1 1 1 0 0 0 0
 0 1 1 1 0 0 0 1 0 1 1 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 0 0 0 0
 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 1 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0 0
 0 1 0 1 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 1 1 0 0 0 0 0
 1 0 1 0 1 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 0 0 0 0 0 0 0 0
 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 0 0 0 0
 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 1 0 0 1]
y_test:
 590     0
1157    0
641     1
398     1
853     0
       ..
563     0
358     1
121     0
1097    0
83      1
Name: survived, Length: 329, dtype: int64
直接对比真实值和预测值:
 590      True
1157     True
641     False
398      True
853      True
        ...  
563      True
358      True
121      True
1097     True
83       True
Name: survived, Length: 329, dtype: bool
准确率为:
 0.8145896656534954
最佳参数
 {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 300}
最佳结果
 0.8241869918699187
最佳估计器
 RandomForestClassifier(criterion='entropy', max_depth=5, n_estimators=300)
交叉验证结果
 {'mean_fit_time': array([0.10773706, 0.19297969, 0.30615187, 0.3949554 , 0.49763954,
       1.58897257, 0.1530757 , 0.3373847 , 0.42813838, 0.62685108,
       1.13304913, 1.80858314, 0.13982916, 0.30716383, 0.46723175,
       0.61357844, 0.76146626, 1.85352802, 0.15277028, 0.32195222,
       0.47836339, 0.66029692, 1.33696401, 2.25642073, 0.19825661,
       0.38971925, 0.65994167, 0.74528587, 1.19055343, 2.95836234]), 'std_fit_time': array([7.97224045e-03, 5.05089760e-04, 1.09999180e-02, 9.85383987e-04,
       1.19386911e-02, 3.60212326e-02, 1.24795437e-02, 3.00669670e-03,
       2.06164122e-02, 6.43358231e-02, 1.00861788e-02, 8.12751055e-02,
       1.53231621e-03, 2.97200680e-03, 1.04892254e-02, 8.19456577e-03,
       1.31447315e-02, 2.14662552e-02, 1.70080662e-02, 1.77611113e-02,
       4.54127789e-03, 4.00140285e-02, 3.85288119e-01, 2.02952027e-01,
       1.51988268e-02, 9.79542732e-03, 4.45888042e-02, 3.46029997e-02,
       1.50036097e-01, 5.44578314e-01]), 'mean_score_time': array([0.01096785, 0.01993704, 0.03096426, 0.04036295, 0.05187905,
       0.14403391, 0.01249444, 0.03091896, 0.03937757, 0.05281842,
       0.0688498 , 0.18329692, 0.01442325, 0.0289228 , 0.04340398,
       0.05485666, 0.06832874, 0.16604424, 0.01512146, 0.02568245,
       0.04339993, 0.05734289, 0.09398592, 0.18908441, 0.01494157,
       0.04238474, 0.05141592, 0.07779431, 0.0899986 , 0.17841971]), 'std_score_time': array([5.12599945e-06, 1.66893005e-05, 1.20401382e-05, 5.27977943e-04,
       3.00967693e-03, 4.77623940e-03, 4.98890877e-04, 9.95516777e-04,
       4.79340553e-04, 6.79492950e-06, 1.57356262e-05, 1.78389549e-02,
       1.51050091e-03, 1.99365616e-03, 3.47173214e-03, 2.77757645e-05,
       4.87208366e-04, 5.46932220e-04, 1.11722946e-03, 2.08139420e-04,
       4.82201576e-04, 4.48501110e-03, 2.41731405e-02, 7.41183758e-03,
       1.01578236e-03, 5.44941425e-03, 3.43656540e-03, 9.87052917e-04,
       7.70485401e-03, 1.41978264e-04]), 'param_criterion': masked_array(data=['entropy', 'entropy', 'entropy', 'entropy', 'entropy',
                   'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
                   'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
                   'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
                   'entropy', 'entropy', 'entropy', 'entropy', 'entropy',
                   'entropy', 'entropy', 'entropy', 'entropy', 'entropy'],
             mask=[False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'param_max_depth': masked_array(data=[4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
                   7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8],
             mask=[False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'param_n_estimators': masked_array(data=[100, 200, 300, 400, 500, 1200, 100, 200, 300, 400, 500,
                   1200, 100, 200, 300, 400, 500, 1200, 100, 200, 300,
                   400, 500, 1200, 100, 200, 300, 400, 500, 1200],
             mask=[False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False, False, False,
                   False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 4, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 5, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 6, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 7, 'n_estimators': 1200}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 100}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 200}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 300}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 400}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 500}, {'criterion': 'entropy', 'max_depth': 8, 'n_estimators': 1200}], 'split0_test_score': array([0.81504065, 0.81504065, 0.81300813, 0.81300813, 0.81300813,
       0.81300813, 0.80894309, 0.81504065, 0.81504065, 0.81504065,
       0.81504065, 0.81707317, 0.80081301, 0.79674797, 0.79878049,
       0.79878049, 0.79674797, 0.79674797, 0.79674797, 0.79471545,
       0.79674797, 0.79471545, 0.79471545, 0.79674797, 0.79674797,
       0.79471545, 0.79674797, 0.79674797, 0.79674797, 0.79674797]), 'split1_test_score': array([0.82723577, 0.82520325, 0.82520325, 0.82520325, 0.82520325,
       0.82520325, 0.82723577, 0.82520325, 0.83333333, 0.83130081,
       0.83333333, 0.82723577, 0.83536585, 0.83130081, 0.83130081,
       0.82926829, 0.83536585, 0.82926829, 0.82520325, 0.82113821,
       0.82723577, 0.82723577, 0.82723577, 0.82723577, 0.81910569,
       0.82520325, 0.82317073, 0.82113821, 0.81910569, 0.81707317]), 'mean_test_score': array([0.82113821, 0.82012195, 0.81910569, 0.81910569, 0.81910569,
       0.81910569, 0.81808943, 0.82012195, 0.82418699, 0.82317073,
       0.82418699, 0.82215447, 0.81808943, 0.81402439, 0.81504065,
       0.81402439, 0.81605691, 0.81300813, 0.81097561, 0.80792683,
       0.81199187, 0.81097561, 0.81097561, 0.81199187, 0.80792683,
       0.80995935, 0.80995935, 0.80894309, 0.80792683, 0.80691057]), 'std_test_score': array([0.00609756, 0.0050813 , 0.00609756, 0.00609756, 0.00609756,
       0.00609756, 0.00914634, 0.0050813 , 0.00914634, 0.00813008,
       0.00914634, 0.0050813 , 0.01727642, 0.01727642, 0.01626016,
       0.0152439 , 0.01930894, 0.01626016, 0.01422764, 0.01321138,
       0.0152439 , 0.01626016, 0.01626016, 0.0152439 , 0.01117886,
       0.0152439 , 0.01321138, 0.01219512, 0.01117886, 0.0101626 ]), 'rank_test_score': array([ 5,  6,  8,  8,  8,  8, 12,  6,  1,  3,  1,  4, 12, 16, 15, 16, 14,
       18, 21, 27, 19, 21, 21, 19, 27, 24, 24, 26, 27, 30])}

5 决策树总结

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

注：企业重要决策，由于决策树很好的分析能力，在决策过程应用较多， 可以选择特征

5 集成学习方法之随机森林

1.随机森林的认识

  • 什么是集成学习方法

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

​ 例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终投票结果就是True

  • 什么是随机森林

​ 在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。

  • 随机森林原理过程

    学习算法根据下列算法而建造每棵树：

    用N来表示训练用例（样本）的个数，M表示特征数目。

    ​ 1、一次随机选出一个样本，重复N次， （有可能出现重复的样本）

    ​ 2、随机去选出m个特征, m <<M，建立决策树

    采取bootstrap抽样

  • 为什么采用BootStrap抽样

    为什么要随机抽样训练集？

    ​ 如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的

    为什么要有放回地抽样？

    ​ 如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。

2 代码

API

  • class 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_features="auto”,每个决策树的最大特征数量
      • If “auto”, then max_features=sqrt(n_features).
      • If “sqrt”, then max_features=sqrt(n_features) (same as “auto”).
      • If “log2”, then max_features=log2(n_features).
      • If None, then max_features=n_features.
    • bootstrap：boolean，optional（default = True）是否在构建树时使用放回抽样
    • min_samples_split:节点划分最少样本数
    • min_samples_leaf:叶子节点的最小样本数

  • 超参数：n_estimator, max_depth, min_samples_split,min_samples_lea

# 随机森林去进行预测
rf = RandomForestClassifier()

param = {"n_estimators": [120,200,300,500,800,1200], "max_depth": [5, 8, 15, 25, 30]}

# 超参数调优
gc = GridSearchCV(rf, param_grid=param, cv=2)

gc.fit(x_train, y_train)

print("随机森林预测的准确率为：", gc.score(x_test, y_test))

3 总结

  • 在当前所有算法中，具有极好的准确率
  • 能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维
    array([ 5, 6, 8, 8, 8, 8, 12, 6, 1, 3, 1, 4, 12, 16, 15, 16, 14,
    18, 21, 27, 19, 21, 21, 19, 27, 24, 24, 26, 27, 30])}
开心码农小王。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习算法.ppt机器学习算法.ppt机器学习算法.ppt机器学习算法.ppt
06-30
机器学习算法.ppt机器学习算法.ppt机器学习算法.ppt
机器学习基础——特征提取（笔记一）
qq_39629280的博客
11-16 599
1.机器学习简介 定义：机器学习是从数据中自动分析获得模型，并利用模型对未知数据进行预测 数据集的构成：特征值+目标值 对于每一行的数据可以成为样本，有些数据集可以没有目标值 机器学习算法分类： 目标值：类别——分类问题 算法：K-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归 目标值：连续型的数据——回归问题 算法：线性回归，岭回归 目标值：无——无监督学习 ...
scikit-learn 实战之非监督学习 3
oxuzhenyi的博客
08-04 1245
聚类算法对比与选择 一、实验介绍 1.1 实验内容 非监督学习（英语：Unsupervised learning）是机器学习中十分重要的一个分支。这是本实验课程的第 3 章节，将带你了解更多聚类算法，并完成聚类算法对照实验。 1.2 实验知识点 Mini Batch K-Means 等其他聚类算法聚类算法对比 1.3 实验环境 python2.7Xfce 终端ipython
机器学习-聚类算法1
08-03
介绍几种K-Means改进的算法。K-Means++算法在聚类中心的初始化过程中的基本原则是使得初始的聚类中心之间的相互距离尽可能远，这样可以避免出现上述的问题
机器学习--KNN算法.pptx
11-28
物流人工智能_机器学习
机器学习十大算法：K-means.rar_K._k-means_机器_机器学习_机器学习算法
09-15
机器学习十大算法，详细介绍，简单易学，强烈推荐
机器学习-PCA算法的Python实现.zip
02-15
机器学习 机器学习_PCA算法的Python实现
Stable Diffusion中的embedding
程序那些事
04-25 809
嵌入，也称为文本反转，是在 Stable Diffusion 中控制图像样式的另一种方法。在这篇文章中，我们将学习什么是嵌入，在哪里可以找到它们，以及如何使用它们。
每天五分钟机器学习：神经网络模型参数的选择
huanfeng_AI的博客
04-21 410
神经网络的模型参数选择是一个复杂而关键的过程。在实际应用中，我们需要根据任务需求、计算资源以及模型的性能来进行综合考虑和调优。通过选择合适的参数和调优方法，我们可以构建出性能优异、泛化能力强的神经网络模型，为深度学习和人工智能的应用提供有力支持。
机器学习笔记 - 使用 OpenCV 的结构化森林进行边缘检测
学以致用 知行合一
04-18 357
边缘检测是计算机视觉领域中一项非常重要的任务。这是许多纯计算机视觉任务（例如轮廓检测）的第一步。即使涉及深度学习，较深层也首先学习识别边缘，然后再学习图像的复杂特征。所以，我们可以说边缘检测在计算机视觉领域非常重要。拥有良好且高效的图像边缘检测算法同样重要。结构化森林进行边缘检测，也称为结构化边缘检测器。已经有许多有效的边缘检测器，例如Canny、Sobel 和 Laplacian 边缘检测器。他们为什么我们需要另一个结构化边缘检测器。这种检测器的主要特点是它能够快速且更好地预测局部掩模的边缘。
【好书推荐7】《机器学习平台架构实战》
定期分享我的发现和想法，感谢你的陪伴和支持
04-23 2436
机器学习平台架构实战》详细阐述了与机器学习平台架构相关的基本解决方案，主要包括机器学习和机器学习解决方案架构，机器学习的业务用例，机器学习算法，机器学习的数据管理，开源机器学习库，Kubernetes容器编排基础设施管理，开源机器学习平台，使用AWS机器学习服务构建数据科学环境，使用AWS机器学习服务构建企业机器学习架构，高级机器学习工程，机器学习治理、偏差、可解释性和隐私，使用人工智能服务和机器学习平台构建机器学习解决方案等内容。
机器学习作业3____决策树（CART算法）
最新发布
u013731025的博客
04-25 992
CART（Classification and Regression Trees）是一种常用的决策树算法，可用于分类和回归任务。这个算法由Breiman等人于1984年提出，它的主要思想是通过递归地将数据集划分为两个子集，然后在每个子集上继续划分，直到满足某个停止条件为止。CART算法在分类和回归问题上表现良好，并且能够处理多种数据类型（包括离散型和连续型特征）。由于其简单、易于理解和实现，以及在一些应用中的良好性能，CART算法被广泛应用于实践中。
机器学习之支持向量机
weixin_50626279的博客
04-21 884
支持向量机的主要任务就是从样本空间中找到合适的划分超平面，将属于不同类别的样本分开。我们希望找到的决策边界距离两个类别中位于边界上的点最远。
机器学习基本流程
WilenWu
04-20 1401
PSI(Population Stability Index)指标反映了实际分布(actual)与预期分布(expected)的差异。在建模中，我们常用来筛选特征变量、评估模型稳定性。其中，在建模时通常以训练样本(In the Sample, INS)作为预期分布，而验证样本在各分数段的分布通常作为实际分布。超参数调优算法主要有网格搜索(Grid Search)，随机搜索(Randomized Search)和贝叶斯优化(Bayesian Optimization)，本文采用贝叶斯优化。
算法刷题-16
qq_45773834的博客
04-21 693
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
【算法基础】第五章：动态规划
m0_65787507的博客
04-24 505
DP：【1】状态表示：需要几个维度来表示状态（1）集合（所有选法，带有约束条件）（2）属性（最大值、最小值、数量）【2】状态计算：如何算出每一步的状态，对应集合的划分（不重+不漏）**DP的优化：**对代码/计算方程做变形。
视频质量评价 BRISQUE算法详细介绍
小金牛来了
04-21 84
视频质量评价 BRISQUE算法详细介绍
【错题集-编程题】数组中的最长连续子序列（排序 + 模拟）
Elena's Blog
04-24 275
因为题目不要求位置连续，那么就可以直接想到排序（我把这一块理解错了，导致没有排序去做），接着就是简单的模拟。，然而实际上这道题目要求的是。小心处理数字相同的情况。
二分答案算法
2301_79980806的博客
04-21 1048
跟二分查找类似，当我们要找某个量的最值的时候，可以在这个两最小可能的取值，和最大可能的取值之间二分，来快速找到答案check函数为了验证中间值是否符合题目要求，根据是否来决定下一轮区间界限是作曲兼缩小，还是右区间缩小。
机器学习-决策树算法
09-02
- *1* *2* *3* [机器学习算法（3）之决策树算法](https://blog.csdn.net/qq_20412595/article/details/82048795)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值