首页 > 其他分享> 文章详细

机器学习sklearn

2021-06-14 17:04:44 阅读：247 来源： 互联网

标签：__ 机器学习 print train test data sklearn

1.机器学习概述

1.1人工智能概述

1.1.1机器学习与人工智能、深度学习的关系

机器学习是人工智能的实现途径
深度学习是机器学习的一个方法发展而来的

1.1.2 机器学习深度学习的应用场景

传统预测
图像识别
自然语言处理

1.2什么是机器学习

1.2.1 定义

机器学习是从数据中自动分析获得模型，并利用模型对未知数据进行预测

1.2.2 数据集的构成

特征值+目标值（比如说房屋的特征是特征值，房屋的价格是目标值）
对于每一行数据可以称为样本，有些数据集可以没有目标值

1.3 机器学习算法分类

监督学习：输入数据是由输入特征值和目标值所组成，函数的输出可以是一个连续的值（称为回归），或者是有限个离散的值（称为分类）
- 分类问题：比如根据图片识别猫和狗，k-邻近算法、贝叶斯分类、决策树与随机森林、逻辑回归
- 回归问题：连续型数据，比如根据房子的特征预测房价，线性回归、岭回归
无监督学习：输入数据有特征无标签，即没有标准答案，比如根据人的特征给人进行分类
- 聚类：k-means

1.4机器学习的开发流程

获取数据
数据处理
特征工程
机器学习算法进行训练-得到模型
模型评估
应用

1.5 学习框架和资料

高数、线代、概率论
框架 sklearn pytouch tenserflow
书籍资料
- 机器学习西瓜书-周志华
- 统计学习方法-李航
- 深度学习花书

2.特征工程

2.1数据集

2.1.1 可用数据集

UCI
sklearn（python的一个库，有文档）
kaggle

2.1.2sklearn数据集

datasets.load_* ()

获取小规模数据集，数据包含在datasets
datasets.fetch_* (data_home=None,subset=’’)

获取大规模数据集，需要重网络下载

函数的第一个参数是data_home，表示数据集下载的目录，默认是 ~/scikit_learn_data/，要修改默认目录，可以修改环境变量SCIKIT_LEARN_DATA

第二个参数可以选择 ‘train’ ‘all’ ‘test’ 分别表示训练集测试机和两者
返回值都为datesets.base.Bunch()继承自字典

本质上是一个 dict，它的键值对可用通过对象的属性方式访问。主要包含以下属性：
- data：特征数据数组，是 n_samples * n_features 的二维 numpy.ndarray 数组
- target：标签数组，是 n_samples 的一维 numpy.ndarray 数组
- DESCR：数据描述
- feature_names：特征名
- target_names：标签名
```
from sklearn.datasets import load_iris


def dataset_demo():
    # 获取数据集
    iris = load_iris()
    print("鸢尾花数据集\n", iris)
    print("查看数据集描述\n",iris["DESCR"])
    print("查看特征值的名字\n",iris['feature_names'])
    print("查看特征值\n",iris.data,iris.data.shape)
    return None


if __name__ == "__main__":
    dataset_demo()
```

2.1.3 数据集划分

机器学习的数据一般分为两个部分

* 训练数据：用于训练，构建模型 70%~80%

* 测试数据：在模型检测时使用，用于评估模型是否有效 20%~30%

  最常用的是train_test_split()函数，用来随机划分样本数据为训练集和测试集。

x_train, x_test,  y_train, y_test = train_test_split(data, label, test_size = 0.3, random_state = 7)

data：待划分样本数据，特征值
label：待划分样本数据的标签，目标值
test_size：测试数据占样本数据的比例，若整数则是测试数据数量
random_state: 设置随机数种子，保证每次都是同一个随机数。如果为0或者不填，则每次得到数据都不一样。
返回值的顺序依次是训练集特征值，测试集特征值，训练集目标值，测试机目标值

鸢尾花数据集

https://blog.csdn.net/Albert201605/article/details/82313139

* data*{ndarray, dataframe} of shape (150, 4)*

  The data matrix. If `as_frame=True`, `data` will be a pandas DataFrame. 属性数据，一个二维数组，对应多行特征值(属性值)，对应鸢尾花的四个属性的数据集，其实就是取整个表的前四列

* target: {ndarray, Series} of shape (150,)

the classification target. If `as_frame=True`, `target` will be a pandas Series. 种类数据或者说目标数据，对应鸢尾花的种类的数据集

* feature_names: list

  四个属性，分别是Sepal.Length（花萼长度），单位是cm;Sepal.Width（花萼宽度），单位是cm;Petal.Length（花瓣长度），单位是cm;Petal.Width（花瓣宽度），单位是cm;

* target_names: list

  三个种类，分别是Iris Setosa（山鸢尾）；Iris Versicolour（杂色鸢尾）；Iris Virginica（维吉尼亚鸢尾）。

* **frame: DataFrame of shape (150, 5)**

  Only present when `as_frame=True`. DataFrame with `data` and `target`.

* DESCR: str

  The full description of the dataset.描述

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


def dataset_demo():
    # 获取数据集
    iris = load_iris()
    
    print("鸢尾花数据集标签\n", iris.target)
    #鸢尾花共有4个属性，分别是花萼的长、花萼的宽、花瓣的长和花瓣的宽,分别是sepal length  sepal width，petal length，petal width 
    print("查看数据集描述\n", iris["DESCR"])
     # ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
    print("查看特征值的名字\n", iris['feature_names'])
    print("查看特征值\n", iris.data, iris.data.shape)

    # 数据集划分成训练集和测试集
    print("训练集特征值：")
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
    print(x_train,x_train.shape)
    return None


if __name__ == "__main__":
    dataset_demo()

2.2 特征工程

2.2.1 什么是特征工程

特征工程是使用专业背景指示和技巧处理数据，使得特征集在机器学习算法上发挥更好的作用的过程（会影响机器学习的效果）

2.2.2 特征工程的内容

特征抽取，特征预处理，特征降维

2.3特征抽取

2.3.1 概念

特征提取是将任意数据比如文本或图像转换为可用于机器学习的数字特征

字典特征提取
文本特征提取
图像特征提取
```
# 采用api
sklearn.feature_extraction
```

2.3.2字典特征提取

作用：对字典数据进行特征值化,比如三个类别就分别用001，010，100来表示，然后如果传进去的参数为ture，那就是用稀疏矩阵表示

sklearn.feature_extraction import DictVectorizer(sparse=True,....)  sparse -- 稀疏

from sklearn.feature_extraction import DictVectorizer
def dict_demo():
    data = [{'city': '北京', 'temperature': 100},{'city': '上海', 'temperature': 60},{'city': '深圳', 'temperature': 30}]
    #1、实例化一个转换器类，不转化为稀疏矩阵
    transfer = DictVectorizer(sparse=False)
    #把数据保存在data_new中
    data_new = transfer.fit_transform(data)
    print("data_new：\n", data_new)
    print("特征名字：\n",  transfer.get_feature_names())
    return None

会返回一个三行的矩阵表示三行数据，每行数据有四个值，前三个表示类，后一个表示温度值

2.3.3 文本特征提取

sklearn.feature_extraction.text.CountVectorizer

CountVectorizer语法

CountVectorizer(max_df=1.0,min_df=1,…)

           返回词频矩阵

CountVectorizer.fit_transform(X,y)

        X:文本或者包含文本字符串的可迭代对象

       返回值：返回sparse矩阵

CountVectorizer.inverse_transform(X)

       x:array数组或者sparse矩阵

返回值:转换之前数据格式

CountVectorizer.get_feature_names()

      返回值:单词列表

from sklearn.feature_extraction.text import CountVectorizer
 
 
def conuntvec():
    """
    对文本进行特征值化
    :return: None
    """
    #加停用词is，会把is去除特征值列表
    cv = CountVectorizer(stop_words=["is"])
 
    data = cv.fit_transform(["life is short,i like python",
                             "life is too long,i dislike python"])
    print(cv.get_feature_names())
    # 将sparse矩阵转换为·数组
    print(data.toarray())
    return None
 
if __name__ == '__main__':
    conuntvec()

结果：

['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']
[[0 1 1 1 0 1 1 0]
 [1 1 1 0 1 1 0 1]]

第一行，打印出统计所有文章当中所有的词，重复的只看做一次

注意：对于单个的英文字母直接进行放弃，不进行统计 (因为它是没有分类的依据的)

数据数组：类似于统计的次数，对每篇文章，在词的列表里面进行统计每个词出现的次数

数据数组的第一行，第一个小数组：对应的输入的数据，以逗号分隔开，

例如第一句话是：“life is short,i like python”, 对应词的列表，出现几次值就为几

2.3.4 中文特征提取

方法一：CountVectorizer：统计每个样本特征词出现的个数，stop_words停用词表

 
from sklearn.feature_extraction.text import CountVectorizer
import jieba
 
 
def count_Chinese_demo():
    data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，",
            "所以每个人不要放弃今天。", "我们看到的从很远星系来的光是在几百万年之前发出的，",
            "这样当我们看到宇宙时，我们是在看它的过去。", "如果只用一种方式了解某样事物，你就不会真正了解它。",
            "了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
    data_new=[ ]
    for sentence in data:
        data_new.append(" ".join(list(jieba.cut(sentence))))

    #实例化一个转换器类，把一种当作停用词，也就是不会以一种来划分
    transfer=CountVectorizer(stop_words=["一种"])

    #调用fit_transform
    data_final=transfer.fit_transform(data_new)

    print(data_new)
    print("data_new",data_final.toarray())
    print("特征名字",transfer.get_feature_names())


if __name__ == "__main__":
    count_Chinese_demo()

方法二：TfidVectorizer

TF-IDF思想：如果某个词或短语在一篇文章中出现的频率高，而且在其他文章中很少出现，则认为此词或短语具有很好的类别区分能力，适合用来分类。
TF-IDF作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度
词频tf：某一个给定的词语在该文件中的出现的频率
逆向文档频率idf：一个词语普遍重要性的度量，某一特定词的idf可以由总文件数目除以包含该词语的文件数目，再将得到的商取以10为底的对数得到，最终得出结果可以理解为重要程度
tf-idf=tf*idf

from sklearn.feature_extraction.text import CountVectorizer,TfidfVectorizer
def count_Chinese_demo():
    data = ["今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，",
            "所以每个人不要放弃今天。", "我们看到的从很远星系来的光是在几百万年之前发出的，",
            "这样当我们看到宇宙时，我们是在看它的过去。", "如果只用一种方式了解某样事物，你就不会真正了解它。",
            "了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
    data_new=[ ]
    for sentence in data:
        data_new.append(" ".join(list(jieba.cut(sentence))))

    #实例化一个转换器类，把一种当作停用词，也就是不会以一种来划分
    transfer=TfidfVectorizer(stop_words=["一种"])

    #调用fit_transform
    data_final=transfer.fit_transform(data_new)

    print(data_new)
    print("data_new",data_final.toarray())
    print("特征名字",transfer.get_feature_names())


if __name__ == "__main__":
    count_Chinese_demo()

2.4特征预处理

2.4.1基本概念

定义：特征预处理是通过一些转换函数将特征数据转换成更适合算法模型的特征数据的过程。
API：sklearn.preprocessing
为什么要进行归一化和标准化？

特征的单位或者大小相差较大，或者某特征的方差相比其他的特征大出几个数量级，容易影响支配目标的结果，使得一些算法无法学习到其他的特征。

2.4.2 归一化

定义

通过对原始数据进行变换把数据映射到（默认为[0,1]）之间

公式

x’=(x-min)/(max-min) x’’=x’*(mx-mi)+mi

作用于每一列，max为一列的最大值，min为一列的最小值，x的值为最终结果，mx，mi分别为指定区间值，默认为mx=1，mi=0

API

sklearn.preprocessing.MinMaxScaler(feature_range(0,1)…)

传递的参数array[样本的个数，特征的个数]

返回值：形状相同的array

from sklearn.preprocessing import MinMaxScaler
import pandas
def demo():
	# 获取数据
	data=pd.read_csv("xx.txt")
	#取所有行，取前三列
	data=data.iloc[:,:3]
	print(data)
	
	#实例化一个转换器类
	transfer=MinMaxScaler(feature_range=[2,3])
	
	# 调用fit_transform,利用转换器类把数据进行处理
	data_new=transfer.fit_transform(data)
	print(data_new)

2.4.3 标准化

定义

通过对原始数据进行变换把数据变换到均值为0，标准差为1范围内

公式

（x-平均值)/标准差

优势

标准差是衡量集中程度的
对于归一化来说，如果出现异常点，影响了最大值和最小值，那么结果显然会发生改变
对于标准化来说，如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响不大

API

函数：
scikit-learn.preprocessing.StandardScaler()

处理之后每列来说所有数据都聚集在均值0附近标准差差为1
StandardScaler.fit_transform(X,y)

X:numpy array格式的数据[n_samples,n_features]

返回值：转换后的形状相同的array

from sklearn.preprocessing import StandardScaler
 
 
def stand():
    """
    标准化缩放
    :return:None
    """
 
    std = StandardScaler()
 
    data = std.fit_transform([[1., -1., 3.],
                              [2., 4., 2.],
                              [4., 6., -1.]]
                             )
    print(data)
    return None
 
 
if __name__ == '__main__':
    stand()

#结果
[[-1.06904497 -1.35873244  0.98058068]
 [-0.26726124  0.33968311  0.39223227]
 [ 1.33630621  1.01904933 -1.37281295]]

2.5特征降维

2.5.1 定义

降维是指在某些特定的条件下，降低随机变量（特征）的个数，得到一组不相关主变量的过程

特征和特征相关性很强时降维方法

选取其中一个
加权就和
主成分分析

2.5.2特征选择

定义

数据中包含冗余或相关变量（或称特征、属性、指标等），旨在从原有特征中找出主要特征

方法

Filter过滤式方法：主要探究特征本身特点，特征与特征和目标值之间关联

方差选择法：低方差特征过滤

低方差特征过滤:sklearn.feature_selection.VarianceThreshold(threshold = 0.0)

返回值：训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差的特征，即删除所有样本中具有相同值的特征

X:numpy array格式的数据[n_samples,n_features]

from sklearn.feature_selection import VarianceThreshold

if __name__ == '__main__':
    data = [
        [1, 2, 3, 4, 5],
        [1, 7, 8, 9, 10],
        [1, 12, 13, 14, 15]
    ]
    # 示例化一个转化器类
    transfer = VarianceThreshold()  # `threshold` 用默认值 0
    # 调用 transfer.fit_transform
    data_final = transfer.fit_transform(data)
    print('返回结果为：', data_final)

'''
返回结果为： [[ 2  3  4  5]
 [ 7  8  9 10]
 [12 13 14 15]]
'''

相关系数：特征与特征之间的相关程度

api:from scipy.stats import pearsonr

参数说明

1）输入：x为特征，y为目标变量.
2）输出：r： 相关系数 [-1，1]之间，p-value: p值。
     注： p值越小，表示相关系数越显著，一般p值在500个样本以上时有较高的可靠性.

代码

from sklearn.datasets import make_regression
from scipy.stats import pearsonr
#样本数1000，特征值3，重要特征1
X,y = make_regression(n_samples=1000, n_features=3, n_informative=1, noise=100, random_state=9527)

#分别计算每个特征与标签的相关系数
p1 = pearsonr(X[:,0],y)
p2 = pearsonr(X[:,1],y)
p3 = pearsonr(X[:,2],y)
#打印
print(p1)
print(p2)
print(p3)

Embedded嵌入式：算法自动选择特征（特征与目标值之间的关联）
- 决策树：信息嫡、信息增益
- 正则化：L1，L2
- 深度学习：卷积

2.5.3 主成分分析

定义

将高维数据转化为低维数据的过程，这个过程可能会舍弃原有数据，创造新的变量。

作用

将数据维数压缩，尽可能降低原数据的维数，损失少量信息

应用

回归分析或者聚类分析当中

过程

找到一个合适的直线，通过一个矩阵运算得出主成分分析的结果

API

sklearn.decomposition.PCA(n_components=None)

将数据分解为较低维的空间
n_components:
- 小数：表示保留百分之多少的信息
- 整数：减少到多少特征
PCA.fit_transform(x)
- x传入参数：[n_sanples,n_features]

from sklearn.decomposition import PCA
def demo():
    data = [[2, 8, 4, 5], [3, 4, 1, 4], [6, 3, 9, 2]]
    transfer = PCA(n_components=2)
    data_new = transfer.fit_transform(data)
    print(data_new)


if __name__ == "__main__":
    demo()

案例：探究用户对物品类别的喜好细分降维

3.分类算法

3.1sklearn转换器和预估器

3.1.1 转换器-特征工程的父类

使用步骤

1.实例化一个转换器类Transformer

2.调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

fit：计算每一列的平均值和标准差
transform：把第一节计算出的结果带入到公式进行转换

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

概述

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

用于分类的估计器

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

用于回归的估计器：

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

用于无监督学习的估计器
```
sklearn.cluster.KMeans 聚类
```

使用

1.实例化一个estimator

2.estimator.fit(x_train,y_train) 把训练集的特征值和目标集的特征值传进来，做计算(调用完就有模型了)

3 模型评估

直接比较真实值和预测值

#获取生成的目标值
y_predict=estimator.predict(x_test)
# 比较生成的目标值和真实的目标值
y_test==y_predict

计算准确率

#把测试集的特征值和目标值都传进去，他会自动比较特征值计算出的结果和目标值的准确率
accuracy=estimator.score(x_test,y_test)

3.2KNN算法

3.2.1 概述

k-近邻算法核心思想

根据你的邻居推断出你的类别

原理

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

距离公式：欧氏距离、曼哈顿距离、明可夫斯基距离
k值取太小，容易受到异常点的影响，k值取太大，容易受到样本不均衡的影响
求距离之前要做无量纲化处理（标准化）

3.2.2 API

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
n_neighbors:k值
algorithm：{‘auto’,‘ball_tree’,‘kd_tree’,‘brute’}可选择计算最近邻居的算法

3.2.3 案例：鸢尾花种类预测

步骤

获取数据
数据集划分
特征工程-标准化
KNN模型进行训练
模型评估

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


def demo():
    """
    用knn算法对鸢尾花进行分类
    :return:
    """
    # 1获取数据
    iris = load_iris()

    # 2划分数据集
    # random_state就是为了保证程序每次运行都分割一样的训练集和测试集。否则，同样的算法模型在不同的训练集和测试集上的效果不一样
    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)
    # 需要用训练集的平均值和标准差对测试集的数据进行标准化,所以不需要再使用fit求一次标准差和平均值
    x_test = transfer.transform(x_test)

    # 4KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    # 把训练集的特征值和目标值传进去
    estimator.fit(x_train, y_train)
    # 5模型评估
    # 直接比较真实值和预测值
    y_predict=estimator.predict(x_test)
    print(y_predict)
    print(y_test==y_predict)

    # 计算准确率
    score=estimator.score(x_test,y_test)
    print(score)

    return None


if __name__ == "__main__":
    demo()

3.2.4 总结

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

3.3 模型选择与调优

3.3.1交叉验证

概念

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

为什么要交叉验证：为了让被评估得模型更加准确可信

3.3.2 超参数搜索-网格搜索

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

模型选择与调优API

sklearn.model_selection.GridSearchCV(estimator,param_grid=None,cv=None)

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

3.3.3 鸢尾花案例增加k值调优

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 demo():
    """
    用knn算法对鸢尾花进行分类，添加网格搜索和交叉验证
    :return:
    """
    # 1获取数据
    iris = load_iris()

    # 2划分数据集
    # random_state就是为了保证程序每次运行都分割一样的训练集和测试集。否则，同样的算法模型在不同的训练集和测试集上的效果不一样
    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)
    # 需要用训练集的平均值和标准差对测试集的数据进行标准化,所以不需要再使用fit求一次标准差和平均值
    x_test = transfer.transform(x_test)

    # 4KNN算法预估器
    estimator = KNeighborsClassifier()

    # 加入网格搜索和交叉验证
    param_dict = {"n_neighbors": [1, 3, 5, 7,9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)

    # 把训练集的特征值和目标值传进去
    estimator.fit(x_train, y_train)

    # 5模型评估
    # 直接比较真实值和预测值
    y_predict = estimator.predict(x_test)
    print(y_predict)
    print(y_test == y_predict)

    # 计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率", score)
    # 最佳的k值
    print("best_params:", estimator.best_params_)
    # 最好的结果
    print("best_soore", estimator.best_score_)
    # 最好的估计器 (取最佳参数的估计器)
    print("best_estimator", estimator.best_estimator_)
    # 交叉验证结果
    print("cv_results", estimator.cv_results_)

    return None


if __name__ == "__main__":
    demo()

3.3.4 案例：预测到facebook签到位置

3.3.5 总结

3.4朴素贝叶斯算法

3.4.1 概念

贝叶斯决策论：考虑如何基于这些概率和误判损失来选择最优的类别标记，就是计算一下属于哪个类别的概率最高，就把他当作这个类别

通过上述贝叶斯算法的基本公式可以写出贝叶斯算法的流程如下：

1）设x={a1,a2,…,am}为待分类项，其中a为x的一个特征属性

2）类别集合为C={y1,y2,…,yn}

3）分别计算P(y1|x),P(y2|x),…,P(yn|x)的值（贝叶斯公式）

4）如果P(yk|x)=max{P(y1|x),P(y2|x),…,P(yn|x)},那么认为x为yk类型

朴素贝叶斯：朴素（假设特征和特征之间相互独立）+贝叶斯算法（贝叶斯公式）
场景：文本分类

3.4.2 概率基础

联合概率：包含多个条件，且所有条件同时成立的概率p(AB)
条件概率：时间A在另一个时间B已经发生的条件下发生的概率p(A|B)
相互独立：p(AB)=p(A)p(B)

3.4.3贝叶斯公式

拉普拉斯平滑系数
- p(F1/C)=(Ni+a)/(N+am)
- a为指定系数一般为1，m为训练文档中统计出的特征词个数，Ni为China类词中出现Chinese的个数，N为整个文档出现这Chinese的个数

3.4.4 API

sklearn.naive_bayes.MultinomialNB(alpha=1.0)

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

3.4.5案例：20类新闻分类


from sklearn.model_selection import train_test_split

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


def demo():
    """
    用朴素贝叶斯算法对新闻进行分类
    :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.朴素贝叶斯算法预估器流程
    estimotor=MultinomialNB()
    estimotor.fit(x_train,y_train)

    #5.模型评估
    #直接比较真实值和预测值
    y_predict=estimotor.predict(x_test)
    print(y_predict)
    print(x_test==y_predict)

    #计算准确率
    score=estimotor.score(x_test,y_test)
    print(score)

if __name__ == "__main__":
    demo()

3.4.6总结

优点
- 朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率
- 对缺失的数据不太敏感，算法比较简单，常用于文本分类
- 分类准确度较高，速度快
缺点
- 由于使用了样本属性独立性的假设，所以如果特征属性有关联时效果不好

3.5 决策树

3.5.1 认识决策树

决策树是基于树结构来进行决策的
每个测试结果或是导出最终结论，或是导出进一步判断问题，其考虑范围是上次决策结果的限定范围之内
如何高效进行决策（取决于特征先后顺序）

3.5.2 决策树分类原理详解

信息论基础

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

信息的衡量-信息量-信息熵

信息增益：总信息熵-条件熵，比如g(D,年龄)=H(D)-H(D|年龄)

3.5.3 决策树API

sklearn.tree.DecisionTreeClassifier(criterion=‘gini’,max_deoth=None,random_state=None)
决策树分类器
criterion:默认是’gini’ 系数，也可以选择信息增益的熵’entropy’
max_depth:树的深度大小

random_state:随机数种子

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


def demo():
    """
    用决策树对鸢尾花进行分类
    :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.特征工程

    # 4.决策树预估器
    estimator = DecisionTreeClassifier(criterion="entropy")
    estimator.fit(x_train, y_train)

    # 5.模型评估
    # 直接比较真实值和预测值
    y_predict = estimator.predict(x_test)

    # 计算准确率
    score=estimator.score(x_test,y_test)
    print(score)


if __name__ == "__main__":
    demo()

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

获取数据
数据处理
	缺失值处理
	特征值->字典类型
准备好特征值 目标值
划分数据集
特征工程-字典特征抽取
决策树预估器流程
模型评估

3.5.5 决策树可视化

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


def demo():
    """
    用决策树对鸢尾花进行分类
    :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.特征工程

    # 4.决策树预估器
    estimator = DecisionTreeClassifier(criterion="entropy")
    estimator.fit(x_train, y_train)

    # 5.模型评估
    # 直接比较真实值和预测值
    y_predict = estimator.predict(x_test)

    # 计算准确率
    score=estimator.score(x_test,y_test)
    print(score)

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


if __name__ == "__main__":
    demo()

3.5.6 决策树总结

优点：

可视化-可解释能力强

缺点：

决策树学习设可以创建不能很好推广数据的过于复杂的树，称为过拟合

改进：

减枝cart算法(决策树API当中已经实现，随机森林参数调优有有关介绍)
随机森林

3.6随机森林

3.6.1集成学习方法

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

3.6.2随机森林

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

3.6.3 随机森林原理过程

两个随机

训练集随机-N个样本中随机有放回抽样N个

bootstrap 随机有放回抽样
特征随机-从M个特征中随机抽取m个特征 M>>m

3.6.4 API

3.6.5 随机森林预测案例

3.6.6 总结

在当前所有的分类算法中，具有极好的准确率
能够运行在大数据集上
处理具有高维特征的输入样本，而且不需要降维

标签：__,机器,学习,print,train,test,data,sklearn
来源： https://blog.csdn.net/timoraty/article/details/117907848

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9