【01】机器学习概述+特征工程

机器学习概述

1 定义

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

2.解释

• 我们人从大量的日常经验中归纳规律，当面临新的问题的时候，就可以利用以往总结的规律去分析现实状况，采取最佳策略。

• 从数据（大量的猫和狗的图片）中自动分析获得模型（辨别猫和狗的规律），从而使机器拥有识别猫和狗的能力。

• 从数据（房屋的各种信息）中自动分析获得模型（判断房屋价格的规律），从而使机器拥有预测房屋价格的能力。

从历史数据当中获得规律？这些历史数据是怎么的格式？

3.数据集构成

• 结构：特征值+目标值

  • 对于每一行数据我们可以称之为样本。

  • 有些数据集可以没有目标值：

    • 特征值：人物的各个属性信息；目标值：无
      • 无监督学习

4. 机器学习算法分类

• 监督学习(supervised learning)（预测）
  • 定义：输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续的值(称为回归），或是输出是有限个离散值（称作分类）。
  • 分类 k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络
  • 回归 线性回归、岭回归
• 无监督学习(unsupervised learning)
  • 定义：输入数据是由输入特征值所组成。
  • 聚类 k-means

5.机器学习开发流程

特征工程

1.数据集

可用数据集

• Kaggle网址：https://www.kaggle.com/datasets
• UCI数据集网址： http://archive.ics.uci.edu/ml/
• scikit-learn网址：http://scikit-learn.org/stable/datasets/index.html#datasets

2.Scikit-learn包含的内容

(1)scikitlearn接口

• 分类、聚类、回归

• 特征工程
• 模型选择、调优

(2)sklearn数据集

① scikit-learn数据集API介绍

• sklearn.datasets
  • 加载获取流行数据集
  • datasets.load_*()
    • 获取小规模数据集，数据包含在datasets里
  • datasets.fetch_*(data_home=None)
    • 获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录,默认是 ~/scikit_learn_data/

② sklearn小数据集

• sklearn.datasets.load_iris()

  加载并返回鸢尾花数据集

• sklearn.datasets.load_boston()

  加载并返回波士顿房价数据集

③ sklearn大数据集

• sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)
  • subset：‘train’或者’test’，‘all’，可选，选择要加载的数据集。
  • 训练集的“训练”，测试集的“测试”，两者的“全部”

④sklearn数据集的使用

• sklearn数据集返回值介绍

  • load和fetch返回的数据类型datasets.base.Bunch(字典格式)
    • data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组
    • target：标签数组，是 n_samples 的一维 numpy.ndarray 数组
    • DESCR：数据描述
    • feature_names：特征名,新闻数据，手写数字、回归数据集没有
    • target_names：标签名

from sklearn.datasets import load_iris
# 获取鸢尾花数据集
iris = load_iris()
print("鸢尾花数据集的返回值：\n", iris)
# 返回值是一个继承自字典的Bench
print("鸢尾花的特征值:\n", iris["data"])
print("鸢尾花的目标值：\n", iris.target)
print("鸢尾花特征的名字：\n", iris.feature_names)
print("鸢尾花目标值的名字：\n", iris.target_names)
print("鸢尾花的描述：\n", iris.DESCR)

⑤数据集的划分

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

• 训练数据：用于训练，构建模型
• 测试数据：在模型检验时使用，用于评估模型是否有效

划分比例：

• 训练集：70% 80% 75%
• 测试集：30% 20% 30%

数据集划分api

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

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


def datasets_demo():
    """
    对鸢尾花数据集的演示
    :return: None
    """
    # 1、获取鸢尾花数据集
    iris = load_iris()
    print("鸢尾花数据集的返回值：\n", iris)
    # 返回值是一个继承自字典的Bench
    print("鸢尾花的特征值:\n", iris["data"])
    print("鸢尾花的目标值：\n", iris.target)
    print("鸢尾花特征的名字：\n", iris.feature_names)
    print("鸢尾花目标值的名字：\n", iris.target_names)
    print("鸢尾花的描述：\n", iris.DESCR)

    # 2、对鸢尾花数据集进行分割
    # 训练集的特征值x_train 测试集的特征值x_test 训练集的目标值y_train 测试集的目标值y_test
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    print("x_train:\n", x_train.shape)
    # 随机数种子
    x_train1, x_test1, y_train1, y_test1 = train_test_split(iris.data, iris.target, random_state=6)
    x_train2, x_test2, y_train2, y_test2 = train_test_split(iris.data, iris.target, random_state=6)
    print("如果随机数种子不一致：\n", x_train == x_train1)
    print("如果随机数种子一致：\n", x_train1 == x_train2)

    return None

3.特征工程的内容

（1）为什么需要特征工程？

机器学习领域的大神Andrew Ng(吴恩达)老师说“Coming up with features is difficult, time-consuming, requires expert knowledge. “Applied machine learning” is basically feature engineering. ”

注：业界广泛流传：数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。

（2）什么是特征工程

特征工程是使用专业背景知识和技巧处理数据，使得特征能在机器学习算法上发挥更好的作用的过程。

• 意义：会直接影响机器学习的效果

（3）特征工程与数据处理的比较

• pandas:一个数据读取非常方便以及基本的处理格式的工具
• sklearn:对于特征的处理提供了强大的接口

特征工程包含内容

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

4.特征抽取

（1）定义

• 将任意数据（如文本或图像）转换为可用于机器学习的数字特征

  • 注：特征值化是为了计算机更好的去理解数据

  • 字典特征提取(特征离散化)

  • 文本特征提取

  • 图像特征提取（深度学习将介绍）

（2）特征提取API

sklearn.feature_extraction

①字典特征提取

对于特征当中存在类别信息的我们都会做one-hot编码处理

作用：对字典数据进行特征值化

• sklearn.feature_extraction.DictVectorizer(sparse=True,…)
  • DictVectorizer.fit_transform(X) X:字典或者包含字典的迭代器返回值：返回sparse矩阵
  • DictVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值:转换之前数据格式
  • DictVectorizer.get_feature_names() 返回类别名称

• 示例

  • 我们对以下数据进行特征提取

    [{'city': '北京','temperature':100}
    {'city': '上海','temperature':60}
    {'city': '深圳','temperature':30}]
    

• 流程分析

  • 实例化类DictVectorizer
  • 调用fit_transform方法输入数据并转换（注意返回格式）

from sklearn.feature_extraction import DictVectorizer
def dict_demo():
    """
    对字典类型的数据进行特征抽取
    :return: None
    """
    data = [{'city': '北京','temperature':100}, {'city': '上海','temperature':60}, {'city': '深圳','temperature':30}]
    # 1、实例化一个转换器类
    transfer = DictVectorizer(sparse=True)
    # 2、调用fit_transform
    data = transfer.fit_transform(data)
    print("返回的结果:\n", data)
    # 打印特征名字
    print("特征名字：\n", transfer.get_feature_names())

    return None
"""
返回的结果:
 [[   0.    1.    0.  100.]
 [   1.    0.    0.   60.]
 [   0.    0.    1.   30.]]
特征名字：
 ['city=上海', 'city=北京', 'city=深圳', 'temperature']
"""

②文本特征抽取

作用：对文本数据进行特征值化

• sklearn.feature_extraction.text.CountVectorizer(stop_words=[])

  • 返回词频矩阵

• CountVectorizer.fit_transform(X) X:文本或者包含文本字符串的可迭代对象 返回值：返回sparse矩阵

• CountVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值:转换之前数据格

• CountVectorizer.get_feature_names() 返回值:单词列表

• sklearn.feature_extraction.text.TfidfVectorizer

• 应用

我们对以下数据进行特征提取

["life is short,i like python",
"life is too long,i dislike python"]

• 流程分析

  • 实例化类CountVectorizer

  • 调用fit_transform方法输入数据并转换 （注意返回格式，利用toarray()进行sparse矩阵转换array数组）

from sklearn.feature_extraction.text import CountVectorizer

def text_count_demo():
    """
    对文本进行特征抽取，countvetorizer
    :return: None
    """
    data = ["life is short,i like like python", "life is too long,i dislike python"]
    # 1、实例化一个转换器类
    # transfer = CountVectorizer(sparse=False)
    transfer = CountVectorizer()
    # 2、调用fit_transform
    data = transfer.fit_transform(data)
    print("文本特征抽取的结果：\n", data.toarray())
    print("返回特征名字：\n", transfer.get_feature_names())

    return None
"""
文本特征抽取的结果：
 [[0 1 1 2 0 1 1 0]
 [1 1 1 0 1 1 0 1]]
返回特征名字：
 ['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']
 """

• 问题:如果我们将数据替换成中文？

"人生苦短，我喜欢Python" "生活太长久，我不喜欢Python"

那么最终得到的结果是

• 为什么会得到这样的结果呢，仔细分析之后会发现英文默认是以空格分开的。其实就达到了一个分词的效果，所以我们要对中文进行分词处理

③jieba分词处理

• jieba.cut()
  • 返回词语组成的生成器

• 例子

  • 对以下三句话进行特征值化

  今天很残酷，明天更残酷，后天很美好，
  但绝对大部分是死在明天晚上，所以每个人不要放弃今天。
  
  我们看到的从很远星系来的光是在几百万年之前发出的，
  这样当我们看到宇宙时，我们是在看它的过去。
  
  如果只用一种方式了解某样事物，你就不会真正了解它。
  了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。
  

  • 分析
    • 准备句子，利用jieba.cut进行分词
    • 实例化CountVectorizer
    • 将分词结果变成字符串当作fit_transform的输入值

• 案例

  • from sklearn.feature_extraction.text import CountVectorizer
    import jieba
    
    def cut_word(text):
        """
        对中文进行分词
        "我爱北京天安门"————>"我 爱 北京 天安门"
        :param text:
        :return: text
        """
        # 用结巴对中文字符串进行分词
        text = " ".join(list(jieba.cut(text)))
    
        return text
    
    def text_chinese_count_demo2():
        """
        对中文进行特征抽取
        :return: None
        """
        data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
                "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
                "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
        # 将原始数据转换成分好词的形式
        text_list = []
        for sent in data:
            text_list.append(cut_word(sent))
        print(text_list)
    
        # 1、实例化一个转换器类
        # transfer = CountVectorizer(sparse=False)
        transfer = CountVectorizer()
        # 2、调用fit_transform
        data = transfer.fit_transform(text_list)
        print("文本特征抽取的结果：\n", data.toarray())
        print("返回特征名字：\n", transfer.get_feature_names())
    
        return None
    

    返回结果：

    Building prefix dict from the default dictionary ...
    Dumping model to file cache /var/folders/mz/tzf2l3sx4rgg6qpglfb035_r0000gn/T/jieba.cache
    Loading model cost 1.032 seconds.
    ['一种 还是 一种 今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']
    Prefix dict has been built succesfully.
    文本特征抽取的结果：
     [[2 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 1 0]
     [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 0 1]
     [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0 0]]
    返回特征名字：
     ['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '还是', '这样']
    

该如何处理某个词或短语在多篇文章中出现的次数高这种情况

④Tf-idf文本特征提取

• TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。

• TF-IDF作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。

• 公式

  • 词频（term frequency，tf）指的是某一个给定的词语在该文件中出现的频率
  • 逆向文档频率（inverse document frequency，idf）是一个词语普遍重要性的度量。某一特定词语的idf，可以由总文件数目除以包含该词语之文件的数目，再将得到的商取以10为底的对数得到

  

  最终得出结果可以理解为重要程度。

  注：假如一篇文件的总词语数是100个，而词语"非常"出现了5次，那么"非常"一词在该文件中的词频就是5/100=0.0
  

• 案例

  • from sklearn.feature_extraction.text import TfidfVectorizer
    import jieba
    
    def cut_word(text):
        """
        对中文进行分词
        "我爱北京天安门"————>"我 爱 北京 天安门"
        :param text:
        :return: text
        """
        # 用结巴对中文字符串进行分词
        text = " ".join(list(jieba.cut(text)))
    
        return text
    
    def text_chinese_tfidf_demo():
        """
        对中文进行特征抽取
        :return: None
        """
        data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
                "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
                "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
        # 将原始数据转换成分好词的形式
        text_list = []
        for sent in data:
            text_list.append(cut_word(sent))
        print(text_list)
    
        # 1、实例化一个转换器类
        # transfer = CountVectorizer(sparse=False)
        transfer = TfidfVectorizer(stop_words=['一种', '不会', '不要'])
        # 2、调用fit_transform
        data = transfer.fit_transform(text_list)
        print("文本特征抽取的结果：\n", data.toarray())
        print("返回特征名字：\n", transfer.get_feature_names())
    
        return None
    

  • 返回结果

  • Building prefix dict from the default dictionary ...
    Loading model from cache /var/folders/mz/tzf2l3sx4rgg6qpglfb035_r0000gn/T/jieba.cache
    Loading model cost 0.856 seconds.
    Prefix dict has been built succesfully.
    ['一种 还是 一种 今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']
    文本特征抽取的结果：
     [[ 0.          0.          0.          0.43643578  0.          0.          0.
       0.          0.          0.21821789  0.          0.21821789  0.          0.
       0.          0.          0.21821789  0.21821789  0.          0.43643578
       0.          0.21821789  0.          0.43643578  0.21821789  0.          0.
       0.          0.21821789  0.21821789  0.          0.          0.21821789
       0.        ]
     [ 0.2410822   0.          0.          0.          0.2410822   0.2410822
       0.2410822   0.          0.          0.          0.          0.          0.
       0.          0.2410822   0.55004769  0.          0.          0.          0.
       0.2410822   0.          0.          0.          0.          0.48216441
       0.          0.          0.          0.          0.          0.2410822
       0.          0.2410822 ]
     [ 0.          0.644003    0.48300225  0.          0.          0.          0.
       0.16100075  0.16100075  0.          0.16100075  0.          0.16100075
       0.16100075  0.          0.12244522  0.          0.          0.16100075
       0.          0.          0.          0.16100075  0.          0.          0.
       0.3220015   0.16100075  0.          0.          0.16100075  0.          0.
       0.        ]]
    返回特征名字：
     ['之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '还是', '这样']
    

5.特征预处理

（1）定义

• 通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程

（2）包含内容

• 数值型数据的无量纲化：
  • 归一化
  • 标准化
• 对于归一化来说：如果出现异常点，影响了最大值和最小值，那么结果显然会发生改变
• 对于标准化来说：如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小。

（3）特征预处理API

sklearn.preprocessing

（4）特征预处理意义与流程

①为什么我们要进行归一化/标准化？

• 特征的单位或者大小相差较大，或者某特征的方差相比其他的特征要大出几个数量级，容易影响（支配）目标结果，使得一些算法无法学习到其它的特征
• 注意最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景。

②归一化

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

• 

  • 作用于每一列，max为一列的最大值，min为一列的最小值,那么X’’为最终结果，mx，mi分别为指定区间值默认mx为1,mi为0

• 

• API

  • sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )
    • MinMaxScalar.fit_transform(X)
      • X:numpy array格式的数据[n_samples,n_features]
    • 返回值：转换后的形状相同的array

• 案例

  • milage,Liters,Consumtime,target
    40920,8.326976,0.953952,3
    14488,7.153469,1.673904,2
    26052,1.441871,0.805124,1
    75136,13.147394,0.428964,1
    38344,1.669788,0.134296,1
    

  • 分析

    • 实例化MinMaxScalar

    • 通过fit_transform转换

    • import pandas as pd
      from sklearn.preprocessing import MinMaxScaler
      
      def minmax_demo():
          """
          归一化演示
          :return: None
          """
          data = pd.read_csv("dating.txt")
          print(data)
          # 1、实例化一个转换器类
          transfer = MinMaxScaler(feature_range=(2, 3))
          # 2、调用fit_transform
          data = transfer.fit_transform(data[['milage','Liters','Consumtime']])
          print("最小值最大值归一化处理的结果：\n", data)
      
          return None
      

      返回结果：

           milage     Liters  Consumtime  target
      0     40920   8.326976    0.953952       3
      1     14488   7.153469    1.673904       2
      2     26052   1.441871    0.805124       1
      3     75136  13.147394    0.428964       1
      ..      ...        ...         ...     ...
      998   48111   9.134528    0.728045       3
      999   43757   7.882601    1.332446       3
      
      [1000 rows x 4 columns]
      最小值最大值归一化处理的结果：
       [[ 2.44832535  2.39805139  2.56233353]
       [ 2.15873259  2.34195467  2.98724416]
       [ 2.28542943  2.06892523  2.47449629]
       ..., 
       [ 2.29115949  2.50910294  2.51079493]
       [ 2.52711097  2.43665451  2.4290048 ]
       [ 2.47940793  2.3768091   2.78571804]]
      

③标准化

• 在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

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

• 

  • 作用于每一列，mean为平均值，σ为标准差

• API

  • sklearn.preprocessing.StandardScaler( )
    • 处理之后每列来说所有数据都聚集在均值0附近标准差差为1
    • StandardScaler.fit_transform(X)
      • X:numpy array格式的数据[n_samples,n_features]
    • 返回值：转换后的形状相同的array

• 例子

  • 实例化StandardScaler

  • 通过fit_transform转换

  • import pandas as pd
    from sklearn.preprocessing import StandardScaler
    
    def stand_demo():
        """
        标准化演示
        :return: None
        """
        data = pd.read_csv("dating.txt")
        print(data)
        # 1、实例化一个转换器类
        transfer = StandardScaler()
        # 2、调用fit_transform
        data = transfer.fit_transform(data[['milage','Liters','Consumtime']])
        print("标准化的结果:\n", data)
        print("每一列特征的平均值：\n", transfer.mean_)
        print("每一列特征的方差：\n", transfer.var_)
    
        return None
    

    返回结果：

         milage     Liters  Consumtime  target
    0     40920   8.326976    0.953952       3
    1     14488   7.153469    1.673904       2
    2     26052   1.441871    0.805124       1
    ..      ...        ...         ...     ...
    997   26575  10.650102    0.866627       3
    998   48111   9.134528    0.728045       3
    999   43757   7.882601    1.332446       3
    
    [1000 rows x 4 columns]
    标准化的结果:
     [[ 0.33193158  0.41660188  0.24523407]
     [-0.87247784  0.13992897  1.69385734]
     [-0.34554872 -1.20667094 -0.05422437]
     ..., 
     [-0.32171752  0.96431572  0.06952649]
     [ 0.65959911  0.60699509 -0.20931587]
     [ 0.46120328  0.31183342  1.00680598]]
    每一列特征的平均值：
     [  3.36354210e+04   6.55996083e+00   8.32072997e-01]
    每一列特征的方差：
     [  4.81628039e+08   1.79902874e+01   2.46999554e-01]
    

6.特征降维

（1）定义

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

• 相关特征(correlated feature)
  • 相对湿度与降雨量之间的相关
  • 等等

正是因为在进行训练的时候，我们都是使用特征进行学习。如果特征本身存在问题或者特征之间相关性较强，对于算法学习预测会影响较大

（2）降维的两种方式

• 特征选择
• 主成分分析（可以理解一种特征提取的方式）

①特征选择

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

②方法

• Filter(过滤式)：主要探究特征本身特点、特征与特征和目标值之间关联
  • 方差选择法：低方差特征过滤
  • 相关系数
• Embedded (嵌入式)：算法自动选择特征（特征与目标值之间的关联）
  • 决策树:信息熵、信息增益
  • 正则化：L1、L2
  • 深度学习：卷积等

对于Embedded方式，只能在讲解算法的时候在进行介绍，更好的去理解

③模块

sklearn.feature_selection

④过滤式

1）低方差特征过滤

• 定义

  • 删除低方差的一些特征，前面讲过方差的意义。再结合方差的大小来考虑这个方式的角度。

  • 特征方差小：某个特征大多样本的值比较相近

  • 特征方差大：某个特征很多样本的值都有差别

• API

  • sklearn.feature_selection.VarianceThreshold(threshold = 0.0)
    • 删除所有低方差特征
    • Variance.fit_transform(X)
      • X:numpy array格式的数据[n_samples,n_features]
      • 返回值：训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征。

• 例子

  • 我们对某些股票的指标特征之间进行一个筛选，数据在"factor_regression_data/factor_returns.csv"文件当中,除去’index,‘date’,'return’列不考虑**（这些类型不匹配，也不是所需要指标）**

    一共这些特征

    pe_ratio,pb_ratio,market_cap,return_on_asset_net_profit,du_return_on_equity,ev,earnings_per_share,revenue,total_expense
    

    index,pe_ratio,pb_ratio,market_cap,return_on_asset_net_profit,du_return_on_equity,ev,earnings_per_share,revenue,total_expense,date,return
    0,000001.XSHE,5.9572,1.1818,85252550922.0,0.8008,14.9403,1211444855670.0,2.01,20701401000.0,10882540000.0,2012-01-31,0.027657228229937388
    1,000002.XSHE,7.0289,1.588,84113358168.0,1.6463,7.8656,300252061695.0,0.326,29308369223.2,23783476901.2,2012-01-31,0.08235182370820669
    2,000008.XSHE,-262.7461,7.0003,517045520.0,-0.5678,-0.5943,770517752.56,-0.006,11679829.03,12030080.04,2012-01-31,0.09978900335112327
    3,000060.XSHE,16.476,3.7146,19680455995.0,5.6036,14.617,28009159184.6,0.35,9189386877.65,7935542726.05,2012-01-31,0.12159482758620697
    4,000069.XSHE,12.5878,2.5616,41727214853.0,2.8729,10.9097,81247380359.0,0.271,8951453490.28,7091397989.13,2012-01-31,-0.0026808154146886697
    

  • 分析

    • 初始化VarianceThreshold,指定阀值方差

    • 调用fit_transform

    • def variance_demo():
          """
          删除低方差特征——特征选择
          :return: None
          """
          data = pd.read_csv("factor_returns.csv")
          print(data)
          # 1、实例化一个转换器类
          transfer = VarianceThreshold(threshold=1)
          # 2、调用fit_transform
          data = transfer.fit_transform(data.iloc[:, 1:10])
          print("删除低方差特征的结果：\n", data)
          print("形状：\n", data.shape)
      
          return None
      

      返回结果：

                  index  pe_ratio  pb_ratio    market_cap  \
      0     000001.XSHE    5.9572    1.1818  8.525255e+10   
      1     000002.XSHE    7.0289    1.5880  8.411336e+10    
      ...           ...       ...       ...           ...   
      2316  601958.XSHG   52.5408    2.4646  3.287910e+10   
      2317  601989.XSHG   14.2203    1.4103  5.911086e+10   
      
            return_on_asset_net_profit  du_return_on_equity            ev  \
      0                         0.8008              14.9403  1.211445e+12   
      1                         1.6463               7.8656  3.002521e+11    
      ...                          ...                  ...           ...   
      2316                      2.7444               2.9202  3.883803e+10   
      2317                      2.0383               8.6179  2.020661e+11   
      
            earnings_per_share       revenue  total_expense        date    return  
      0                 2.0100  2.070140e+10   1.088254e+10  2012-01-31  0.027657  
      1                 0.3260  2.930837e+10   2.378348e+10  2012-01-31  0.082352  
      2                -0.0060  1.167983e+07   1.203008e+07  2012-01-31  0.099789   
      ...                  ...           ...            ...         ...       ...  
      2315              0.2200  1.789082e+10   1.749295e+10  2012-11-30  0.137134  
      2316              0.1210  6.465392e+09   6.009007e+09  2012-11-30  0.149167  
      2317              0.2470  4.509872e+10   4.132842e+10  2012-11-30  0.183629  
      
      [2318 rows x 12 columns]
      删除低方差特征的结果：
       [[  5.95720000e+00   1.18180000e+00   8.52525509e+10 ...,   1.21144486e+12
          2.07014010e+10   1.08825400e+10]
       [  7.02890000e+00   1.58800000e+00   8.41133582e+10 ...,   3.00252062e+11
          2.93083692e+10   2.37834769e+10]
       [ -2.62746100e+02   7.00030000e+00   5.17045520e+08 ...,   7.70517753e+08
          1.16798290e+07   1.20300800e+07]
       ..., 
       [  3.95523000e+01   4.00520000e+00   1.70243430e+10 ...,   2.42081699e+10
          1.78908166e+10   1.74929478e+10]
       [  5.25408000e+01   2.46460000e+00   3.28790988e+10 ...,   3.88380258e+10
          6.46539204e+09   6.00900728e+09]
       [  1.42203000e+01   1.41030000e+00   5.91108572e+10 ...,   2.02066110e+11
          4.50987171e+10   4.13284212e+10]]
      形状：
       (2318, 8)
      

2）相关系数

• 皮尔逊相关系数(Pearson Correlation Coefficient)
  • 反映变量之间相关关系密切程度的统计指标
• 公式
  • 

• 特点

  相关系数的值介于–1与+1之间，即–1≤ r ≤+1。其性质如下：

  • 当r>0时，表示两变量正相关，r<0时，两变量为负相关
  • 当|r|=1时，表示两变量为完全相关，当r=0时，表示两变量间无相关关系
  • 当0<|r|<1时，表示两变量存在一定程度的相关。且|r|越接近1，两变量间线性关系越密切；|r|越接近于0，表示两变量的线性相关越弱
  • 一般可按三级划分：|r|<0.4为低度相关；0.4≤|r|<0.7为显著性相关；0.7≤|r|<1为高度线性相关

  这个符号：|r|为r的绝对值， |-5| = 5

• API

  • from scipy.stats import pearsonr
    • x : (N,) array_like
    • y : (N,) array_like Returns: (Pearson’s correlation coefficient, p-value)

7.主成分分析

• 定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量
• 作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。
• 应用：回归分析或者聚类分析当中

对于信息一词，在决策树中会进行介绍

（1） API

• sklearn.decomposition.PCA(n_components=None)
  • 将数据分解为较低维数空间
  • n_components:
    • 小数：表示保留百分之多少的信息
    • 整数：减少到多少特征
  • PCA.fit_transform(X) X:numpy array格式的数据[n_samples,n_features]
  • 返回值：转换后指定维度的array