精华内容
下载资源
问答
  • 机器学习模型是什么 机器学习算法分类 明确几点问题 算法是核心,数据和计算是基础 找准定位 大部分复杂模型的算法设计都是算法工程师在做,而我们 > 分析很多的数据 > 分析具体的业务 > 应用常见的算法 >...

    一、机器学习基础

    在这里插入图片描述

    1.明确几点问题

    算法是核心,数据和计算是基础
    找准定位
    大部分复杂模型的算法设计都是算法工程师在做,而我们
    > 分析很多的数据
    > 分析具体的业务
    > 应用常见的算法
    > 特征工程、调参数、优化

    我们应该怎么做
    1.学会分析问题,使用机器学习算法的目的,想要算法完成何种任务
    2.掌握算法基本思想,学会对问题用相应的算法解决
    3.学会利用库或者框架解决问题

    2.机器学习算法的判别依据

    这两组数据的区别?
    在这里插入图片描述
    数据类型
    离散型数据:由记录不同类别个体的数目所得到的数据,又称计数数据,所有这些数据都是整数,而且不能再细分,也不能进一步提高他们的精确度。
    连续型数据:变量可以在某个范围内取任一数,即变量的取值可以是连续的,如,长度、时间、质量值等,这类整数通常是非整数,含有小数部分。

    数据类型的不同应用
    数据的类型将是机器学习模型不同问题不同处理的依据
    在这里插入图片描述

    3.机器学习算法分类

    • 监督学习
      分类: k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络
      回归: 线性回归、岭回归
      标注: 隐马尔可夫模型 (不做要求)
    • 无监督学习
      聚类: k-means
      在这里插入图片描述
      监督学习
      监督学习,可以由输入数据中学到或建立一个模型,并依此模式推测新的结
      果。输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续
      的值(称为回归),或是输出是有限个离散值(称作分类)。
      无监督学习
      无监督学习(英语:Supervised learning),可以由输入数据中学到或建立一
      个模型,并依此模式推测新的结果。输入数据是由输入特征值所组成。

    4.机器学习开发流程

    在这里插入图片描述

    二、机器学习算法

    • 算法
      1、sklearn数据集与估计器
      2、分类算法-k近邻算法
      3、k-近邻算法实例
      4、分类模型的评估
      5、分类算法-朴素贝叶斯算法
      6、朴素贝叶斯算法实例
      7、模型的选择与调优
      8、决策树与随机森林

    1.sklearn数据集

    (1)数据集划分

    机器学习一般的数据集会划分为两个部分:
    训练数据:用于训练,构建模型
    测试数据:在模型检验时使用,用于评估模型是否有效

    (2)sklearn数据集接口介绍

    sklearn数据集划分API
    sklearn.model_selection.train_test_split

    scikit-learn数据集API介绍
    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:标签名,回归数据集没有

    (3)sklearn分类数据集

    sklearn.datasets.load_iris() 加载并返回鸢尾花数据集
    在这里插入图片描述

    from sklearn.datasets import load_iris
    
    # 获取小规模数据
    li = load_iris()
    # 获取特征值
    print(li.data)
    '''
    [[5.1 3.5 1.4 0.2]
     [4.9 3.  1.4 0.2]
     [4.7 3.2 1.3 0.2]
     ...
     [6.5 3.  5.2 2. ]
     [6.2 3.4 5.4 2.3]
     [5.9 3.  5.1 1.8]] '''
    # 获取目标值
    print(li.target)
    '''
    [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
     0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
     1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
     2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
     2 2]'''
    # 获取描述信息
    print(li.DESCR)
    '''
    .. _iris_dataset:
    
    Iris plants dataset
    --------------------
    
    **Data Set Characteristics:**
    
        :Number of Instances: 150 (50 in each of three classes)
        :Number of Attributes: 4 numeric, predictive attributes and the class
        :Attribute Information:
            - sepal length in cm
            - sepal width in cm
            - petal length in cm
            - petal width in cm
            - class:
                    - Iris-Setosa
                    - Iris-Versicolour
                    - Iris-Virginica
                    
        :Summary Statistics:
    
        ============== ==== ==== ======= ===== ====================
                        Min  Max   Mean    SD   Class Correlation
        ============== ==== ==== ======= ===== ====================
        sepal length:   4.3  7.9   5.84   0.83    0.7826
        sepal width:    2.0  4.4   3.05   0.43   -0.4194
        petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)
        petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)
        ============== ==== ==== ======= ===== ====================
    
        :Missing Attribute Values: None
        :Class Distribution: 33.3% for each of 3 classes.
        :Creator: R.A. Fisher
        :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)
        :Date: July, 1988
    '''
    # 获取特征名
    print(li.feature_names)
    '''
    ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']'''
    # 获取标签名
    print(li.target_names)
    '''
    ['setosa' 'versicolor' 'virginica']
    '''
    

    sklearn.datasets.load_digits()加载并返回数字数据集
    在这里插入图片描述

    from sklearn.datasets import load_digits
    
    # 获取小规模数据
    li = load_digits()
    # 获取特征值
    # print(li.data)
    '''
    [[ 0.  0.  5. ...  0.  0.  0.]
     [ 0.  0.  0. ... 10.  0.  0.]
     [ 0.  0.  0. ... 16.  9.  0.]
     ...
     [ 0.  0.  1. ...  6.  0.  0.]
     [ 0.  0.  2. ... 12.  0.  0.]
     [ 0.  0. 10. ... 12.  1.  0.]]
    '''
    # 获取目标值
    # print(li.target)
    '''
    [0 1 2 ... 8 9 8]'''
    # 获取描述信息
    # print(li.DESCR)
    '''
    .. _digits_dataset:
    
    Optical recognition of handwritten digits dataset
    --------------------------------------------------
    
    **Data Set Characteristics:**
    
        :Number of Instances: 1797
        :Number of Attributes: 64
        :Attribute Information: 8x8 image of integer pixels in the range 0..16.
        :Missing Attribute Values: None
        :Creator: E. Alpaydin (alpaydin '@' boun.edu.tr)
        :Date: July; 1998'''
    # 获取特征名
    # print(li.feature_names)
    '''
    ['pixel_0_0', 'pixel_0_1', 'pixel_0_2', 'pixel_0_3', 'pixel_0_4', 'pixel_0_5', 'pixel_0_6', 'pixel_0_7', 'pixel_1_0', 'pixel_1_1', 'pixel_1_2', 'pixel_1_3', 'pixel_1_4', 'pixel_1_5', 'pixel_1_6', 'pixel_1_7', 'pixel_2_0', 'pixel_2_1', 'pixel_2_2', 'pixel_2_3', 'pixel_2_4', 'pixel_2_5', 'pixel_2_6', 'pixel_2_7', 'pixel_3_0', 'pixel_3_1', 'pixel_3_2', 'pixel_3_3', 'pixel_3_4', 'pixel_3_5', 'pixel_3_6', 'pixel_3_7', 'pixel_4_0', 'pixel_4_1', 'pixel_4_2', 'pixel_4_3', 'pixel_4_4', 'pixel_4_5', 'pixel_4_6', 'pixel_4_7', 'pixel_5_0', 'pixel_5_1', 'pixel_5_2', 'pixel_5_3', 'pixel_5_4', 'pixel_5_5', 'pixel_5_6', 'pixel_5_7', 'pixel_6_0', 'pixel_6_1', 'pixel_6_2', 'pixel_6_3', 'pixel_6_4', 'pixel_6_5', 'pixel_6_6', 'pixel_6_7', 'pixel_7_0', 'pixel_7_1', 'pixel_7_2', 'pixel_7_3', 'pixel_7_4', 'pixel_7_5', 'pixel_7_6', 'pixel_7_7']'''
    # 获取标签名
    print(li.target_names)
    '''
    [0 1 2 3 4 5 6 7 8 9]'''
    

    数据集进行分割
    sklearn.model_selection.train_test_split(*arrays,**options)
    x 数据集的特征值
    y 数据集的标签值
    test_size 测试集的大小,一般为float
    random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
    return 训练集特征值,测试集特征值,训练标签,测试标签(默认随机取)

    用于分类的大数据集
    sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)
    subset: ‘train’或者’test’,‘all’,可选,选择要加载的数据集.训练集的“训练”,测试集的“测试”,两者的“全部”

    # 数据集进行分割
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.datasets import fetch_20newsgroups
    
    li = load_iris()
    
    # train 训练集     test 测试集
    x_train, x_test, y_train, y_test = train_test_split(li.data, li.target, test_size=0.25)
    
    # print("训练集特征值和目标值", x_train, y_train)
    '''
    训练集特征值和目标值 [[6.7 3.3 5.7 2.1]
     [5.5 2.4 3.7 1. ]
     [5.4 3.9 1.7 0.4]
     ...
      [7.2 3.2 6.  1.8]
     [6.3 2.7 4.9 1.8]
     [4.9 3.1 1.5 0.1]] [2 1 0 1 0 2 1 0 0 1 1 2 0 0 2 1 0 1 0 0 0 2 1 0 1 2 1 0 0 1 2 2 1 0 1 1 0
     1 2 0 1 0 1 1 1 2 0 0 1 1 2 1 2 1 0 1 0 1 0 0 0 0 0 2 2 0 1 0 2 1 2 0 1 0
     2 1 2 2 2 2 0 2 1 2 0 2 2 1 2 2 0 1 2 1 1 2 2 1 2 2 0 2 1 0 2 2 1 1 0 2 2
     0]'''
    # print("测试集特征值和目标值", x_test, y_test)
    '''
    测试集特征值和目标值 [[6.7 3.1 4.7 1.5]
     [6.3 3.4 5.6 2.4]
     [5.1 3.7 1.5 0.4]
     ...
      [6.6 3.  4.4 1.4]
     [5.9 3.2 4.8 1.8]
     [6.9 3.2 5.7 2.3]] [1 2 0 0 2 2 1 1 0 0 2 2 0 2 2 2 2 1 0 0 1 0 1 2 1 0 2 1 1 0 0 2 1 2 0 1 1
     2]'''
    news = fetch_20newsgroups(subset='all')
    print(news.data)
    
    

    (4)sklearn回归数据集

    sklearn.datasets.load_boston() 加载并返回波士顿房价数据集
    在这里插入图片描述

    # 回归数据集
    from sklearn.datasets import load_boston
    
    lb = load_boston()
    
    # 获取特征值
    print(lb.data)
    '''
    [[6.3200e-03 1.8000e+01 2.3100e+00 ... 1.5300e+01 3.9690e+02 4.9800e+00]
     [2.7310e-02 0.0000e+00 7.0700e+00 ... 1.7800e+01 3.9690e+02 9.1400e+00]
     [2.7290e-02 0.0000e+00 7.0700e+00 ... 1.7800e+01 3.9283e+02 4.0300e+00]
     ...
     [6.0760e-02 0.0000e+00 1.1930e+01 ... 2.1000e+01 3.9690e+02 5.6400e+00]
     [1.0959e-01 0.0000e+00 1.1930e+01 ... 2.1000e+01 3.9345e+02 6.4800e+00]
     [4.7410e-02 0.0000e+00 1.1930e+01 ... 2.1000e+01 3.9690e+02 7.8800e+00]]
    '''
    # 获取目标值
    print(lb.target)
    '''
    [24.  21.6 34.7 33.4 36.2 28.7 22.9 27.1 16.5 18.9 15.  18.9 21.7 20.4
     18.2 19.9 23.1 17.5 20.2 18.2 13.6 19.6 15.2 14.5 15.6 13.9 16.6 14.8
     18.4 21.  12.7 14.5 13.2 13.1 13.5 18.9 20.  21.  24.7 30.8 34.9 26.6
     25.3 24.7 21.2 19.3 20.  16.6 14.4 19.4 19.7 20.5 25.  23.4 18.9 35.4
     24.7 31.6 23.3 19.6 18.7 16.  22.2 25.  33.  23.5 19.4 22.  17.4 20.9
     24.2 21.7 22.8 23.4 24.1 21.4 20.  20.8 21.2 20.3 28.  23.9 24.8 22.9
     23.9 26.6 22.5 22.2 23.6 28.7 22.6 22.  22.9 25.  20.6 28.4 21.4 38.7
     43.8 33.2 27.5 26.5 18.6 19.3 20.1 19.5 19.5 20.4 19.8 19.4 21.7 22.8
     18.8 18.7 18.5 18.3 21.2 19.2 20.4 19.3 22.  20.3 20.5 17.3 18.8 21.4
     15.7 16.2 18.  14.3 19.2 19.6 23.  18.4 15.6 18.1 17.4 17.1 13.3 17.8
     14.  14.4 13.4 15.6 11.8 13.8 15.6 14.6 17.8 15.4 21.5 19.6 15.3 19.4
     17.  15.6 13.1 41.3 24.3 23.3 27.  50.  50.  50.  22.7 25.  50.  23.8
     23.8 22.3 17.4 19.1 23.1 23.6 22.6 29.4 23.2 24.6 29.9 37.2 39.8 36.2
     37.9 32.5 26.4 29.6 50.  32.  29.8 34.9 37.  30.5 36.4 31.1 29.1 50.
     33.3 30.3 34.6 34.9 32.9 24.1 42.3 48.5 50.  22.6 24.4 22.5 24.4 20.
     21.7 19.3 22.4 28.1 23.7 25.  23.3 28.7 21.5 23.  26.7 21.7 27.5 30.1
     44.8 50.  37.6 31.6 46.7 31.5 24.3 31.7 41.7 48.3 29.  24.  25.1 31.5
     23.7 23.3 22.  20.1 22.2 23.7 17.6 18.5 24.3 20.5 24.5 26.2 24.4 24.8
     29.6 42.8 21.9 20.9 44.  50.  36.  30.1 33.8 43.1 48.8 31.  36.5 22.8
     30.7 50.  43.5 20.7 21.1 25.2 24.4 35.2 32.4 32.  33.2 33.1 29.1 35.1
     45.4 35.4 46.  50.  32.2 22.  20.1 23.2 22.3 24.8 28.5 37.3 27.9 23.9
     21.7 28.6 27.1 20.3 22.5 29.  24.8 22.  26.4 33.1 36.1 28.4 33.4 28.2
     22.8 20.3 16.1 22.1 19.4 21.6 23.8 16.2 17.8 19.8 23.1 21.  23.8 23.1
     20.4 18.5 25.  24.6 23.  22.2 19.3 22.6 19.8 17.1 19.4 22.2 20.7 21.1
     19.5 18.5 20.6 19.  18.7 32.7 16.5 23.9 31.2 17.5 17.2 23.1 24.5 26.6
     22.9 24.1 18.6 30.1 18.2 20.6 17.8 21.7 22.7 22.6 25.  19.9 20.8 16.8
     21.9 27.5 21.9 23.1 50.  50.  50.  50.  50.  13.8 13.8 15.  13.9 13.3
     13.1 10.2 10.4 10.9 11.3 12.3  8.8  7.2 10.5  7.4 10.2 11.5 15.1 23.2
      9.7 13.8 12.7 13.1 12.5  8.5  5.   6.3  5.6  7.2 12.1  8.3  8.5  5.
     11.9 27.9 17.2 27.5 15.  17.2 17.9 16.3  7.   7.2  7.5 10.4  8.8  8.4
     16.7 14.2 20.8 13.4 11.7  8.3 10.2 10.9 11.   9.5 14.5 14.1 16.1 14.3
     11.7 13.4  9.6  8.7  8.4 12.8 10.5 17.1 18.4 15.4 10.8 11.8 14.9 12.6
     14.1 13.  13.4 15.2 16.1 17.8 14.9 14.1 12.7 13.5 14.9 20.  16.4 17.7
     19.5 20.2 21.4 19.9 19.  19.1 19.1 20.1 19.9 19.6 23.2 29.8 13.8 13.3
     16.7 12.  14.6 21.4 23.  23.7 25.  21.8 20.6 21.2 19.1 20.6 15.2  7.
      8.1 13.6 20.1 21.8 24.5 23.1 19.7 18.3 21.2 17.5 16.8 22.4 20.6 23.9
     22.  11.9]'''
    print(lb.DESCR)
    '''
    .. _boston_dataset:
    
    Boston house prices dataset
    ---------------------------
    
    **Data Set Characteristics:**  
    
        :Number of Instances: 506 
    
        :Number of Attributes: 13 numeric/categorical predictive. Median Value (attribute 14) is usually the target.
    
        :Attribute Information (in order):
            - CRIM     per capita crime rate by town
            - ZN       proportion of residential land zoned for lots over 25,000 sq.ft.
            - INDUS    proportion of non-retail business acres per town
            - CHAS     Charles River dummy variable (= 1 if tract bounds river; 0 otherwise)
            - NOX      nitric oxides concentration (parts per 10 million)
            - RM       average number of rooms per dwelling
            - AGE      proportion of owner-occupied units built prior to 1940
            - DIS      weighted distances to five Boston employment centres
            - RAD      index of accessibility to radial highways
            - TAX      full-value property-tax rate per $10,000
            - PTRATIO  pupil-teacher ratio by town
            - B        1000(Bk - 0.63)^2 where Bk is the proportion of blacks by town
            - LSTAT    % lower status of the population
            - MEDV     Median value of owner-occupied homes in $1000's
    
        :Missing Attribute Values: None
    
        :Creator: Harrison, D. and Rubinfeld, D.L.
    
    This is a copy of UCI ML housing dataset.
    https://archive.ics.uci.edu/ml/machine-learning-databases/housing/
    '''
    

    sklearn.datasets.load_diabetes()加载和返回糖尿病数据集
    在这里插入图片描述

    # 回归数据集
    from sklearn.datasets import load_diabetes
    
    lb = load_diabetes()
    
    # 获取特征值
    print(lb.data)
    '''
    [[ 0.03807591  0.05068012  0.06169621 ... -0.00259226  0.01990842
      -0.01764613]
     [-0.00188202 -0.04464164 -0.05147406 ... -0.03949338 -0.06832974
      -0.09220405]
     [ 0.08529891  0.05068012  0.04445121 ... -0.00259226  0.00286377
      -0.02593034]
     ...
     [ 0.04170844  0.05068012 -0.01590626 ... -0.01107952 -0.04687948
       0.01549073]
     [-0.04547248 -0.04464164  0.03906215 ...  0.02655962  0.04452837
      -0.02593034]
     [-0.04547248 -0.04464164 -0.0730303  ... -0.03949338 -0.00421986
       0.00306441]]
    '''
    # 获取目标值
    print(lb.target)
    '''
    [151.  75. 141. 206. 135.  97. 138.  63. 110. 310. 101.  69. 179. 185.
     118. 171. 166. 144.  97. 168.  68.  49.  68. 245. 184. 202. 137.  85.
     131. 283. 129.  59. 341.  87.  65. 102. 265. 276. 252.  90. 100.  55.
      61.  92. 259.  53. 190. 142.  75. 142. 155. 225.  59. 104. 182. 128.
      52.  37. 170. 170.  61. 144.  52. 128.  71. 163. 150.  97. 160. 178.
      48. 270. 202. 111.  85.  42. 170. 200. 252. 113. 143.  51.  52. 210.
      65. 141.  55. 134.  42. 111.  98. 164.  48.  96.  90. 162. 150. 279.
      92.  83. 128. 102. 302. 198.  95.  53. 134. 144. 232.  81. 104.  59.
     246. 297. 258. 229. 275. 281. 179. 200. 200. 173. 180.  84. 121. 161.
      99. 109. 115. 268. 274. 158. 107.  83. 103. 272.  85. 280. 336. 281.
     118. 317. 235.  60. 174. 259. 178. 128.  96. 126. 288.  88. 292.  71.
     197. 186.  25.  84.  96. 195.  53. 217. 172. 131. 214.  59.  70. 220.
     268. 152.  47.  74. 295. 101. 151. 127. 237. 225.  81. 151. 107.  64.
     138. 185. 265. 101. 137. 143. 141.  79. 292. 178.  91. 116.  86. 122.
      72. 129. 142.  90. 158.  39. 196. 222. 277.  99. 196. 202. 155.  77.
     191.  70.  73.  49.  65. 263. 248. 296. 214. 185.  78.  93. 252. 150.
      77. 208.  77. 108. 160.  53. 220. 154. 259.  90. 246. 124.  67.  72.
     257. 262. 275. 177.  71.  47. 187. 125.  78.  51. 258. 215. 303. 243.
      91. 150. 310. 153. 346.  63.  89.  50.  39. 103. 308. 116. 145.  74.
      45. 115. 264.  87. 202. 127. 182. 241.  66.  94. 283.  64. 102. 200.
     265.  94. 230. 181. 156. 233.  60. 219.  80.  68. 332. 248.  84. 200.
      55.  85.  89.  31. 129.  83. 275.  65. 198. 236. 253. 124.  44. 172.
     114. 142. 109. 180. 144. 163. 147.  97. 220. 190. 109. 191. 122. 230.
     242. 248. 249. 192. 131. 237.  78. 135. 244. 199. 270. 164.  72.  96.
     306.  91. 214.  95. 216. 263. 178. 113. 200. 139. 139.  88. 148.  88.
     243.  71.  77. 109. 272.  60.  54. 221.  90. 311. 281. 182. 321.  58.
     262. 206. 233. 242. 123. 167.  63. 197.  71. 168. 140. 217. 121. 235.
     245.  40.  52. 104. 132.  88.  69. 219.  72. 201. 110.  51. 277.  63.
     118.  69. 273. 258.  43. 198. 242. 232. 175.  93. 168. 275. 293. 281.
      72. 140. 189. 181. 209. 136. 261. 113. 131. 174. 257.  55.  84.  42.
     146. 212. 233.  91. 111. 152. 120.  67. 310.  94. 183.  66. 173.  72.
      49.  64.  48. 178. 104. 132. 220.  57.]
    '''
    print(lb.DESCR)
    '''
    .. _diabetes_dataset:
    
    Diabetes dataset
    ----------------
    
    Ten baseline variables, age, sex, body mass index, average blood
    pressure, and six blood serum measurements were obtained for each of n =
    442 diabetes patients, as well as the response of interest, a
    quantitative measure of disease progression one year after baseline.
    
    **Data Set Characteristics:**
    
      :Number of Instances: 442
    
      :Number of Attributes: First 10 columns are numeric predictive values
    
      :Target: Column 11 is a quantitative measure of disease progression one year after baseline
    
      :Attribute Information:
          - age     age in years
          - sex
          - bmi     body mass index
          - bp      average blood pressure
          - s1      tc, T-Cells (a type of white blood cells)
          - s2      ldl, low-density lipoproteins
          - s3      hdl, high-density lipoproteins
          - s4      tch, thyroid stimulating hormone
          - s5      ltg, lamotrigine
          - s6      glu, blood sugar level
    
    Note: Each of these 10 feature variables have been mean centered and scaled by the standard deviation times `n_samples` (i.e. the sum of squares of each column totals 1).
    
    Source URL:
    https://www4.stat.ncsu.edu/~boos/var.select/diabetes.html
    
    For more information see:
    Bradley Efron, Trevor Hastie, Iain Johnstone and Robert Tibshirani (2004) "Least Angle Regression," Annals of Statistics (with discussion), 407-499.
    (https://web.stanford.edu/~hastie/Papers/LARS/LeastAngle_2002.pdf)
    '''
    

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

    fit_taransform 输入数据  直接转换
    fit  输入数据  不转换
    taransform    进行数据转换
    

    在这里插入图片描述

    • 估计器
      在sklearn中,估计器(estimator)是一个重要的角色,分类器和回归器都属于estimator,是一类实现了算法的API
      用于分类的估计器
      sklearn.neighbors         k-近邻算法
      sklearn.naive_bayes         贝叶斯
      sklearn.linear_model.LogisticRegression         逻辑回归
      用于回归的估计器
      sklearn.linear_model.LinearRegression         线性回归
      sklearn.linear_model.Ridge         岭回归

    在这里插入图片描述

    2.K-近邻算法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    2.1 k近邻算法(KNN)

    定义:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某
    一个类别,则该样本也属于这个类别。
    来源:KNN算法最早是由Cover和Hart提出的一种分类算法

    计算距离公式
    两个样本的距离可以通过如下公式计算,又叫欧式距离
    比如说,a(a1,a2,a3),b(b1,b2,b3)
    在这里插入图片描述
    k-近邻算法API
    sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
    > n_neighbors:int,可选(默认= 5),k_neighbors查询默认使用的邻居数,如果k值等于6的话,两个
    特征值出现的概率相等怎么办?
    > algorithm:{‘auto’,‘ball_tree’,‘kd_tree’,‘brute’},可选用于计算最近邻居的算法:'ball_tree’将会使
    用 BallTree,'kd_tree’将使用 KDTree。'auto’将尝试根据传递给fit方法的值来决定最合适的算法。
    (不同实现方式影响效率)

    2.2 k近邻算法实例-预测入住位置

    在这里插入图片描述
    档案说明
    train.csv,test.csv
    row_id:签到事件的ID
    xy:坐标
    精度:位置精度
    时间:时间戳
    place_id:商家的ID,这是您要预测
    的目标
    sample_submission.csv-带有随机预测
    的正确格式的样本提交文件

    数据处理:
    (1)将x,y缩小
    (2)时间戳进行转换(年、月、日、时、分、秒),作为新特征
    (3)删除少于指定签到人数的位置

    问题
    1.k值取多大?有什么影响?
    k值取很小:容易受异常点影响
    k值取很大:容易受最近数据太多导致比例变化
    2.性能问题?
    K-近邻算法
    k-近邻算法优缺点
    优点:简单,易于理解,易于实现,无需估计参数,无需训练
    缺点:懒惰算法,对测试样本分类时的计算量大,内存开销大必须指定K值,K值选择不当则分类精度不能保证

    import pandas as pd
    from sklearn.model_selection import train_test_split
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.preprocessing import StandardScaler
    
    def nkkcls():
        """
        K-近邻预测用户签到位置
        :return: None
        """
    
        data = pd.read_csv('./train.csv')
    
        # print(data.head(10))  # sql语句里面的where条件 缩小数据
        '''
           row_id       x       y  accuracy    time    place_id
        0       0  0.7941  9.0809        54  470702  8523065625
        1       1  5.9567  4.7968        13  186555  1757726713
        2       2  8.3078  7.0407        74  322648  1137537235
        3       3  7.3665  2.5165        65  704587  6567393236
        4       4  4.0961  1.1307        31  472130  7440663949
        5       5  3.8099  1.9586        75  178065  6289802927
        6       6  6.3336  4.3720        13  666829  9931249544
        7       7  5.7409  6.7697        85  369002  5662813655
        8       8  4.3114  6.9410         3  166384  8471780938
        9       9  6.3414  0.0758        65  400060  1253803156'''
    
        data = data.query('x > 1.0 & x < 1.25 & y > 2.5 & y<2.75')
        # print(data)
        '''
                    row_id       x       y  accuracy    time    place_id
        600            600  1.2214  2.7023        17   65380  6683426742
        957            957  1.1832  2.6891        58  785470  6683426742
        4345          4345  1.1935  2.6550        11  400082  6889790653
        4735          4735  1.1452  2.6074        49  514983  6822359752
        5580          5580  1.0089  2.7287        19  732410  1527921905
        ...            ...     ...     ...       ...     ...         ...
        29100203  29100203  1.0129  2.6775        12   38036  3312463746
        29108443  29108443  1.1474  2.6840        36  602524  3533177779
        29109993  29109993  1.0240  2.7238        62  658994  6424972551
        29111539  29111539  1.2032  2.6796        87  262421  3533177779
        29112154  29112154  1.1070  2.5419       178  687667  4932578245
        
        [17710 rows x 6 columns]'''
        # 处理时间
        time_value = pd.to_datetime(data['time'],unit='s')
        # print(time_value)
        '''
        600        1970-01-01 18:09:40
        957        1970-01-10 02:11:10
        4345       1970-01-05 15:08:02
        4735       1970-01-06 23:03:03
        5580       1970-01-09 11:26:50
                           ...        
        29100203   1970-01-01 10:33:56
        29108443   1970-01-07 23:22:04
        29109993   1970-01-08 15:03:14
        29111539   1970-01-04 00:53:41
        29112154   1970-01-08 23:01:07
        Name: time, Length: 17710, dtype: datetime64[ns]'''
        time_value = pd.DatetimeIndex(time_value)
        # print(time_value)
        '''
        DatetimeIndex(['1970-01-01 18:09:40', '1970-01-10 02:11:10',
                       '1970-01-05 15:08:02', '1970-01-06 23:03:03',
                       '1970-01-09 11:26:50', '1970-01-02 16:25:07',
                       '1970-01-04 15:52:57', '1970-01-01 10:13:36',
                       '1970-01-09 15:26:06', '1970-01-08 23:52:02',
                       ...
                       '1970-01-07 10:03:36', '1970-01-09 11:44:34',
                       '1970-01-04 08:07:44', '1970-01-04 15:47:47',
                       '1970-01-08 01:24:11', '1970-01-01 10:33:56',
                       '1970-01-07 23:22:04', '1970-01-08 15:03:14',
                       '1970-01-04 00:53:41', '1970-01-08 23:01:07'],
                      dtype='datetime64[ns]', name='time', length=17710, freq=None)
        '''
        data['day'] = time_value.day
        data['hour'] = time_value.hour
        data['weekday'] = time_value.weekday
        # print(data)
        '''
                    row_id       x       y  accuracy  ...    place_id  day  hour  weekday
        600            600  1.2214  2.7023        17  ...  6683426742    1    18        3
        957            957  1.1832  2.6891        58  ...  6683426742   10     2        5
        4345          4345  1.1935  2.6550        11  ...  6889790653    5    15        0
        4735          4735  1.1452  2.6074        49  ...  6822359752    6    23        1
        5580          5580  1.0089  2.7287        19  ...  1527921905    9    11        4
        ...            ...     ...     ...       ...  ...         ...  ...   ...      ...
        29100203  29100203  1.0129  2.6775        12  ...  3312463746    1    10        3
        29108443  29108443  1.1474  2.6840        36  ...  3533177779    7    23        2
        29109993  29109993  1.0240  2.7238        62  ...  6424972551    8    15        3
        29111539  29111539  1.2032  2.6796        87  ...  3533177779    4     0        6
        29112154  29112154  1.1070  2.5419       178  ...  4932578245    8    23        3
        
        [17710 rows x 9 columns]'''
        data = data.drop(['time'],axis=1)
        # print(data)
        '''
                    row_id       x       y  accuracy    place_id  day  hour  weekday
        600            600  1.2214  2.7023        17  6683426742    1    18        3
        957            957  1.1832  2.6891        58  6683426742   10     2        5
        4345          4345  1.1935  2.6550        11  6889790653    5    15        0
        4735          4735  1.1452  2.6074        49  6822359752    6    23        1
        5580          5580  1.0089  2.7287        19  1527921905    9    11        4
        ...            ...     ...     ...       ...         ...  ...   ...      ...
        29100203  29100203  1.0129  2.6775        12  3312463746    1    10        3
        29108443  29108443  1.1474  2.6840        36  3533177779    7    23        2
        29109993  29109993  1.0240  2.7238        62  6424972551    8    15        3
        29111539  29111539  1.2032  2.6796        87  3533177779    4     0        6
        29112154  29112154  1.1070  2.5419       178  4932578245    8    23        3
        
        [17710 rows x 8 columns]'''
        place_count = data.groupby('place_id').count()
        # print(place_count)
        '''
                    row_id     x     y  accuracy   day  hour  weekday
        place_id                                                     
        1012023972       1     1     1         1     1     1        1
        1057182134       1     1     1         1     1     1        1
        1059958036       3     3     3         3     3     3        3
        1085266789       1     1     1         1     1     1        1
        1097200869    1044  1044  1044      1044  1044  1044     1044
        ...            ...   ...   ...       ...   ...   ...      ...
        9904182060       1     1     1         1     1     1        1
        9915093501       1     1     1         1     1     1        1
        9946198589       1     1     1         1     1     1        1
        9950190890       1     1     1         1     1     1        1
        9980711012       5     5     5         5     5     5        5
        
        [805 rows x 7 columns]
        '''
        tf = place_count[place_count.row_id > 3].reset_index()
        # print(tf)
        '''
               place_id  row_id     x     y  accuracy   day  hour  weekday
        0    1097200869    1044  1044  1044      1044  1044  1044     1044
        1    1228935308     120   120   120       120   120   120      120
        2    1267801529      58    58    58        58    58    58       58
        3    1278040507      15    15    15        15    15    15       15
        4    1285051622      21    21    21        21    21    21       21
        ..          ...     ...   ...   ...       ...   ...   ...      ...
        234  9741307878       5     5     5         5     5     5        5
        235  9753855529      21    21    21        21    21    21       21
        236  9806043737       6     6     6         6     6     6        6
        237  9809476069      23    23    23        23    23    23       23
        238  9980711012       5     5     5         5     5     5        5
        
        [239 rows x 8 columns]'''
        data = data[data['place_id'].isin(tf.place_id)]
        # print(data)
        '''
                    row_id       x       y  accuracy    place_id  day  hour  weekday
        600            600  1.2214  2.7023        17  6683426742    1    18        3
        957            957  1.1832  2.6891        58  6683426742   10     2        5
        4345          4345  1.1935  2.6550        11  6889790653    5    15        0
        4735          4735  1.1452  2.6074        49  6822359752    6    23        1
        5580          5580  1.0089  2.7287        19  1527921905    9    11        4
        ...            ...     ...     ...       ...         ...  ...   ...      ...
        29100203  29100203  1.0129  2.6775        12  3312463746    1    10        3
        29108443  29108443  1.1474  2.6840        36  3533177779    7    23        2
        29109993  29109993  1.0240  2.7238        62  6424972551    8    15        3
        29111539  29111539  1.2032  2.6796        87  3533177779    4     0        6
        29112154  29112154  1.1070  2.5419       178  4932578245    8    23        3
        
        [16918 rows x 8 columns]
        '''
        # 分类算法  特征值  目标值
        x = data.drop(['place_id'],axis=1)
        y = data['place_id']
        # 数据分割
        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(n_neighbors=5)
        knn.fit(x_train, y_train)
        # 得出预测结果
        y_predict = knn.predict(x_test)
        print(y_predict)  # [6424972551 2355236719 3952821602 ... 3992589015 6424972551 3533177779]
        # [6683426742 8258328058 6399991653 ... 8048985799 7914558846 1435128522]
    
        # 预测的准确率
        score = knn.score(x_test,y_test)
        print(score)  # 0.028605200945626477  # 0.4148936170212766
    
    
    if __name__ == '__main__':
        nkkcls()
    
    

    3.朴素贝叶斯算法

    在这里插入图片描述
    在这里插入图片描述

    3.1朴素贝叶斯算法

    概率定义为一件事情发生的可能性
    > 扔出一个硬币,结果头像朝上
    > 某天是晴天
    在这里插入图片描述
    问题?
    1.女神喜欢的概率? 4/7
    2.职业是程序员并且体型匀称的概率? 联合概率:p(程序员,匀称)=3/7 * 4/7
    3.在女神喜欢的条件下,职业是程序
    员的概率? 2/4
    4.在女神喜欢的条件下,职业是产品,
    体重是超重的概率?条件概率:P(产品,超重|喜欢) = P(产品|喜欢)P(超重|喜欢) = 2/4 * 1/4

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

    朴素贝叶斯-贝叶斯公式
    在这里插入图片描述
    在这里插入图片描述
    朴素贝叶斯-贝叶斯公式
    公式分为三个部分:
    P©:每个文档类别的概率(某文档类别词数/总文档词数)
    P(W|C):给定类别下特征(被预测文档中出现的词)的概率
    计算方法:P(F1|C) = Ni/N
    Ni为该F1词在C类别所有文档中出现的次数
    N为所属类别C下的文档所有词出现的次数和
    P(F1,F2)预测文档中每个词的概率

    P(文档类别|文档特征)
    P(科技|云计算,5G)=P(云计算,5G|科技)P(科技)/P(W)
    P(编程|云计算,5G)=P(云计算,5G|科技)P(编程)/P(W)

    朴素贝叶斯-贝叶斯公式
    在这里插入图片描述
    现有一篇被预测文档:出现了影院,支付宝,云计算,计算属于科技、娱乐的类别概率?

    预测文档:P(科技|影院,支付宝,云计算) = P(影院,支付宝,云计算|科技)P(科技) = 8/10020/10063/100*100/221

    预测文档:P(娱乐|影院,支付宝,云计算) = P(影院,支付宝,云计算|娱乐)P(娱乐) = 56/12115/121(0+1)/121*121/221

    拉普拉斯平滑
    问题:从上面的例子我们得到娱乐概率为0,这是不合理的,如果词频列表里面有很多出现次
    数都为0,很可能计算结果都为零
    解决方法:拉普拉斯平滑系数
    在这里插入图片描述
    sklearn朴素贝叶斯实现API
    sklearn.naive_bayes.MultinomialNB
    sklearn.naive_bayes.MultinomialNB(alpha = 1.0) 朴素贝叶斯分类
    alpha:拉普拉斯平滑系数

    3.2 朴素贝叶斯算法案例

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

    from sklearn.datasets import fetch_20newsgroups
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.model_selection import train_test_split
    
    
    def naviebays():
        """
        朴素贝叶斯进行文本分类
        :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()
        x_train = tf.fit_transform(x_train)
        x_test = tf.transform(x_test)
    
        # 进行算法流程
        mlt = MultinomialNB(alpha=1.0)
    
        mlt.fit(x_train, y_train)
    
        y_predict = mlt.predict(x_test)
        print(y_predict)  # [17  9  0 ...  6  2 16]
    
        # 准确率
        print(mlt.score(x_test,y_test))  # 0.8554753820033956
    
        return None
    
    
    if __name__ == '__main__':
        naviebays()
    
    

    3.3朴素贝叶斯总结

    优点:
    1.朴素贝叶斯模型发源于古典数学理论,有稳定的分类效率。
    2.对缺失数据不太敏感,算法也比较简单,常用于文本分类。
    3.分类准确度高,速度快
    缺点:
    1.模型的原因导致预测效果不佳。

    3.4分类模型的评估

    判定手机的好用与否
    在这里插入图片描述在这里插入图片描述
    estimator.score()一般最常见使用的是准确率,即预测结果正确的百分比
    混淆矩阵
    在分类任务下,预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合,构成混淆矩阵(适用于多分类)
    在这里插入图片描述
    在这里插入图片描述

    精确率与召回率
    精确率:预测结果为正例样本中真实为正例的比例(查得准)

    在这里插入图片描述
    召回率:真实为正例的样本中预测结果为正例的比例(查的全,对正样本的区分能力)
    在这里插入图片描述
    分类模型评估API
    sklearn.metrics.classification_report
    sklearn.metrics.classification_report(y_true, y_pred, target_names=None)
    • y_true:真实目标值
    • y_pred:估计器预测目标值
    • target_names:目标类别名称
    return:每个类别精确率与召回率

    from sklearn.datasets import fetch_20newsgroups
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.naive_bayes import MultinomialNB
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    
    def naviebays():
        """
        朴素贝叶斯进行文本分类
        :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()
        x_train = tf.fit_transform(x_train)
        x_test = tf.transform(x_test)
    
        # 进行算法流程
        mlt = MultinomialNB(alpha=1.0)
    
        mlt.fit(x_train, y_train)
    
        y_predict = mlt.predict(x_test)
        print(y_predict)  # [17  9  0 ...  6  2 16]
    
        # 准确率
        print(mlt.score(x_test, y_test))  # 0.8554753820033956
    
        # 精确率和召回率
        print('每个类别的精确率和召回率:', classification_report(y_test, y_predict, target_names=news.target_names))
        return None
    
    
    if __name__ == '__main__':
        naviebays()
    '''
    [ 0 17 16 ...  8 11  0]
    0.8491086587436333
    每个类别的精确率和召回率:                           precision    recall  f1-score   support
    
                 alt.atheism       0.90      0.73      0.81       206
               comp.graphics       0.89      0.76      0.82       233
     comp.os.ms-windows.misc       0.84      0.83      0.83       235
    comp.sys.ibm.pc.hardware       0.73      0.87      0.79       245
       comp.sys.mac.hardware       0.92      0.85      0.88       247
              comp.windows.x       0.93      0.84      0.89       249
                misc.forsale       0.91      0.72      0.80       242
                   rec.autos       0.93      0.90      0.92       250
             rec.motorcycles       0.95      0.95      0.95       254
          rec.sport.baseball       0.94      0.96      0.95       252
            rec.sport.hockey       0.89      0.98      0.93       234
                   sci.crypt       0.82      0.97      0.89       267
             sci.electronics       0.87      0.79      0.83       248
                     sci.med       0.97      0.89      0.93       247
                   sci.space       0.85      0.97      0.90       220
      soc.religion.christian       0.54      0.97      0.69       254
          talk.politics.guns       0.78      0.96      0.86       240
       talk.politics.mideast       0.90      0.97      0.93       234
          talk.politics.misc       0.99      0.58      0.74       202
          talk.religion.misc       1.00      0.18      0.30       153
    
                    accuracy                           0.85      4712
                   macro avg       0.88      0.83      0.83      4712
                weighted avg       0.87      0.85      0.84      4712'''
    

    模型的选择与调优
    1、交叉验证
    2、网格搜索
    交叉验证
    交叉验证:为了让被评估的模型更加准确可信
    交叉验证过程
    交叉验证:将拿到的数据,分为训练和验证集。以下图为例:将数据分成5份,其中一份作
    为验证集。然后经过5次(组)的测试,每次都更换不同的验证集。即得到5组模型的结果,
    取平均值作为最终结果。又称5折交叉验证。
    在这里插入图片描述
    超参数搜索-网格搜索
    通常情况下,有很多参数是需要手动指定的(如k-近邻算法中的K值),这种叫超参数。但是手动过程繁杂,所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型。
    在这里插入图片描述

    在这里插入图片描述
    超参数搜索-网格搜索API
    sklearn.model_selection.GridSearchCV

    GridSearchCV
    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-近邻网格搜索案例
    将前面的k-近邻算法案例改成网格搜索

    import pandas as pd
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.preprocessing import StandardScaler
    
    
    def nkkcls():
        """
        K-近邻预测用户签到位置
        :return: None
        """
    
        data = pd.read_csv('./train.csv')
    
        # print(data.head(10))  sql语句里面的where条件 缩小数据
        # data = data.query('x > 1.0 & x < 1.25 & y > 2.5 & y<2.75')
        # print(data)
    
        # 处理时间
        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
    
        # print(data)
        data = data.drop(['time'], axis=1)
    
        place_count = data.groupby('place_id').count()
        # print(place_count)
        tf = place_count[place_count.row_id > 3].reset_index()
        data = data[data['place_id'].isin(tf.place_id)]
    
        # 分类算法  特征值  目标值
        x = data.drop(['place_id'], axis=1)
    
        y = data['place_id']
    
        # 数据分割
        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(n_neighbors=5)
        knn.fit(x_train, y_train)
    
        # 进行网格搜索
        param = {"n_neighbors": [3, 5, 10]}
        gc = GridSearchCV(knn, 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_)
    
    
    if __name__ == '__main__':
        nkkcls()
    
    

    在这里插入图片描述

    展开全文
  • 机器学习十大算法

    万次阅读 多人点赞 2018-08-18 09:26:05
    机器学习十大算法 http://www.52cs.org/?p=1835   作者 James Le ,译者 尚剑 , 本文转载自infoQ 毫无疑问,机器学习/人工智能的子领域在过去几年越来越受欢迎。目前大数据在科技行业已经炙手可热,而...

    机器学习十大算法

    http://www.52cs.org/?p=1835

     

    作者 James Le ,译者 尚剑 , 本文转载自infoQ

    毫无疑问,机器学习/人工智能的子领域在过去几年越来越受欢迎。目前大数据在科技行业已经炙手可热,而基于大量数据来进行预测或者得出建议的机器学习无疑是非常强大的。一些最常见的机器学习例子,比如Netflix的算法可以根据你以前看过的电影来进行电影推荐,而Amazon的算法则可以根据你以前买过的书来推荐书籍。

    所以如果你想了解更多有关机器学习的内容,那么你该如何入门?对于我来说,我的入门课程是我在哥本哈根出国留学时参加的人工智能课。当时我的讲师是丹麦技术大学(Technical University of Denmark)的应用数学和计算机科学的全职教授,他的研究方向是逻辑与人工智能,侧重于使用逻辑学来对人性化的规划、推理和解决问题进行建模。这个课程包括对理论/核心概念的讨论和自己动手解决问题。我们使用的教材是AI经典之一:Peter Norvig的Artificial Intelligence—A Modern Approach(中文译本:《人工智能:一种现代的方法》),这本书主要讲了智能体、搜索解决问题、对抗搜索、概率论、多智能体系统、社会AI和AI的哲学/伦理/未来等等。在课程结束时,我们三个人的团队实现了一个简单的编程项目,也就是基于搜索的智能体解决虚拟环境中的运输任务问题。

    在那门课程上我已经学到了很多知识,并决定继续学习相关的课题。在过去的几个星期里,我在旧金山参加了多次相关的技术讲座,涉及到深度学习、神经网络和数据结构,并且参加了一个有很多该领域的知名专家学者参加的机器学习会议。最重要的是,我在6月初参加了Udacity上的Intro to Machine Learning(机器学习入门)在线课程,前几天才完成。在这篇文章中,我想分享一下我从课程中学到的一些最常用的机器学习算法。

    机器学习算法可以分为三大类:监督学习、无监督学习和强化学习。监督学习可用于一个特定的数据集(训练集)具有某一属性(标签),但是其他数据没有标签或者需要预测标签的情况。无监督学习可用于给定的没有标签的数据集(数据不是预分配好的),目的就是要找出数据间的潜在关系。强化学习位于这两者之间,每次预测都有一定形式的反馈,但是没有精确的标签或者错误信息。因为这是一个介绍课程,我没有学习过强化学习的相关内容,但是我希望以下10个关于监督学习和无监督学习的算法足以让你感兴趣。

    监督学习

    1.决策树(Decision Trees)

    决策树是一个决策支持工具,它使用树形图或者决策模型以及可能性序列,包括偶然事件的结果、资源成本和效用。下图是其基本原理:

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/0.jpg

    从业务决策的角度来看,决策树是人们必须了解的最少的是/否问题,这样才能评估大多数时候做出正确决策的概率。作为一种方法,它允许你以结构化和系统化的方式来解决问题,从而得出合乎逻辑的结论。

    2.朴素贝叶斯分类(Naive Bayesian classification)

    朴素贝叶斯分类器是一类简单的概率分类器,它基于贝叶斯定理和特征间的强大的(朴素的)独立假设。图中是贝叶斯公式,其中P(A|B)是后验概率,P(B|A)是似然,P(A)是类先验概率,P(B)是预测先验概率。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/1.jpg

    一些应用例子:

    • 判断垃圾邮件
    • 对新闻的类别进行分类,比如科技、政治、运动
    • 判断文本表达的感情是积极的还是消极的
    • 人脸识别

    3.最小二乘法(Ordinary Least Squares Regression)

    如果你懂统计学的话,你可能以前听说过线性回归。最小二乘法是一种计算线性回归的方法。你可以将线性回归看做通过一组点来拟合一条直线。实现这个有很多种方法,“最小二乘法”就像这样:你可以画一条直线,然后对于每一个数据点,计算每个点到直线的垂直距离,然后把它们加起来,那么最后得到的拟合直线就是距离和尽可能小的直线。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/2.jpg

    线性指的是你用来拟合数据的模型,而最小二乘法指的是你最小化的误差度量。

    4.逻辑回归(Logistic Regression)

    逻辑回归是一个强大的统计学方法,它可以用一个或多个解释变量来表示一个二项式结果。它通过使用逻辑函数来估计概率,从而衡量类别依赖变量和一个或多个独立变量之间的关系,后者服从累计逻辑分布。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/3.jpg

    总的来说,逻辑回归可以用于以下几个真实应用场景:

    • 信用评分
    • 计算营销活动的成功率
    • 预测某个产品的收入
    • 特定的某一天是否会发生地震

    5.支持向量机(Support Vector Machine,SVM)

    SVM是二进制分类算法。给定N维坐标下两种类型的点,SVM生成(N-1)维的超平面来将这些点分成两组。假设你在平面上有两种类型的可以线性分离的点,SVM将找到一条直线,将这些点分成两种类型,并且这条直线尽可能远离所有这些点。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/4.jpg

    从规模上看,使用SVM(经过适当的修改)解决的一些最大的问题包括显示广告、人类剪切位点识别(human splice site recognition)、基于图像的性别检测,大规模图像分类……

    6.集成方法(Ensemble methods)

    集成方法是学习算法,它通过构建一组分类器,然后通过它们的预测结果进行加权投票来对新的数据点进行分类。原始的集成方法是贝叶斯平均,但是最近的算法包括纠错输出编码、Bagging和Boosting。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/5.jpg

    那么集成方法如何工作?并且为什么它们要优于单个模型?

    • 它们平均了单个模型的偏差:如果你将民主党的民意调查和共和党的民意调查在一起平均化,那么你将得到一个均衡的结果,不偏向任何一方。
    • 它们减少了方差:一组模型的总体意见比其中任何一个模型的单一意见更加统一。在金融领域,这就是所谓的多元化,有许多股票的组合比一个单独的股票的不确定性更少,这也为什么你的模型在数据多的情况下会更好的原因。
    • 它们不太可能过拟合:如果你有单个的模型没有过拟合,那么把这些模型的预测简单结合起来(平均、加权平均、逻辑回归),那么最后得到的模型也不会过拟合。

    无监督学习

    7.聚类算法(Clustering Algorithms)

    聚类是将一系列对象分组的任务,目标是使相同组(集群)中的对象之间比其他组的对象更相似。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/6.jpg

    每一种聚类算法都不相同,下面是一些例子:

    • 基于质心的算法
    • 基于连接的算法
    • 基于密度的算法
    • 概率
    • 降维
    • 神经网络/深度学习

    8.主成分分析(Principal Component Analysis,PCA)

    PCA是一个统计学过程,它通过使用正交变换将一组可能存在相关性的变量的观测值转换为一组线性不相关的变量的值,转换后的变量就是所谓的主分量。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/7.jpg

    PCA的一些应用包括压缩、简化数据便于学习、可视化等。请注意,领域知识在选择是否继续使用PCA时非常重要。 数据嘈杂的情况(PCA的所有成分具有很高的方差)并不适用。

    9.奇异值分解(Singular Value Decomposition,SVD)

    在线性代数中,SVD是复杂矩阵的因式分解。对于给定的m * n矩阵M,存在分解使得M=UΣV,其中U和V是酉矩阵,Σ是对角矩阵。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/8.jpg

    实际上,PCA是SVD的一个简单应用。在计算机视觉中,第一个人脸识别算法使用PCA和SVD来将面部表示为“特征面”的线性组合,进行降维,然后通过简单的方法将面部匹配到身份,虽然现代方法更复杂,但很多方面仍然依赖于类似的技术。

    10.独立成分分析(Independent Component Analysis,ICA)

    ICA是一种统计技术,主要用于揭示随机变量、测量值或信号集中的隐藏因素。ICA对观测到的多变量数据定义了一个生成模型,这通常是作为样本的一个大的数据库。在模型中,假设数据变量由一些未知的潜在变量线性混合,混合方式也是未知的。潜在变量被假定为非高斯分布并且相互独立,它们被称为观测数据的独立分量。

    http://cdn1.infoqstatic.com/statics_s1_20170718-0237/resource/articles/10-algorithms-machine-learning-engineers-need-to-know/zh/resources/9.jpg

    ICA与PCA有关,但是当这些经典方法完全失效时,它是一种更强大的技术,能够找出源的潜在因素。 其应用包括数字图像、文档数据库、经济指标和心理测量。

    现在运用你对这些算法的理解去创造机器学习应用,为世界各地的人们带来更好的体验吧。

    展开全文
  • 机器学习新手十大算法

    千次阅读 2020-08-03 09:33:07
    有一个通用原则是所有用于预测建模的受监督机器学习算法的基础。 机器学习算法被描述为学习目标函数(f),该函数最好将输入变量(X)映射到输出变量(Y):Y = f(X) 这是一个简单的学习任务,我们想在给定新的...

    有一个通用原则是所有用于预测建模的受监督机器学习算法的基础。
    机器学习算法被描述为学习目标函数(f),该函数最好将输入变量(X)映射到输出变量(Y):Y = f(X)
    这是一个简单的学习任务,我们想在给定新的输入变量(X)的情况下,对(Y)进行预测。但是不知道函数(f)。
    机器学习的最常见类型是学习映射 Y = f(X)可以对新 X 预测到 Y,目标是尽可能进行最准确的预测。
    对于初入机器学习领域,没有机器学习基础知识的新手,我会对常用的十大机器学习算法做简单介绍。

    1-线性回归

    线性回归可能是统计和机器学习中最著名和最易理解的算法之一。
    主要与最小化模型的误差或做出尽可能准确的预测有关,但以可解释性为代价。我们将从许多不同领域(包括统计数据)中学习。
    线性回归的表示法是一个方程,该方程通过找到称为系数(B),来描述输入变量(x)与输出变量(y)之间关系的线。

    在这里插入图片描述
    例如:y = B0 + B1 * x ,这不是一次函数吗?哈哈
    给定输入 x,我们将预测 y,线性回归学习算法的目标是找到系数 B0 和 B1 的值, 例如用于普通最小二乘法和梯度下降优化的线性代数解。

    2-LOGISTIC回归

    逻辑回归是机器学习从统计领域 “借” 的另一种技术。它是二分类问题(具有两个类值的问题)的首选方法。
    Logistic 回归类似于线性回归,因为目标是找到权重每个输入变量的系数的值。与线性回归不同,输出的预测使用称为对数函数的非线性函数进行变换。
    逻辑函数看起来像一个大 S,它将任何值转换为 0 到 1 的范围。因为我们可以将规则应用于逻辑函数的输出为 0 和 1(例如,如果 IF 小于 0.5,则输出 1)并预测类别值。
    在这里插入图片描述
    与线性回归一样,当去除与输出变量无关的属性以及相关的属性时,逻辑回归的效果更好。这是一个快速学习二进制分类问题并有效的模型。

    3-线性判别分析

    Logistic 回归是传统上仅限于两类分类问题的分类算法。如果是多分类,则线性判别分析算法(LDA)就是很重要的算法了。
    LDA 的表示非常简单,它由数据的统计属性组成,这些属性是针对每个类别计算的。对于单个输入变量,这包括:

    1. 每个类别的平均值。
    2. 计算所有类别的方差
      在这里插入图片描述

    通过为每个类别计算一个区分值并为具有最大值的类别进行预测来进行预测。
    该算法的前提是:数据具有高斯分布(钟形曲线),因此最好在操作之前从数据中删除异常值。

    4-分类和回归树

    决策树是用于预测建模机器学习的重要算法类型。
    决策树模型的表示形式是二叉树。这是来自算法和数据结构的二叉树,没有什么花哨的。每个节点代表一个输入变量(x)和该变量的分割点(假设变量是数字)。

    树的叶节点包含用于进行预测的输出变量(y)。通过遍历树的拆分直到到达叶节点并在该叶节点输出类值来进行预测。
    树学习速度很快,做出预测的速度也非常快。它们对于许多问题通常也很准确,不需要为数据做任何特殊预处理。
    在这里插入图片描述
    树的叶节点包含用于进行预测的输出变量(y)。通过遍历树的拆分直到到达叶节点并在该叶节点输出类值来进行预测。
    树学习速度很快,做出预测的速度也非常快。它们对于许多问题通常也很准确,不需要为数据做任何特殊预处理。

    5-朴素贝叶斯

    朴素贝叶斯(Naive Bayes)是一种简单但功能强大的预测建模算法。
    该模型由两种类型的概率组成,可以直接从您的训练数据中计算出:
    1)每个类别的概率;
    2)给定每个 x 值的每个类别的条件概率。
    开始计算,概率模型可用于使用贝叶斯定理对新数据进行预测。当你的数据是实值时,通常会假设一个高斯分布(钟形曲线),以便可以轻松地估计这些概率。
    在这里插入图片描述
    朴素贝叶斯之所以被称为朴素,是因为它假定每个输入变量都是独立的。这是一个很强的假设,对于真实数据来说是不现实的,尽管如此,该技术对于大量复杂问题非常有效。

    6 - K近邻

    KNN 算法非常简单且非常有效。KNN 的模型表示是整个训练数据集。简单吧?
    通过搜索整个训练集中的 K 个最相似实例并汇总这 K 个实例的输出变量,可以对新数据点进行预测。
    对于回归问题,这可能是平均输出变量,对于分类问题,这可能是最常见的类别值。
    诀窍在于如何确定数据实例之间的相似性。如果您的属性都具有相同的比例(例如,都是距离数据),最简单的方法是使用欧几里得距离,您可以根据每个输入变量之间的差异直接计算一个数字。
    在这里插入图片描述

    KNN 可能需要大量内存或空间来存储所有数据,因为它把所有数据都遍历了。您还可以随着时间的训练数据,以保持预测的准确性。
    距离或紧密度的概念可能会分解为非常高的维度(许多输入变量),这可能会对问题的算法性能产生负面影响。所以对于数据的输入就至关重要。

    7- 矢量化学习

    K 最近的缺点是需要整个训练数据集。学习向量量化算法(简称 LVQ)是一种人工神经网络算法,可让选择要需要的训练实例数量。
    在这里插入图片描述
    LVQ 的表示形式是向量的集合。这些是在最开始开始时随机选择的,适用于在学习算法的多次迭代中最好地总结训练数据集。
    学习之后,可以像使用 K 近邻一样,使用数据进行预测。通过计算每个向量与新数据实例之间的距离,可以找到最相似的数据向量(最佳匹配的向量)。然后返回最佳匹配的类值作为预测。记得数据归一化,获得的效果更好。

    8-支持向量机

    支持向量机可能是最受欢迎的机器学习算法之一。
    超平面是分割输入变量空间的线。
    在 SVM 中,选择一个超平面以按类别(类别 0 或类别 1)最好地分隔输入变量空间中的点。
    在二维图中,您可以将其可视化为一条线,并假设所有输入点都可以被这条线完全隔开。SVM 学习算法找到超平面对类进行最佳分离的系数。
    在这里插入图片描述
    超平面和最近的数据点之间的距离称为边距。可以将这两个类别分开的最佳或最佳超平面是边距最大的线。
    仅这些点与定义超平面和分类器的构造有关。这些点称为支持向量。
    在实践中,使用优化算法来找到使余量最大化的系数的值。
    SVM 可能是功能最强大的即用型分类器之一,使用频率很高。

    9-BAGGING和随机森林

    随机森林是最流行,功能最强大的机器学习算法之一。这是一种称为 Bootstrap 聚类或 BAGGING 的集成机器学习算法。
    您需要对数据进行大量采样,计算平均值,然后对所有平均值取平均值,以便更好地估算真实平均值。
    在 bagging 中,使用相同的方法,但用于估计整个统计模型(最常见的是决策树)。获取训练数据的多个样本,然后为每个数据样本构建模型。当你需要对新数据进行预测时,每个模型都将进行预测,并对预测取平均值以对真实输出值进行更好的估计。
    在这里插入图片描述
    随机森林是对这种方法的一种调整,在该方法中将创建决策树,不是选择最佳的拆分点。
    因此,为每个数据样本创建的模型与原先的模型相比,差异更大。将他们的预测结合起来可以更好地估计真实的基础输出值。

    10-BOOSTING和ADABOOST

    在这里插入图片描述

    Boosting 是一种集成技术,尝试从多个弱分类器创建强分类器。这是通过从训练数据构建模型,然后创建第二个模型来尝试纠正第一个模型中的错误来完成的。添加模型,直到完美预测训练集或添加最大数量的模型为止。
    AdaBoost 是为二进制分类开发的第一个真正成功的增强算法。这是了解增强的最佳起点。现代的增强方法基于 AdaBoost,最著名的是随机梯度增强机.
    AdaBoost 与决策树一起使用。
    创建第一棵树后,将在每个训练实例上使用该树的性能来加权要创建的下一棵树应注意每个训练实例的关注程度。
    难以预测的训练数据的权重更高,而易于预测的实例的权重更低。依次创建模型,每个模型都会更新训练实例上的权重,这些权重会影响序列中下一棵树执行的学习。构建完所有树之后,对新数据进行预测,并根据训练数据的准确性对每棵树的性能进行加权。
    由于该算法在纠正错误方面投入了很多精力,因此删除异常值和数据去噪非常重要。

    展开全文
  • Machine Learning_机器学习10大算法

    万次阅读 2019-10-24 13:21:21
    Machine Learning_机器学习10大算法 1. 线性回归 在统计学和机器学习领域,线性回归可能是最广为人知也最易理解的算法之一。 预测建模主要关注的是在牺牲可解释性的情况下,尽可能最小化模型误差或做出最准确的...

    Machine Learning_机器学习10大算法


     

    1. 线性回归

    在统计学和机器学习领域,线性回归可能是最广为人知也最易理解的算法之一。

    预测建模主要关注的是在牺牲可解释性的情况下,尽可能最小化模型误差或做出最准确的预测。我们将借鉴、重用来自许多其它领域的算法(包括统计学)来实现这些目标。

    线性回归模型被表示为一个方程式,它为输入变量找到特定的权重(即系数 B),进而描述一条最佳拟合了输入变量(x)和输出变量(y)之间关系的直线。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

    例如:y = B0 + B1 * x

    我们将在给定输入值 x 的条件下预测 y,线性回归学习算法的目的是找到系数 B0 和 B1 的值。

    我们可以使用不同的技术来从数据中学习线性回归模型,例如普通最小二乘法的线性代数解和梯度下降优化。

    线性回归大约有 200 多年的历史,并已被广泛地研究。在使用此类技术时,有一些很好的经验规则:我们可以删除非常类似(相关)的变量,并尽可能移除数据中的噪声。线性回归是一种运算速度很快的简单技术,也是一种适合初学者尝试的经典算法。

    2. Logistic 回归

    Logistic 回归是机器学习从统计学领域借鉴过来的另一种技术。它是二分类问题的首选方法。

    像线性回归一样,Logistic 回归的目的也是找到每个输入变量的权重系数值。但不同的是,Logistic 回归的输出预测结果是通过一个叫作「logistic 函数」的非线性函数变换而来的。

    logistic 函数的形状看起来像一个大的「S」,它会把任何值转换至 0-1 的区间内。这十分有用,因为我们可以把一个规则应用于 logistic 函数的输出,从而得到 0-1 区间内的捕捉值(例如,将阈值设置为 0.5,则如果函数值小于 0.5,则输出值为 1),并预测类别的值。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

    由于模型的学习方式,Logistic 回归的预测结果也可以用作给定数据实例属于类 0 或类 1 的概率。这对于需要为预测结果提供更多理论依据的问题非常有用。

    与线性回归类似,当删除与输出变量无关以及彼此之间非常相似(相关)的属性后,Logistic 回归的效果更好。该模型学习速度快,对二分类问题十分有效。

    3. 线性判别分析

    Logistic 回归是一种传统的分类算法,它的使用场景仅限于二分类问题。如果你有两个以上的类,那么线性判别分析算法(LDA)是首选的线性分类技术。

    LDA 的表示方法非常直接。它包含为每个类计算的数据统计属性。对于单个输入变量而言,这些属性包括:

    • 每个类的均值。
    • 所有类的方差。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

    预测结果是通过计算每个类的判别值、并将类别预测为判别值最大的类而得出的。该技术假设数据符合高斯分布(钟形曲线),因此最好预先从数据中删除异常值。LDA 是一种简单而有效的分类预测建模方法。

    4. 分类和回归树

    决策树是一类重要的机器学习预测建模算法。

    决策树可以被表示为一棵二叉树。这种二叉树与算法设计和数据结构中的二叉树是一样的,没有什么特别。每个节点都代表一个输入变量(x)和一个基于该变量的分叉点(假设该变量是数值型的)。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

    决策树的叶子结点包含一个用于做出预测的输出变量(y)。预测结果是通过在树的各个分叉路径上游走,直到到达一个叶子结点并输出该叶子结点的类别值而得出。

    决策树的学习速度很快,做出预测的速度也很快。它们在大量问题中往往都很准确,而且不需要为数据做任何特殊的预处理准备。

    5. 朴素贝叶斯

    朴素贝叶斯是一种简单而强大的预测建模算法。

    该模型由两类可直接从训练数据中计算出来的概率组成:1)数据属于每一类的概率;2)给定每个 x 值,数据从属于每个类的条件概率。一旦这两个概率被计算出来,就可以使用贝叶斯定理,用概率模型对新数据进行预测。当你的数据是实值的时候,通常假设数据符合高斯分布(钟形曲线),这样你就可以很容易地估计这些概率。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

    朴素贝叶斯之所以被称为「朴素」,是因为它假设每个输入变量相互之间是独立的。这是一种很强的、对于真实数据并不现实的假设。不过,该算法在大量的复杂问题中十分有效。

    6. K 最近邻算法

    K 最近邻(KNN)算法是非常简单而有效的。KNN 的模型表示就是整个训练数据集。这很简单吧?

    对新数据点的预测结果是通过在整个训练集上搜索与该数据点最相似的 K 个实例(近邻)并且总结这 K 个实例的输出变量而得出的。对于回归问题来说,预测结果可能就是输出变量的均值;而对于分类问题来说,预测结果可能是众数(或最常见的)的类的值。

    关键之处在于如何判定数据实例之间的相似程度。如果你的数据特征尺度相同(例如,都以英寸为单位),那么最简单的度量技术就是使用欧几里得距离,你可以根据输入变量之间的差异直接计算出该值。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

    KNN 可能需要大量的内存或空间来存储所有数据,但只有在需要预测时才实时执行计算(或学习)。随着时间的推移,你还可以更新并管理训练实例,以保证预测的准确率。

    使用距离或接近程度的度量方法可能会在维度非常高的情况下(有许多输入变量)崩溃,这可能会对算法在你的问题上的性能产生负面影响。这就是所谓的维数灾难。这告诉我们,应该仅仅使用那些与预测输出变量最相关的输入变量。

    7. 学习向量量化

    KNN 算法的一个缺点是,你需要处理整个训练数据集。而学习向量量化算法(LVQ)允许选择所需训练实例数量,并确切地学习这些实例。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

     

    LVQ 的表示是一组码本向量。它们在开始时是随机选择的,经过多轮学习算法的迭代后,最终对训练数据集进行最好的总结。通过学习,码本向量可被用来像 K 最近邻那样执行预测。通过计算每个码本向量与新数据实例之间的距离,可以找到最相似的邻居(最匹配的码本向量)。然后返回最匹配单元的类别值(分类)或实值(回归)作为预测结果。如果将数据重新放缩放到相同的范围中(例如 0 到 1 之间),就可以获得最佳的预测结果。

    如果你发现 KNN 能够在你的数据集上得到不错的预测结果,那么不妨试一试 LVQ 技术,它可以减少对内存空间的需求,不需要像 KNN 那样存储整个训练数据集。

    8. 支持向量机

    支持向量机(SVM)可能是目前最流行、被讨论地最多的机器学习算法之一。

    超平面是一条对输入变量空间进行划分的「直线」。支持向量机会选出一个将输入变量空间中的点按类(类 0 或类 1)进行最佳分割的超平面。在二维空间中,你可以把他想象成一条直线,假设所有输入点都可以被这条直线完全地划分开来。SVM 学习算法旨在寻找最终通过超平面得到最佳类别分割的系数。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

     

    超平面与最近数据点之间的距离叫作间隔(margin)。能够将两个类分开的最佳超平面是具有最大间隔的直线。只有这些点与超平面的定义和分类器的构建有关,这些点叫作支持向量,它们支持或定义超平面。在实际应用中,人们采用一种优化算法来寻找使间隔最大化的系数值。

    支持向量机可能是目前可以直接使用的最强大的分类器之一,值得你在自己的数据集上试一试。

    9. 袋装法和随机森林

    随机森林是最流行也最强大的机器学习算法之一,它是一种集成机器学习算法。

    自助法是一种从数据样本中估计某个量(例如平均值)的强大统计学方法。你需要在数据中取出大量的样本,计算均值,然后对每次取样计算出的均值再取平均,从而得到对所有数据的真实均值更好的估计。

    Bagging 使用了相同的方法。但是最常见的做法是使用决策树,而不是对整个统计模型进行估计。Bagging 会在训练数据中取多个样本,然后为每个数据样本构建模型。当你需要对新数据进行预测时,每个模型都会产生一个预测结果,Bagging 会对所有模型的预测结果取平均,以便更好地估计真实的输出值。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

     

    随机森林是这种方法的改进,它会创建决策树,这样就不用选择最优分割点,而是通过引入随机性来进行次优分割。

    因此,为每个数据样本创建的模型比在其它情况下创建的模型更加独特,但是这种独特的方式仍能保证较高的准确率。结合它们的预测结果可以更好地估计真实的输出值。

    如果你使用具有高方差的算法(例如决策树)获得了良好的结果,那么你通常可以通过对该算法执行 Bagging 获得更好的结果。

    10. Boosting 和 AdaBoost

    Boosting 是一种试图利用大量弱分类器创建一个强分类器的集成技术。要实现 Boosting 方法,首先你需要利用训练数据构建一个模型,然后创建第二个模型(它企图修正第一个模型的误差)。直到最后模型能够对训练集进行完美地预测或加入的模型数量已达上限,我们才停止加入新的模型。

    AdaBoost 是第一个为二分类问题开发的真正成功的 Boosting 算法。它是人们入门理解 Boosting 的最佳起点。当下的 Boosting 方法建立在 AdaBoost 基础之上,最著名的就是随机梯度提升机。

    æºå¨å­¦ä¹ å¿ç¥å¿ä¼10大ç®æ³

     

    AdaBoost 使用浅层决策树。在创建第一棵树之后,使用该树在每个训练实例上的性能来衡量下一棵树应该对每个训练实例赋予多少权重。难以预测的训练数据权重会增大,而易于预测的实例权重会减小。模型是一个接一个依次创建的,每个模型都会更新训练实例权重,影响序列中下一棵树的学习。在构建所有的树之后,我们就可以对新的数据执行预测,并根据每棵树在训练数据上的准确率来对其性能进行加权。

    由于算法在纠正错误上投入了如此多的精力,因此删除数据中的异常值在数据清洗过程中是非常重要的。

    原文链接:https://medium.com/m/global-identity?redirectUrl=https%3A%2F%2Fblog.goodaudience.com%2Ftop-10-machine-learning-algorithms-2a9a3e1bdaff

     

    展开全文
  • 机器学习常见算法

    2019-09-30 23:57:21
    先说算法,其实算法是个很大的概念,除了机器学习算法,还有很多非机器学习算法,如编程里解决排序的快排、堆排、冒泡,也是算法。只是机器学习太火了,一提算法,多想到的是机器学习算法。 1.决策树 决策树,一种...
  • 人工智能之机器学习常见算法

    万次阅读 多人点赞 2016-05-22 15:47:54
    很多人在平时的工作中都或多或少会用到机器学习算法。这里IT经理网为您总结一下常见的机器学习算法,以供您在工作和学习中参考。 机器学习算法很多。很多时候困惑人们都是,很多算法是一类算法,而有
  • 机器学习 之 十大算法

    千次阅读 2017-04-18 17:03:10
    英文原文:The 10 Algorithms Machine Learning Engineers Need to Know ...毫无疑问,机器学习/人工智能的子领域在...一些最常见的机器学习例子,比如Netflix的算法可以根据你以前看过的电影来进行电影推荐,而A
  • 机器学习之各种算法

    千次阅读 2015-11-20 15:51:49
    当然,机器学习的范围非常庞大,有些算法很难明确归类到某一类。而对于有些分类来说,同一分类的算法可以针对不同类型的问题。这里,我们尽量把常用的算法按照最容易理解的方式进行分类。 (1)回归算法:   ...
  • 我们先带着大家过一遍传统机器学习算法,基本思想和用途。把问题解决思路和方法应用建议提前到这里的想法也很简单,希望能提前给大家一些小建议,对于某些容易出错的地方也先给大家打个预防针,这样在理解后续相应...
  • 程序员面试、算法研究、编程艺术、红黑树、机器学习5大经典原创系列集锦与总结 作者:July--结构之法算法之道blog之博主。 时间:2010年10月-2018年5月,一直在不断更新中.. 出处:...
  • 机器学习机器学习算法之旅

    千次阅读 2018-05-19 20:57:56
    在这篇文章中,我们将介绍最流行的机器学习算法。 浏览该领域的主要算法以了解可用的方法是有用的。 有很多算法可用,当算法名称被抛出时,它会感到压倒性的,并且您只需要知道它们是什么以及它们在哪里适合。 我想...
  • 机器学习之聚类算法

    万次阅读 2016-08-17 18:37:53
    机器学习之聚类算法 一、什么是聚类? 物以聚类,人以群分。每个事物找到和自己相似的作为一类就是聚类,从小学到大学的学校生活中,每个人肯定都有自己的小团伙,自发的形成,,,其实这也算是聚类的实例。聚类在...
  • 机器学习之集成算法

    2018-07-19 09:38:09
    机器学习的集成算法是指的多个单一算法集成在一起,使得机器学习的效果更好。 集成算法包含 Bagging-----bootstrap aggregation  ①从样本集中重采样(有重复的)选出n个样本  ②在所有属性上,对这n个样本建立...
  • 机器学习常见算法整理

    万次阅读 2019-12-06 16:56:01
    1.XGBoost算法 1.1算法特性 用于解决二分类问题,同时通过使用许多策略能够防止过拟合现象发生,模型准确率比普通算法要高。XGBoost支持并行化计算,使得算法在模型训练及模型计算时运行速度快,效率高。XGBoost...
  • 机器学习之KNN最邻近分类算法

    万次阅读 多人点赞 2018-09-15 13:13:33
    KNN算法简介 KNN(K-Nearest Neighbor)最邻近分类算法是数据挖掘分类(classification)技术中最简单的算法之一,其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。 KNN最邻近分类算法的...
  • 机器学习之Apriori算法

    万次阅读 2018-05-18 17:28:55
    1.Apriori算法简介 Apriori算法是常用于挖掘出数据关联规则的算法,能够发现事物数据库中频繁出现的数据集,这些联系构成的规则可帮助用户找出某些行为特征,以便进行企业决策。例如,某食品商店希望发现顾客的购买...
  • [机器学习] Boosting算法1 --- AdaBoost

    万次阅读 多人点赞 2018-05-23 19:39:40
    [机器学习] Boosting算法1 --- AdaBoost [机器学习] Boosting算法2 --- GBDT [机器学习] Boosting算法3 --- XGBoost 目录 一、提升算法概论 二、AdaBoost算法 弱分类器(单层决策树) 关于Adaboost的两种...
  • 机器学习基础】EM算法

    万次阅读 多人点赞 2019-06-04 14:24:39
    最大期望算法(Expectation-maximization algorithm,又译为期望最大化算法),是在概率模型中寻找参数最大似然估计或者最大后验估计的算法,其中概率模型依赖于无法观测的隐性变量。 最大期望算法经过两个步骤...
  • 机器学习算法地图

    千次阅读 多人点赞 2018-07-05 12:10:07
    其它机器学习、深度学习算法的全面系统讲解可以阅读《机器学习-原理、算法与应用》,清华大学出版社,雷明著,由SIGAI公众号作者倾力打造。 书的购买链接 书的勘误,优化,源代码资源 文章《机器学习算法地图》系...
  • 在本指南中,我们将通过现代机器学习算法进行实用,简洁的介绍。虽然存在其他这样的列表,但它们并没有真正解释每种算法的实际权衡,我们希望在这里做。我们将根据我们的经验讨论每种算法的优缺点。 对机器学习算法...
  • 机器学习-遗传算法

    千次阅读 2018-01-16 17:22:20
    文中也简单提及了模拟退火算法。文章综合参考了一些互联网资料。发博客以备忘! 三:遗传算法  照例先给出科学定义:  遗传算法(Genetic Algorithm, GA)起源于对生物系统所进行的计算机模拟研究。...
  • 机器学习算法选取

    万次阅读 2019-04-23 16:56:06
    下面代码选取了五种主流机器学习算法包括SVM、KNN、决策树、逻辑回归、朴素贝叶斯,当然也包括集成学习算法,Bagging、Adaboost、GBDT和随机森林。编写一个通用函数分别构建上述模型,并作出ROC曲线进行模型评估。...
  • 机器学习:回归算法

    万次阅读 2017-02-11 20:58:07
    监督学习指的是有目标变量或预测目标的机器学习方法。回归与分类的不同,就在于其目标变量是连续数值型。线性回归 原理 回归的目的是预测数值型的目标值。最直接的办法是依据输入写出一个目标值的计算公式,该公式...
  • 机器学习算法简要

    万次阅读 2018-11-20 11:33:45
    机器学习算法很多,按照是否有标注,以及要解决的问题特点,按照如下规则分类。 有监督学习 分类问题 决策树: 支持向量机 朴素贝叶斯:条件概率 集成学习(多个分类算法的结合) Boosting:弱学习提升为强学习 ...
  • 机器学习:常见的机器学习算法归纳

    万次阅读 多人点赞 2021-03-11 09:22:43
    1) .回归算法 2) .基于实例的算法 3) .决策树学习 4) .贝叶斯方法 5) .基于核的算法 6) .聚类算法 7) .降低维度算法 8) .关联规则学习 9) .集成算法 10) .人工神经网络
  • Python与机器学习之优化算法

    千次阅读 2017-10-19 14:27:23
    Python与机器学习之优化算法 回顾圣经,在监督学习中优化算法是关键的步骤——分析模型并得到最优模型,才是最终的目的。
  • Spark机器学习有哪些算法

    千次阅读 2016-11-19 12:29:53
    Spark机器学习有哪些算法? Algorithms 算法: MLlib contains many algorithms and utilities, including:
  • 机器学习 —— Boosting算法

    万次阅读 多人点赞 2018-02-15 17:41:35
    Boosting算法(提升法) 算法的三个要素 (1)函数模型:Boosting的函数模型是叠加型的,即F(x)=∑i=1kfi(x;θi)F(x)=∑i=1kfi(x;θi)F(x)=\sum_{i=1}^{k}f_i(x;\theta_i) (2)目标函数:选定某种损失函数作为...
  • 机器学习常用算法总结

    万次阅读 2016-08-21 23:26:48
    机器学习算法很多,很多算法是一类算法,而有些算法又是从其他算法中延伸出来的。这里从两个方面进行总结,第一个方面是学习的方式,第二个方面是算法的类似性。 一、学习方式  根据数据类型的不同,对一个...
  • 浅谈机器学习框架和算法

    千次阅读 2017-08-03 13:40:42
    下面我将介绍机器学习的框架和一些常用的比较主流的算法。框架确定目标 业务需求:首先我们必须要明确机器学习是要用来解决问题的,一般是通过大量的数据,来预测未来的行为。所以首先要明确的就是业务需求,明确了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 301,524
精华内容 120,609
关键字:

机器学习包括什么算法