机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证

机器学习基础

文章目录

      • 机器学习基础
      • 机器学习开发流程
      • 机器学习模型是什么
      • 机器学习算法分类 (监督学习,无监督学习)
    • sklearn 数据集
      • 数据集划分
      • sklearn 数据集接口介绍
    • 转化器和预估器
      • 转换器
      • 估计器
    • 小结
    • 分类算法-k近邻算法
      • sklearn k-近邻算法API
      • 算法实战:案例1 预测入住位置
        • 实例流程
        • 数据处理方式
        • 实例代码
        • k-近邻算法优缺点
      • 算法实战:案例12 通过k-近邻算法对生物物种进行分类——鸢尾花(load_iris)
    • 分类算法-朴素贝叶斯算法
      • 朴素贝叶斯-贝叶斯公式
      • 拉普拉斯平滑
      • sklearn朴素贝叶斯实现API
      • 朴素贝叶斯算法案例
        • 朴素贝叶斯案例流程
        • 实例代码
        • 朴素贝叶斯分类优缺点
    • 分类模型的评估
      • 混淆矩阵
      • 精确率(Precision)与召回率(Recall)
    • 模型的选择与调优
      • 交叉验证
      • 超参数搜索-网格搜索

  • 算法是核心,数据和计算是基础

机器学习开发流程

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第1张图片

机器学习模型是什么

  • 定义:通过一种映射关系将输入值到输出值
    机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第2张图片

机器学习算法分类 (监督学习,无监督学习)

  • 监督学习

    • 分类: k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络
    • 回归: 线性回归、岭回归
    • 标注: 隐马尔可夫模型 (不做要求)
  • 无监督学习

    • 聚类 k-means
  • 区别

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第3张图片

监督学习

  • 可以由输入数据中学到或建立一个模型,并依此模式推测新的结果。输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续的值(称为回归),或是输出是有限个离散值(称作分类)。

无监督学习

  • 可以由输入数据中学到或建立一个模型,并依此模式推测新的结果。输入数据是由输入特征值所组成。

分类问题

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第4张图片

  • 分类是监督学习的一个核心问题,在监督学习中,当输出变量取有限个离散值时,预测问题变成为分类问题。最基础的便是二分类问题,即判断是非,从两个类别中选择一个作为预测结果;

分类问题的应用

  • 分类在于根据其特性将数据“分门别类”,所以在许多领域都有广泛的应用
  • 在银行业务中,构建一个客户分类模型,按客户按照贷款风险的大小进行分类
  • 图像处理中,分类可以用来检测图像中是否有人脸出现,动物类别等
  • 手写识别中,分类可以用于识别手写的数字
  • 文本分类,这里的文本可以是新闻报道、网页、电子邮件、学术论文

回归问题

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第5张图片

  • 回归是监督学习的另一个重要问题。回归用于预测输入变量和输出变量之间的关系,输出是连续型的值。

回归问题的应用

  • 回归在多领域也有广泛的应用

  • 房价预测,根据某地历史房价数据,进行一个预测

  • 金融信息,每日股票走向

sklearn 数据集

数据集划分

  • 机器学习一般的数据集会划分为两个部分:

  • 训练数据:用于训练,构建模型

  • 测试数据:在模型检验时使用,用于评估模型是否有效

sklearn 数据集接口介绍

sklearn 数据集划分API

 sklearn.model_selection.train_test_split
sklearn.datasets
	加载获取流行数据集
	datasets.load_*()
		获取小规模数据集,数据包含在datasets里

datasets.fetch_*(data_home=None)
	获取大规模数据集,需要从网络上下载,函数的第一个参数是data_home,表示数据集下载的目录,默认是 ~/scikit_learn_data/


获取数据集返回的类型

load*和fetch*返回的数据类型datasets.base.Bunch(字典格式)

data:特征数据数组,是 [n_samples * n_features] 的二维 numpy.ndarray 数组

target:标签数组,是 n_samples 的一维 numpy.ndarray 数组

DESCR:数据描述

feature_names:特征名,新闻数据,手写数字、回归数据集没有

target_names:标签名,回归数据集没有

转化器和预估器

转换器

想一下之前做的特征工程的步骤?
1、实例化 (实例化的是一个转换器类(Transformer)) 
2、调用fit_transform(对于文档建立分类词频矩阵,不能同时调用)

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第6张图片

  • 转换器的作用:进行特征工程的父类(Transformer)调用:fit_transform来完成数据的处理

  • fit_transform = fit + transform

  • Fit(): Method calculates the parameters μ and σ and saves them as internal objects
    # 简单来说,就是求得训练集X的均值,方差,最大值,最小值,这些训练集X固有的属性。
    
  • transform(): Method using these calculated parameters apply the transformation to a particular dataset.
    # 解释:在fit的基础上,进行标准化,降维,归一化等操作(看具体用的是哪个工具,如PCA,StandardScaler等)。
    
  • fit_transform(): joins the fit() and transform() method for transformation of dataset.
    # 解释:fit_transform是fit和transform的组合,既包括了训练又包含了转换。
    # transform()和fit_transform()二者的功能都是对数据进行某种统一处理(比如标准化~N(0,1),将数据缩放(映射)到某个固定区间,归一化,正则化等)
    

实例化过程中需要注意的点,训练集x_train使用fit_transform,而测试集只需要使用transform,不用fit(因为它需要统一方差,均值这些标准)

估计器

  • 在sklearn中,估计器(estimator)是一个重要的角色,分类器和回归器都属于estimator,是一类实现了算法的API
  • 前面转换器我们有使用fit_transform和transform,而在预估器这里,我们只使用fit,而不用transform。
  • 模型评估:
    • 方法1:直接比对真实值和预测值 y_predict = estimator.predict(x_test)
    • 方法2:计算准确率,计算分数 accuracy = estimator.score(x_test, y_test)

1、用于分类的估计器:

  1. sklearn.neighbors k-近邻算法
  2. sklearn.naive_bayes 贝叶斯
  3. sklearn.linear_model.LogisticRegression 逻辑回归

2、用于回归的估计器:

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

估计器的工作流程

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第7张图片

小结

传统机器学习算法流程

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第8张图片

分类算法-k近邻算法

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第9张图片

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

  • 两个样本的距离可以通过如下公式计算,又叫欧式距离

    • 比如说,a(a1,a2,a3),b(b1,b2,b3)

    • √ ( ( 1 − 1 ) 2 + ( 2 − 2 ) 2 + ( 3 − 3 ) 2 ) √((1−1)^2+(2−2)^2+(3−3)^2 ) ((a1b1)2+(a2b2)2+(a3b3)2)

sklearn 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方法的值来决定最合适的算法。 (不同实现方式影响效率)

算法实战:案例1 预测入住位置

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第10张图片

实例流程

  • 1、数据集的处理
  • 2、分割数据集
  • 3、对数据集进行标准化
  • 4、estimator流程进行分类预测

数据处理方式

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第11张图片

实例代码

from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import pandas as pd

def knncls():
    """
    K-近邻预测用户签到位置
    :return:None
    """
    # 读取数据
    data = pd.read_csv("./data/FRelocation/train.csv/train.csv")

    # 处理数据
    # 1.缩小数据
    data = data.query("x > 1.0 &  x < 1.25 & y > 2.5 & y < 2.75")

    # 处理时间数据
    time_value = pd.to_datetime(data['time'], unit='s')

    # 把日期格式转换成字典格式
    time_value = pd.DatetimeIndex(time_value)

    # 构造一些特征
    data['day'] = time_value.day
    data['hour'] = time_value.hour
    data['weekday'] = time_value.weekday

    # 把时间戳特征删除
    data = data.drop(['time'], axis=1)

    # 吧签到数量少于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)]

    # 取出数据当中的特征值和目标值
    y = data['place_id']

    x = data.drop(['place_id'], axis=1)

    # 进行数据的分割训练集合测试集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)

    # 特征工程(标准化)
    std = StandardScaler()

    # 对测试集和训练集的特征值进行标准化
    x_train = std.fit_transform(x_train)

    x_test = std.transform(x_test)

    # 进行算法流程 # 超参数
    knn = KNeighborsClassifier()

    knn.fit(x_train, y_train)

    # 得出预测结果
    y_predict = knn.predict(x_train)

    print("预测的目标签到位置为:", y_predict)

    # 得出准确率
    print("预测的准确率:", knn.score(x_test, y_test))

    return None

if __name__ == "__main__":
    knncls()

结果为

预测的目标签到位置为: [4932578245 6424972551 3312463746 ... 6399991653 7803770431 6766324666]
预测的准确率: 0.4061465721040189

k-近邻算法优缺点

  • 优点
    • 简单,易于理解,易于实现,无需估计参数,无需训练
  • 缺点
    • 懒惰算法,对测试样本分类时的计算量大,内存开销大
    • 必须指定K值,K值选择不当则分类精度不能保证
  • 使用场景:小数据场景,几千~几万样本,具体场景具体业务去测试

算法实战:案例12 通过k-近邻算法对生物物种进行分类——鸢尾花(load_iris)

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第12张图片

实例代码

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

def knncls():
    """
    #通过k-近邻算法对生物物种进行分类——鸢尾花(load_iris)
    :return: None
    """
    li = load_iris()

    # 取出数据当中的特征值和目标值

    x = li["data"]
    y = li["target"]

    # 进行数据的分割训练集合测试集
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)

    # 特征工程(标准化)
    std = StandardScaler()

    # 对测试集和训练集的特征集进行标准化
    x_train = std.fit_transform(x_train)

    x_test = std.transform(x_test)

    # 进行算法流程 # 超参数
    knn = KNeighborsClassifier()

    knn.fit(x_train, y_train)

    # 得出预测结果
    y_predict = knn.predict(x_test)

    print("预测的目标签到位置为:", y_predict)

    # 得出准确率
    print("预测的准确率:", knn.score(x_test, y_test))

    return None

if __name__ == "__main__":
    knncls()

结果为

预测的目标签到位置为: [2 1 0 1 2 1 1 2 0 0 2 1 2 0 1 0 1 0 1 1 0 0 1 2 2 0 0 1 0 1 2 1 2 2 1 1 2 0]
预测的准确率: 0.8947368421052632

分类算法-朴素贝叶斯算法

概率基础

  • 联合概率:包含多个条件,且所有条件同时成立的概率 P(A,B)
  • 条件概率:就是事件A在另外一个事件B已经发生条件下的发生概率 P(A|B)
  • 特性:P(A1,A2|B) = P(A1|B)P(A2|B) 注意:此条件概率的成立,是由于A1,A2相互独立的结果

朴素贝叶斯-贝叶斯公式

  • (│)=((│)())/(())
  • 注:w为给定文档的特征值(频数统计,预测文档提供),c为文档类别

公式可以理解为
( │ 1 , 2 , … ) = ( ( 1 , 2 , … │ ) ( ) ) / ( ( 1 , 2 , … ) ) (│1,2,…)=((1,2,… │)())/((1,2,…)) P(CF1,F2,)=(P(F1,F2,C)P(C))/(P(F1,F2,))

  • 其中c可以是不同类别

  • P©:每个文档类别的概率(某文档类别词数/总文档词数)

  • P(W│C):给定类别下特征(被预测文档中出现的词)的概率

  • 计算方法:P(F1│C)=Ni/N (训练文档中去计算)

    Ni为该F1词在C类别所有文档中出现的次数

    N为所属类别C下的文档所有词出现的次数和

举例

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第13张图片

拉普拉斯平滑

  • 问题:从上面的例子我们得到娱乐概率为0,这是不合理的,如果词频列表里面有很多出现次数都为0,很可能计算结果都为零

  • 解决方法:拉普拉斯平滑系数

  • Font metrics not found for font: .

  • α为指定的系数一般为1,m为训练文档中统计出的特征词个数

sklearn朴素贝叶斯实现API

sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
# alpha:拉普拉斯平滑系数

朴素贝叶斯算法案例

  • sklearn20类新闻分类
  • 20个新闻组数据集包含20个主题的18000个新闻组帖子

朴素贝叶斯案例流程

  • 1、加载20类新闻数据,并进行分割
  • 2、生成文章特征词
  • 3、朴素贝叶斯estimator流程进行预估

实例代码

from sklearn.datasets import load_iris, fetch_20newsgroups, load_boston
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report

def naviebayes():
    """
    朴素贝叶斯进行文本分类
    :return: None
    """
    # 加载数据
    news = fetch_20newsgroups(subset='all')

    # 进行数据分割
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, test_size=0.25)

    # 对数据进行特征抽取
    tf = TfidfVectorizer()

    # 以训练集当中的词的列表进行每篇文章重要性统计['a','b','c','d']
    x_train = tf.fit_transform(x_train)

    print(tf.get_feature_names())

    x_test = tf.transform(x_test)

    # 进行朴素贝叶斯算法的预测
    mlt = MultinomialNB(alpha=1.0)

    print(x_train.toarray())

    mlt.fit(x_train, y_train)

    y_predict = mlt.predict(x_test)

    print("预测的文章类别为:", y_predict)

    # 得出准确率
    print("准确率为:", mlt.score(x_test, y_test))

    print("每个类别的精确率和召回率:", classification_report(y_test,y_predict,target_names=news.target_names))

    return None

if __name__ == "__main__":
    naviebayes()

朴素贝叶斯分类优缺点

  • 优点
    • 朴素贝叶斯模型发源于古典数学理论,有稳定的分类效率。
    • 对缺失数据不太敏感,算法也比较简单,常用于文本分类。
    • 分类准确度高,速度快
  • 缺点
    • 需要知道先验概率P(F1,F2,…|C),因此在某些时候会由于假设的先验模型的原因导致预测效果不佳。

分类模型的评估

estimator.score() #一般最常见使用的是准确率,即预测结果正确的百分比

混淆矩阵

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第14张图片

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

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第15张图片

其他分类标准,F1-score,反映了模型的稳健型

机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第16张图片

模型的选择与调优

交叉验证

  • 为了让被评估的模型更加准确可信
  • 交叉验证:将拿到的数据,分为训练和验证集。以下图为例:将数据分成5份,其中一份作为验证集。然后经过5次(组)的测试,每次都更换不同的验证集。即得到5组模型的结果,取平均值作为最终结果。又称5折交叉验证。
  • 机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第17张图片

超参数搜索-网格搜索

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

  • 机器学习 入门详细解析(一)开发流程\sklearn\k近邻算法\朴素贝叶斯算法\交叉验证_第18张图片

  • 超参数搜索-网格搜索API

  • sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
    对估计器的指定参数值进行详尽搜索
    
    estimator:估计器对象
    param_grid:估计器参数(dict){“n_neighbors”:[1,3,5]}
    cv:指定几折交叉验证
    fit:输入训练数据
    score:准确率
    
    结果分析:
    best_score_:在交叉验证中测试的最好结果
    best_estimator_:最好的参数模型
    cv_results_:每次交叉验证后的测试集准确率结果和训练集准确率结果
    
    
  • K-近邻网格搜索案例

  • from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.preprocessing import StandardScaler
    import pandas as pd
    
    def knncls():
        """
        K-近邻预测用户签到位置
        :return:None
        """
        # 读取数据
        data = pd.read_csv("./data/FBlocation/train.csv")
    
        # print(data.head(10))
    
        # 处理数据
        # 1、缩小数据,查询数据晒讯
        data = data.query("x > 1.0 &  x < 1.25 & y > 2.5 & y < 2.75")
    
        # 处理时间的数据
        time_value = pd.to_datetime(data['time'], unit='s')
    
        print(time_value)
    
        # 把日期格式转换成 字典格式
        time_value = pd.DatetimeIndex(time_value)
    
        # 构造一些特征
        data['day'] = time_value.day
        data['hour'] = time_value.hour
        data['weekday'] = time_value.weekday
    
        # 把时间戳特征删除
        data = data.drop(['time'], axis=1)
    
        print(data)
    
        # 把签到数量少于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)]
    
        # 取出数据当中的特征值和目标值
        y = data['place_id']
    
        x = data.drop(['place_id'], axis=1)
    
        # 进行数据的分割训练集合测试集
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)
    
        # 特征工程(标准化)
        std = StandardScaler()
    
        # 对测试集和训练集的特征值进行标准化
        x_train = std.fit_transform(x_train)
    
        x_test = std.transform(x_test)
    
        # 进行算法流程 # 超参数
        knn = KNeighborsClassifier()
    
        # 构造一些参数的值进行搜索
        param = {
           "n_neighbors": [3, 5, 10]}
    
        # 进行网格搜索
        gc = GridSearchCV(knn, param_grid=param, cv=2)
    
        gc.fit(x_train, y_train)
    
        # 预测准确率
        print("在测试集上准确率:", gc.score(x_test, y_test))
    
        print("在交叉验证当中最好的结果:", gc.best_score_)
    
        print("选择最好的模型是:", gc.best_estimator_)
    
        print("每个超参数每次交叉验证的结果:", gc.cv_results_)
    
        return None
    
    if __name__ == "__main__":
        knncls()
    

你可能感兴趣的