2019-03-01

2019-03-01  本文已影响0人  d032a642d9de

Data Analysis

算法基础， 工具框架算法模型的选择使用， 业务方面（金融等）
需要掌握 算法推导过程
了解大数据系统 （架构层， 算法是核心层）
数据获取途径： 爬虫， 大数据架构， 购买
数据挖掘（numpy， pandas， matplotlib ... ...）----
图像识别（在物联网中的应用， 无人驾驶技术， 自动泊车） nlp

numpy

核心数据结构是数组（二维以上就是矩阵， 一维数组是行向量）

  1. 创建
    (1) list创建
    ​ copy列表， 把列表中的元素类型统一化（object > float > int > boolean）然后根据统一化以后列表创建数组对象（数组中的元素类型都一致）
    ​ 列表在双肩数组的时候需要每个维度上的元素个数保持一致
    (2) 内建函数
    ​ ones()
    ​ zeros()
    ​ full()
    ​ eye() 对角线上为1 其他为0
    ​ linspace(start, stop, num=50)
    ​ logspace(start, stop, num=50) 指数 1 - 10
    ​ arange(start, stop, step) 去下标
    ​ random.randint(low, hight, size)
    ​ random.randn() 标准正态分布
    ​ random.narmal() 正态分布
    ​ random.random() 0 - 1 随机浮点数
  2. 属性
    ndim 维度
    size 大小
    shape 形状
    dtype 数据类型
    itemsize 每个元素的字节数 (float双精度的浮点64位 8个字节， 布尔类型一个字节)
    data 内存地址
  3. ndarray的基本操作
    1. 索引
      所有的列表索引方式， 数组都使用 a = np.array([[1, 2, 3], [4, 5, 6]])
      列表索引方式 a[0][0]
      数组特有的索引方式 a[0, 1] 或 a[[1, 0, 1]]
    2. 切片
      a[起始 : 终止 : 步长]
      步长为正： 从前向后切，
      步长为负： 从后向前切，
    3. 变形
      1. 变形前后size值保持一致
      2. reshape(size=())把原来的数组copy出一个副本对副本进行变形并返回
      3. resize(size=())直接在原数组上进行变形
    4. 级联
      1. 维度一致才能级联
      2. 形状相符才能级联（将axis的取值所在维度盖住看其他维度是否形状一致）
      3. axis 指定级联的方向
        针对于矩阵还有hstack() 和 vsrack()
        h 是把二维数组变成一维（行向量）
        v 是把一维数组变成 n 行 1 列的二维数组（列向量）
    5. 切分
      split(数组, [切分点, ... ...], axis=0 )
      vsplit纵向上切 切的是0维度
      hspilt横向上切 切的是1维度
  4. 矩阵运算
    1. 矩阵与矩阵 + - （两个矩阵之间形状size要一致）
    2. 矩阵与矩阵乘np.dot() 矩阵乘分为点乘(内积)和叉乘(外积)
    3. 矩阵与常数 * /
    4. 广播机制原则
      • 当向量或者常数与矩阵进行运算的时候， 可以把向量或者常数补全成矩阵的形状
      • 我们可以把一个常数按照任何一个矩阵的形状进行扩充
      • 向量和矩阵相加减（要求： 如果是行向量那么元素的个数要和矩阵的列数一致， 因为按行扩充）（如果是列向量， 那么行数要和矩阵的行数一致， 按列扩充）， 根据行数或者列数把向量进行扩充
  5. 数组的聚合
    • 完全聚合： 不指定 axis 的值， 则把所有的数据聚合在一起
    • 聚合时将 np.nan 剔除
    • 指定轴聚合： 用 axis 来指定对哪些维度进行聚合
      • axis 值等于哪个维度， 这个维度就会消失， 取而代之的是把这个维度上的子元素进行某种聚合的结果
pandas

Series、 DataFrame、 Pannel

  1. Series
    构成： index 和 values
 # 字典是 哈希结构（散列结构）， 数组是线性结构
 # 字典的查找（哈希算法找）效率比数组的查找（先找到首元素再根据下标）效率快，</pre>

series在查找的时候既可以用下标（隐式索引）来查找又可以用 index（显式索引）来查找

  1. DataFrame 数据表
    结构： index、 column、 values 分别代表行索引， 列索引， 值
    一个DataFrame 由多个Series构成， 按行的话， 每一行都是一个Series， 如果按列， 每一列都是一个Series
    • 创建
      • 数组： 指定index， colunms 和 values
      • 字典： 每个键值对应的是一列， 键代表这一列的列索引， 值代表这个列名下对应的那些值
        df = DataFrame({'a': [1, 2, 3, 4], 'b':[3, 4, 5, 6], 'c':[1, 5, 7, 8]})
    • 索引与切片
      • 索引列
        列不能直接用列名进行切片 df['a': 'c']
        df['a'] 或 df.a
      • 索引行
        显式 df.loc['a'] df.loc['a': 'c'] df.loc[['a', 'b', 'c']]
        隐式 df.iloc[0] df.iloc[0: 2] df.iloc[[0, 1, 1]]
    • 索引具体元素
      df['a'][0]
      df['a', 0] 这是错误的 不允许先列后行
      df.loc[0, 'a']
      df.loc[::, 'a':'c']
      df.iloc[::, 0: 2]
  2. DataFrame 的运算
    • DataFrame之间的运算
      遵从自动补全机制
    • DataFrame 和 Series 之间的运算
      如果Series 的 index 是行索引 在运算的时候要指定 axis 为 0，
      如果 Series的 index 是列索引 在运算的时候要指定 axis 为 1，
  3. 数据的过滤与清晰
    • 缺失值的处理
      标准的python缺失值np.nan
      检测具体某个位置的缺失 isnull() 和 notnull() 与 any() 和 all() 配合使用
      • 过滤 dropna(axis=0)
      • 填充 fillna() 用具体值填充， 向前填充， 向后填充
    • 异常值的处理
      在实际业务中规定某些范围的值就是异常值， 处理异常值也要根据实际业务（删除、 修正）
    • 重复值（行）
      不是第一次出现的都是重复
  4. 层次化索引
    • 层次化索引创建
    • 层次化索引的查找与切片
      只有暴露在最外层的索引才能直接查找与切片
    • 索引堆
      stack() 和 unstack()
      stack(level = -1) level 等于哪一层次， 她就会消失出现在列中
      unstack(level = -1) level 等于哪一层次， 她就会消失出现在列中
  5. 拼接
    • 级联 pd.concat([df1, df2], axis=0)
      • 简单级联
        对行级联， 列名一致
      • 不匹配级联
        对行级联， 列名不一致
        内连接join='outer'（不匹配的补nan）， 外连接join='inner'（不匹配的去掉）， 指定轴链接join_axes=[df1.columns]（只保留指定的轴）join_axes=[pd.Index(['A', 'C'])
    • 合并
      和并要求两个二维表有一个或者多个公共属性， 用公共属性作为合并的key值进行拼接；如果两个表没有公共属性那么不能直接合并
      • 一对一 df1.merge(df2)
      • 一对多 把一个复制成多份 再合并
      • 多对多 组合
        如果出现不匹配的情况则
      • 内合并：how='inner' 不匹配的部分剃掉
      • 外合并： 不匹配的地方补nan
      • 左合并： 按左边为基准合并
      • 右合并：
        多个公共属性时
      • 指定以某一属性为key df1.merge(df2, on=['name'], suffixes=['age1', 'age2'])
        没有公共属性时
      • df1.merge(df2, left_on=['name'], right_on=['名字'])
  6. 映射
    在一个关系表中把某些值和特定的键绑定在一起构成映射
如：
    {'a': 1, 'b': 2}
    y = 2 * x + 1, y = x ** 2 + 1
    def func(x):
     return x ** 2  # 函数 功能模块的封装(面向对象：继承，封装，多态)
    lambda x: x * 2 + 1

df1['job'][df1.job == 'driver'] = 'cooker'
替换元素 df.replace({'原来的元素': '替换的元素'})
根据已知列映射出新列 df['新的列名'] = df['已存在的列名'].map({'已存在列的元素': '映射结果'})

def func(x):
         if x > 60 :
         return '及格'
         else:
         return '不及格'
        # df['是否及格']  = df['成绩'].map(func)
  1. 分组聚合
    df.groupby['color'][['price']].sum() 按颜色求价格的和
  2. 绘图
    折线图、 柱状图、 直方图、概率密度曲线
scipy

高端科学计算工具包

  1. 傅里叶变换 fft()
    过滤高频信号
  2. 微积分 integrate.qual(积分方程， 积分上限， 积分下限) 
方程： y = x ** 2 在（x0, xn）的面积
     x0^2dx +  x1^2dx +  ... ... +  xn^2dx
     = f(0~2)x^2dx = （1/3）x^3|0~2 = 8/3 </pre>
  1. 图像处理
    移动 shift() 旋转 rotate() 缩放zoom()
    高斯滤波 from scipy import ndimage ndimage.gaussian_filter()
    中位数滤波 ndimage.median_filter()
    signal维纳滤波 from scipy import signal signal.wiener(moon, size=5)
matplotlib
  1. 图形基础
    matplotlib 中基本的绘图元素包括 坐标轴、 坐标轴刻度、 绘图区域、
    • 2D曲线
      单个 plot() 参数传一个数组或者两个数组
      多条： 用多个 plot() 函数绘制 用 plot.show() 统一显示 也可以 plt.plot(x1, y1, x2, y2, x3, y3)
      彩图转灰度图 可以使用 聚合， rgb加权
    • 2D曲线的属性设置
      网格线 plt， 轴面与子轴面， 坐标轴的样式与界限， 坐标轴的标签 plt.ysticks([-1, 0, 1])、 图例legend()
      线性 linestyle 样式 marker 颜色 color 背景色 透明度
    • 2D图形
      直方图 plt.hist、 条形图 plt.bar、 饼图 plt.pie、 散点图 plt.scatter、 玫瑰图（极坐标）
    • 3D图形

Machine learning

深度学习

神经网络： 基础神经网络， 俊基神经网络， 循环神经网络， 框架TensorFlow

监督学习算法

K nearest nerghbour

from sklearn.neighbours import KNerghborsClassifier， KNeighborsRegressor

LinearRegression *

from sklearn.linear_model import LinearRegression

lr = LinearRegression(fit_intercopt=True, noemalize=False, copy_X=True, n_jobs=None)
# fit_intercopt 是否计算截距
# noemalize在计算拮据的情况下， 回归前归一化， 回归因子X为减去均值,除以L2范数
# copy_X复制或覆盖
# n_jobs 采用多少CPU计算 n_jobs=-1 有多少用多少</pre>
  1. 线性方程
    y = w1x1 + w2x2 + ... ... + wnxn + b
    令 W = (w1, w2 ... ... wn)， X = (x1, x2, ... ... xn)
    则 y = W * X ^ T + b
    称 W 为回归系数， X 为特征向量， b 为截距
  2. 线性方程的推导
    现有 m 个已知样本， 每个样本有 n 个特征记为 X1, X2, ... ... , Xm 每个X中都有 n 个 x
    对应的标签记为： y1, y2, ... ... , ym ，且特征和标签成线性关系
    此时只要求得 W 就可得到线性回归方程
    ​ 将m个已知量带入方程会得到方程组：
    ​ y1 = W * X1 ^ T + b = w1x1_1 + w2x1_2 + ... ... + wnx1_n + b
    ​ y2 = W * X2 ^ T + b = w1x2_1 + w2x2_2 + ... ... + wnx2_n + b
    ​ ... ...
    ​ ym = W * Xm ^ T + b = w1xm_1 + w2xm_2 + ... ... + wnxm_n + b
    ​ 讨论： m > n 且无共线， 方程无解
    ​ m = n 且无共线， 有且只有一个解
    ​ m < n 无数个解
    ​ 在实际生产环境中 m >> n （样本数远远大于特征维度）， 所以上述方案行不通
  3. 最小二乘法
    • 假设 W’ 和 b‘ 是最合适的， 得到假设出来的回归方程： W‘ * X ^ T + b’
    • 把所有的样本带入， 得到假设的那些标签数据：
      y1' = W' * X1 ^ T + b'
      y2' = W' * X2 ^ T + b'
      ... ...
      ym' = W' * Xm ^ T + b'
      此时 y1', y2', ... .. , ym' 都是通过假设的 W' 和 b‘ 得到的标签， 那么真实的标签 y1, y2, ... .. , ym 和假设推导的标签之间一定存在差异
    • 求真实的标签和假设推导的标签之间存在的差异 (因为差异有正负 所以采用平方)
      H = (y1' - y1) ^ 2 + (y2' -y2) ^ 2 + ... ... + (ym' -ym) ^ 2
      将推导量带入得到
      H = (W'X1 ^ T - y1) ^ 2 + (W'X2 ^ T - y2) ^ 2 + ... ... + (W'Xm ^ T - ym) ^ 2
    • 求差异的最小值
      对 H 求导 为 0 得到极小值点
      H’ = 2[W' * X1 ^ T - X1 ^ T * y1] + ... + 2[W' * Xm ^ T - Xm ^ T * ym]
      令 X = （X1, X2, ... ... , Xm） Y = （y1, y2, ... ... , ym）
      H' = 2W'X^T - 2X^TY
      令 H‘ = 0 得到极小值
      W'X^T * X = X^TY * X
      X^T * X 是否可逆？
      • 如果可逆 W’ = （X ^ T * X）^(-1) * X ^ T * y * X
        行列式不等于0 满秩矩阵
      • 不可逆 引入岭回归 W'*(X^T * X + λI) = X^TY * X 【I是单位矩阵(对角线为1)， λ为缩减系数】
        此时 W‘ 的值除了受已知数据的影响以外还受 λ 的影响
        W' = (X^T * X + λI)^(-1) * X^TY * X
        from sklearn.linear_model import Ridge 改良的最小二乘法
        1.岭回归可以解决特征数量比样本量多的问题
        2.岭回归作为一种缩减算法可以判断哪些特征重要或者不重要，有点类似于降维的效果
        3.缩减算法可以看作是对一个模型增加偏差的同时减少方差
        岭回归用于处理下面两类问题：
        1.数据点少于变量个数
        2.变量间存在共线性（最小二乘回归得到的系数不稳定，方差很大）
      • from sklearn.learn_model import Lasso
        罗斯回归与岭回归的区别是罗斯回归采用L1正则：惩罚系数的绝对值

逻辑斯蒂

from sklearn.learn_model import LogisiticRegression
计算量非常小，速度很快，存储资源低，缺点就是因为模型简单，对于复杂的情况下会出现欠拟合，并且只能处理2分类问题， 信用评测， 营销活动成功率概率， 产品销售预测，

​ 特征向量: X = (x1, x2, ... ... , xn)

​ 回归系数: W = (w1, w2, ... ... , wn)

​ 截距: b

​ 标签: Y

​ 如果 Y 和 X 成线性关系， 且 Y 是连续的， 则可以表示成： Y = W * X ^ T + b

朴素贝叶斯

from sklearn.naive_bayes import GaussianNB, MultionmialNB, BernoulliNB

高斯， 多项式文本分类， 伯努利文本分类多适用于小型文本，

  1. 条件概率

    P(A|B) = P(AB) / P(B) <===> P(AB) = P(A|B)P(B)

    在 B 已经发生的基础上 A 发生的概率， A 和 B 是相互独立事件

  2. 全概率

    全概率公式表达的是由因溯果

  3. 贝叶斯公式

    由果溯因， 事件已经发生， 推测是哪个因素造成的

  4. 朴素贝叶斯分类器基于贝叶斯理论及其假设（即特征之间是独立的，互不相互影响的）

    P(A|B) = P(B|A)P(A) / P(B)

    P(A|B) 是后验概率， P(B|A)是似然 P(A)是先验概率 ，P(B)是预测的值

    具体应用： 垃圾邮件检测， 文章分类， 情感分类， 人脸识别

SVM *

from sklearn.svm import SVC, SVR

在N维空间找到一个（N-1）维的超平面将样本空间分为两类。

具体应用： 广告展示， 性别检测， 大规模图像识别

通过核函数，支持向量机可以将特征向量映射到更高维的空间中，是的原本线性不可分的数据在映射之后的空间中变得线性可分。

在是显示不需要直接对特征向量做映射，耳式用核函数对两个特征响亮的内积进行变换，这样做等价于先对箱量进行映射然后做内积。

[图片上传失败...(image-3f220a-1551434906070)]

决策树 *

from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor

线性结构（列表 栈 队列）、 散列结构 、 树形结构 （至多有一个前驱， 可以有多个后继） 、 网络结构（有方向的图）

 class sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best', max_depth=None, min_samples_split=2,min_samples_leaf =1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None,class_weight=None, presort=False)
    '''
    criterion:string类型，可选（默认为"gini"）
     衡量分类的质量。支持的标准有"gini"代表的是Gini impurity(不纯度)与"entropy"代表的是information gain（信息增益）。
    ​
    splitter:string类型，可选（默认为"best"）
     一种用来在节点中选择分类的策略。支持的策略有"best"，选择最好的分类，"random"选择最好的随机分类。
    ​
    max_features:int,float,string or None 可选（默认为None）
     在进行分类时需要考虑的特征数。
     1.如果是int，在每次分类是都要考虑max_features个特征。
     2.如果是float,那么max_features是一个百分率并且分类时需要考虑的特征数是int(max_features*n_features,其中n_features是训练完成时发特征数)。
     3.如果是auto,max_features=sqrt(n_features)
     4.如果是sqrt,max_features=sqrt(n_features)
     5.如果是log2,max_features=log2(n_features)
     6.如果是None，max_features=n_features
     注意：至少找到一个样本点有效的被分类时，搜索分类才会停止。
    ​
    max_depth:int or None,可选（默认为"None"）
     表示树的最大深度。如果是"None",则节点会一直扩展直到所有的叶子都是纯的或者所有的叶子节点都包含少于min_samples_split个样本点。忽视max_leaf_nodes是不是为None。
    ​
    min_samples_split:int,float,可选（默认为2）
     区分一个内部节点需要的最少的样本数。
     1.如果是int，将其最为最小的样本数。
     2.如果是float，min_samples_split是一个百分率并且ceil(min_samples_split*n_samples)是每个分类需要的样本数。ceil是取大于或等于指定表达式的最小整数。
    ​
    min_samples_leaf:int,float,可选（默认为1）
     一个叶节点所需要的最小样本数：
     1.如果是int，则其为最小样本数
     2.如果是float，则它是一个百分率并且ceil(min_samples_leaf*n_samples)是每个节点所需的样本数。
    ​
    min_weight_fraction_leaf:float,可选（默认为0）
     一个叶节点的输入样本所需要的最小的加权分数。
    ​
    max_leaf_nodes:int,None 可选（默认为None）
     在最优方法中使用max_leaf_nodes构建一个树。最好的节点是在杂质相对减少。如果是None则对叶节点的数目没有限制。如果不是None则不考虑max_depth.
    ​
    class_weight:dict,list of dicts,"Banlanced" or None,可选（默认为None）
     表示在表{class_label:weight}中的类的关联权值。如果没有指定，所有类的权值都为1。对于多输出问题，一列字典的顺序可以与一列y的次序相同。
     "balanced"模型使用y的值去自动适应权值，并且是以输入数据中类的频率的反比例。如：n_samples/(n_classes*np.bincount(y))。
     对于多输出，每列y的权值都会想乘。
     如果sample_weight已经指定了，这些权值将于samples以合适的方法相乘。
    ​
    random_state:int,RandomState instance or None
     如果是int,random_state 是随机数字发生器的种子；如果是RandomState，random_state是随机数字发生器，如果是None，随机数字发生器是np.random使用的RandomState instance.
    ​
    persort:bool,可选（默认为False）
     是否预分类数据以加速训练时最好分类的查找。在有大数据集的决策树中，如果设为true可能会减慢训练的过程。当使用一个小数据集或者一个深度受限的决策树中，可以减速训练的过程。
    '''
    decision_tree.feature_importances_  # 查看属性的重要性
    ​
    绘制一棵决策树 pip install graphviz (并配置环境变量)
    import graphviz
    dot = sklearn.tree.export_graphviz(decison_tree, out_file=None, max_depth=None, filled=None)
    graphviz.Source(dot)  # filled 填充颜色</pre>

决策树算法

  1. 决策树的定义：
    用非叶子表示模型的特征

    用叶子节点来表示标签

    每一个分支都是当前特征在特定值域上的输出

  2. 如何构造以可决策树

    关键： 属性的分裂， 如何在某个节点处根据属性的不同构造不同的输出

    理论基础： 信息论

    三种情况

    • 属性是离散的并且不要求构建二叉树（有多少中取值就够贱多少个分支）
    • 属性是离散的需要构建二叉树（将离散的标签按照需求归类）
    • 属性是连续的（取若干个区间 将对应的值划分到区间中进行分类）
ID3 算法
C4.5决策树：

为了解决ID3决策树的缺点：当一个属性值可取数目较多时， 那么可能这个属性对应的可取值下的样本只有一个或者很少个， 此时信息增益非常高， ID3算法会认为这个属性非常适合用来划分， 但较多属性来进行划分带来的问题是他的泛化能力很弱， 不能对新样本进行有效的预测。

所以C4.5 采用信息增益率来作为划分依据：

但是增增益率会偏好取值数目较少的属性， 因此C4.5决策树会先从候选划分属性中找出信息增益高于平均水平的属性，再从中选择增益率最高的

CART 算法：

  1. 也叫分类回归树， 既能分类有能回归

    CART是一颗二叉树

    如果是CART分类树， 采用GINI值来作为节点分裂的依据；如果是CART回归树， 采用样本的最小方差作为节点的分裂依据

  2. 如何选择分裂属性

  1. 如何分裂成一颗二叉树

    ​

集成算法

ada，gbdt, xgboost 常用 max_depth = 6, 而 decision_tree , randomForest 常用 max_depth = 15

boosting 提升

学习器之间存在先后顺序，初始时。每个样本的权重相等，首先第一个学习器训练样本进行学习，学习完成后，增大错误样本的权重，同时减小正确样本的权重，再利用第二个学习期对其进行学习，依次进行下去，最终得到b个学习器。最终合并b个学习其的结果，同时与bagging的不同的是，每个学习器的权重也不一样。

Adaboost

from sklearn.ensemble import AdaBoostClassidier

重复选择表现一般的模型，每次基于先前模型的表现进行调整， 不同的是 ada是通过提升数据点的权重来定位模型的不足，而gbdt是通过算梯度定位模型的不足，因此 gbdt可使用更多种类的不妙函数，而这主要区别在于 识别模型的问题，ada用错分数据来识别问题，通过调整错分数据的权重来进行模型的改进。 gbdt梯度提升树通过计算梯度来改进。

GBDT

CART 作为基分类器。

每棵树学的是之前树的残差（预测值为前面所有树累加的和）

后面的学习器纠正前面的所有若学习器的残差，最终将多个学习器像加在一起用来进行最终的预测（每一次计算都是为了减少上一次的残差，即利用残差学模型， 为了消除残差，会在残差减少的梯度方向上减少一个新的模型）

梯度提升树 进行特征重要性排序

from sklearn.ensemble import GradientBosstingClassifier
gbdt = GradientBosstingClassifier(n_estimators,learning_rate=0.2, )
gbdt.fit(data, target)
fi = gbdt.feature_importances_.argsort()[::-1]  # 特征重要性的索引排序
​</pre>
XGBOOST

pip install xgboost GBDT 的极端化，2014年 陈天奇

from xgboost.sklearn import XGBClassifier

支持线性分类器，相当于带L1 和L2 正则化项的LR或线性回归。

xgboost,plot_importance(xgb) 显示属性重要性排序

xgboost.plot_tree(xgb, num_tree=0,ax=axes) 绘制索引为0的树

构造损失函数： 真实值与预测值的 均方误差/ 似然函数

求损失函数的最小值

用集成学习算法表示预测值 yi' = f1(xi) + f2(xi) + ... ... + fk(xi), f代表每一棵树映射函数

找到最合适的 K

bagging 套袋

关注降低方差：度量了同等大小的训练集的变动导致学习性能的变化。刻画了数据扰动所导致的影响。

通过对训练样本重新采样的方法得到不同的训练样本集，在这些新的训练样本集上分别训练学习器，最终合并每一个学习器的结果，作为最终的学习结果。

随机森林

from sklearn.ensemble import RandomForestClassifier

确定森林中的树是 CART 二叉树

  1. 样本随机： 从样本中随机有放回的抽取 n 个样本（样本有重复）

  2. 特征随机： 从所有的属性中随机选取 k 个属性， 选择最佳的分割属性作为节点建立决策树

  3. 重复以上步骤 m 次， 即建立 m 棵CART决策树

  4. 这 m 棵CART树形成随机森林， 通过投票表决结果， 决定数据属于哪一类

    投票机制： 一票否决、 少数服从多数、 加权

模型调参：

RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_split=1e-07, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=1, oob_score=True, random_state=10, verbose=0, warm_start=False)
--------------------- 
- 选取 K 值
- 设置最大深度（一般不超过8）
- 棵数
- 最小分裂样本数
- 类别比例

无监督学习

聚类

K-means * from sklearn.cluster import KMeans

KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,n_clusters=8, 
 n_init=10, n_jobs=None, precompute_distances='auto',random_state=None, 
 tol=0.0001, verbose=0)

训练过程： 根据 K-means++ 选取 8 个种子点， 计算所有样本点到每一个种子点的欧氏距离， 取这个样本点距离最近的那个种子点， 该样本点就划归为这个种子点的簇。将种子点移动到该簇的几何中心， 再循环上面的操作， 直至种子点不再移动为止。 最后得到八个有序号的簇（不是标签， 因为多次训练序号可能会发生改变）

预测 km.predict(digits_x_train) 得到的是所属的簇的序号

digits_y_pre = km.predict(digits_x_test) 预测的簇的序号

​
​</pre>

clusters = [2,3,4,5,6,7,8,9,10]
    scores = []
    for cluster in clusters:
     km = KMeans(n_clusters=cluster)
     km.fit(digits_data)
     labels = km.labels_
     score = silhouette_score(digits_data, labels)
     scores.append(score)

    import matplotlib.pyplot as plt
    %matplotlib inline
    plt.plot(clusters, scores)
    plt.show()</pre>

聚类算法有多种： 中心聚类，关联聚类，密度聚类，概率聚类，降维，圣经网络/深度学习

数据升维

多项式特征生成器

from sklearn.preprocessing import PolynomialFeatures

特征降维

PCA *

from sklearn.decomposition impoprt PCA

在数据挖掘的过程中， 某些属性之间存在相关性， 可以抹去或者通过某些算法把他们映射到更低的维度， 从而提高机器学习的效率和准确率。

SVD矩阵分解
LDA
独立成分分析（ICA)

与PCA相关， 但他在发现潜在因素方面效果良好，它可以应用在数字图像、当问数据库、经济指标、心理测量等

SMOTE

针对类不均衡的过采样算法

from imblearn.over_sampling import SMOTE
    smote = SMOTE()
    target.value_counts()  # 观察是否存在样本不均衡问题
    data, target = smote.fit_sample(data, target)
    # 通过以上过采样算法后 （target==0).sum()  与  (target==1).sum() 数量一样多</pre>

缺陷：

预处理

from sklearn.preprocessing import MinMaxScaler
MinMaxScaler().fit_transform(data)
# (data-min(data)) / max(data) - min(data)</pre>

目的：

  1. 对于方差较小的属性可以增加其稳定性，
  2. 维持稀疏矩阵中0的条目，
  3. 防止过大的属性对模型起过份主导作用
from sklearn.preprocessing import StandardScaler
StandardScaler().fit_transform(data)
        ​
# (data - data.mean())/ data.std() 服从标准正态分布</pre>

from sklearn.preprocessing import Normalizer
Normalizer().fit_transform(data)
# 默认为L2正则化</pre>

模型评测指标

每个模型都自带有一个性能检测方法， score 在性能检测过程中会把 data 带入模型中进行训练并得到预测值， 然后求预测值和 target 的吻合程度（准确度， 从宏观上表达了预测数据和真实数据的差别）

性能检测报告

栗子：有两个类别 A 和 B 预测结果有4种 TrueA，TrueB，FalseA，FalseB

精确率： 表示每一个类别预测正确的数量占预测为该类别的数量的比例

Preision_A = TrueA/(TrueA+FalseA),Preision_B = TrueB/(TrueB+FalseB)

召回率： 表示每一个类别预测正确的数量占真正为该类别的数量的比例

Recall_A = TrueA/(TrueA+FalseB)

F1指标： 精确率和召回率的调和平均数， 如果两个指标相近，那么调和平均数的值就大

F1_A = 2/(1/Precision_A + 1/Recall_A)

【注意】在评测一个模型的时候如果某个标签精确率和召回率偏差过大，则该模型在预测该类别的时候的预测结果就不具备参考价值

交叉验证

from sklearn.model_selection import cross_val_score
# 实例化算法模型
knn = KNeighborsClassifier()
dt = DecisionTreeClassifier()
# 输出划分对应类别时的准确率
cross_val_score(dt, data, target)
cross_val_score(knn, data, target)
# 根据需求选取更适合的算法</pre>

网格搜索算法参数调优

from sklearn.model_selection import GridSearchCV
​
# K近邻分类模型
GridSearchCV(knn,param_grid={"n_neighbors": [i for i in range(1, 21)]})
# 岭回归模型
GridSearchCV(ridge,param_grid={"alpha": [10**i for i in range(-20, 6)]})
# 逻辑斯蒂分类模型
GridSearchCV(lgs,param_grid={"C":[10**i for i in range(-3, 2)]})
# 梯度下降模型 可以调节学习率 alpha
# 决策树模型 通过调节 max_depth 最大深度
# 支持向量机 
GridSearchCV(svc,param_grid={"C":[0.5,1.0,3,5,2],"kernel":["poly","rbf"],"gamma":[0.1,0.2,0.5,1,2]})
''' 
C惩罚参数（惩罚参数越大，惩罚程度越大， 容错率越小）
kernel，核函数，决定模型是线性还某种非线性，linear、rbf、poly、sigmoid、precomputed 例如rbf核函数:exp(-gamma|u-v|^2) sigmoid核函数：1/(1+ e^(-gamma*Z))
gamma，即是核函数的参数值，默认是auto，则选择1/n_feature
'''
​
gsc.best_estimator_  # 最优参数组合的模型</pre>
上一篇 下一篇

猜你喜欢

热点阅读