机器学习概述

1.1 人工智能概述

机器学习与人工智能、深度学习

• 机器学习与人工智能、深度学习的关系
  • 机器学习是人工智能的一个实现途径
  • 深度学习是机器学习的一个方法发展而来
• 达特茅斯会议-人工智能的起点
  • 1956年8月，在美国汉诺斯小镇宁静的达特茅斯学院中，约翰·麦卡锡(John McCarthy)、马文闵斯基(Marvin Minsky，人工智能与认知学专家)、克劳德·香农(Claude Shannon，信息论的创始人)、艾伦·纽厄尔(Allen Newell，计算机科学家)、赫伯特·西蒙(Herbert Simon，诺贝尔经济学奖得主) 等科学家正聚在一起，讨论着一个完全不食人间烟火的主题:
    
    用机器来模仿人类学习以及其他方面的智能。
    
    会议足足开了两个月的时间，虽然大家没有达成普遍的共识，但是却为会议讨论的内容起了一个名字:
    
    人工智能
    
    因此，1956年也就成为了人工智能元年。

1.1.2 机器学习、深度学习能做些什么

机器学习的应用场景非常多，可以说渗透到了各个行业领域当中。医疗、航空、教育、物流、电商等等领域的各种场景。

• 用在挖掘、预测领域：
  • 应用场景：店铺销量预测、量化投资、广告推荐、企业客户分类、SQL语句安全检测分类…
• 用在图像领域：
  • 应用场景：街道交通标志检测、人脸识别等等
    
• 用在自然语言处理领域：
  • 应用场景：文本分类、情感分析、自动聊天、文本检测等等
    

当前重要的是掌握一些机器学习算法等技巧，从某个业务领域切入解决问题。

1.2 什么是机器学习

1.2.1 定义

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

1.2.2 解释

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

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

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

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

1.2.3 数据集构成

• 结构：特征值 + 目标值
  

注：

• 对于每一行数据我们可以称之为样本。
• 有些数据集可以没有目标值：

1.3 机器学习算法分类

1. 监督学习
   • 目标值：类别 - 分类问题
   • 目标值：连续型的数据 - 回归问题
2. 无监督学习
   • 目标值：无 - 无监督学习

分析1.2.2 中的例子：

• 特征值：猫/狗的图片；目标值：猫/狗-类别
  • 分类问题

• 特征值：房屋的各个属性信息；目标值：房屋价格-连续型数据
  • 回归问题

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

1.3.1 总结

1.3.2 练习

说一下它们具体问题类别：
1、预测明天的气温是多少度？
回归
2、预测明天是阴、晴还是雨？
分类
3、人脸年龄预测？
回归/分类, 看我们怎么定义这个年龄，比如说：
测心理年龄测试结果是26.1、50.1 … 这种就属于回归, 目标值是连续型的；
如果说测试心理年龄是 老的、小的 这种的话说明目标值是类别，这种就属于分类。
4、人脸识别？
分类虽然人脸识别最终的结果 他的目标值有很多很多，有多少个人就有不同的人脸，虽然类别很多但他还是分类

1.3.3 机器学习算法分类

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

1.4 机器学习开发流程（了解）

1）获取数据
2）数据处理
  比如：数据有缺失值处理一下缺失值；有一些数据不符合要求了给它处理掉。
3）特征工程
  其实特征工程也算是在做数据处理，只不过我们将这些数据处理成更为直接能够被算法使用的数据。我们说机器学习的 数据集 分为 特征值 和 目标值，所以我们在处理数据的时候，直接叫特征工程，特征工程里的这个 特征 跟 特征值 是一回事。
4）机器学习算法训练 - 模型
  选择合适的算法去训练了，训练好之后 得到一个模型。
5）模型评估
  如果我们用一系列的方法看出这个模型效果比较好，那么就可以应用了；如果不好的话，还是要返回 数据处理 这一步，看看数据的处理有没有问题、看看特征工程做的好不好、看看算法选择有没有问题，这些都要检查一下，最终再看一下新的模型怎么样（模型评估），如果不好继续循环。直到模型评估比较好的，才可以应用。
6）应用

流程图：

1.5 学习框架和资料介绍

需明确几点问题：

（1）算法是核心，数据与计算是基础

（2）找准定位

大部分复杂模型的算法设计都是算法工程师在做，而我们

• 分析很多的数据
• 分析具体的业务
• 应用常见的算法
• 特征工程、调参数、优化

• 我们应该怎么做？

• 学会分析问题，使用机器学习算法的目的，想要算法完成何种任务

• 掌握算法基本思想，学会对问题用相应的算法解决

• 学会利用库或者框架解决问题

当前重要的是掌握一些机器学习算法等技巧，从某个业务领域切入解决问题。

1.5.1 机器学习库与框架

• 传统机器学习算法
  • Scikit-lear
• 深度学习框架
  • TensorFlow
  • pytorch
  • Caffe2
  • theano（TensorFlow的前身）
  • Chainer（pytorch的前身）

1.5.2 书籍资料

机器学习 -”西瓜书”- 周志华
统计学习方法 - 李航
深度学习 - “花书”

1.5.3 提深内功（但不是必须）

特征工程

了解特征工程在机器学习当中的重要性
应用sklearn实现特征预处理
应用sklearn实现特征抽取
应用sklearn实现特征选择
应用PCA实现特征的降维

2.1 数据集

2.1.1 可用数据集

公司内部 百度
数据接口 花钱

Kaggle网址：https://www.kaggle.com/datasets

UCI数据集网址： http://archive.ics.uci.edu/ml/

scikit-learn网址：https://scikit-learn.org/stable/index.html

1、Scikit-learn工具介绍

• Python语言的机器学习工具
• Scikit-learn包括许多知名的机器学习算法的实现
• Scikit-learn文档完善，容易上手，丰富的API
• 本章用的版本 1.3.0

2、安装

pip install scikit-learn

可以指定版本号
pip3 install Scikit-learn==0.19.1

也可以在虚拟环境里安装

创建并进入虚拟环境eliauk mkvirtualenv eliauk
安装win版本后可以是有命令进行虚拟环境的进入, 进入eliauk workon eliauk

安装好之后可以通过以下命令查看是否安装成功

import sklearn

ipython是一个python的交互式shell
pip list 看一下我们的环境

• 注：安装scikit-learn需要Numpy, Scipy等库
  那你就把相应的库安装上就可以了。

3、Scikit-learn包含的内容

scikitlearn接口

• 分类、聚类、回归
• 特征工程
• 模型选择、调优

2.1.2 sklearn数据集

1、scikit-learn数据集API介绍

_* 是 _某一个数据集名字

• sklearn.datasets
  • 加载获取流行数据集
  • datasets.load_*()
    • 获取小规模数据集，数据包含在- datasets里
    • 返回Bunch类型
  • datasets.fetch_*(data_home=None)
    • 返回Bunch类型
    • 获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录,默认是 ~/scikit_learn_data/
    • 我的是windows，C:\Users\用户名\Envs\虚拟环境名\Lib\site-packages\sklearn\datasets\data
      

2、获取sklearn小数据集

• sklearn.datasets.load_iris()
  加载并返回鸢尾花数据集
  

最受欢迎、用的比较多的数据集，鸢尾花数据集，是一个非常经典的数据集，在sklearn当中也有

• sklearn.datasets.load_digits()
  加载并返回数字数据集

• sklearn.datasets.load_boston()
  加载并返回波士顿房价数据集
  
• sklearn.datasets.load_diabetes()
  加载和返回糖尿病数据集
  

3、获取sklearn大数据集

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

4、sklearn数据集的使用

• 以鸢尾花数据集为例：

sklearn数据集返回值介绍

• load 和 fetch 返回的数据类型datasets.base.Bunch(字典格式)，继承自字典
  • data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组
  • target：标签数组，是 n_samples 的一维 numpy.ndarray 数组。目标值
  • DESCR：数据描述
  • feature_names：特征名,新闻数据，手写数字、回归数据集没有
  • target_names：标签名。目标值的标签
  • 字典的方式：dict["key"] = values
  • .属性的方式: bunch.key = values

from sklearn.datasets import load_iris


def datasets_demo():
    """
    sklearn数据集使用
    :return:
    """
    # 获取数据集
    iris = load_iris()
    print("鸢尾花数据集:\n", iris)

    return None


if __name__ == "__main__":
    # 代码:sklearn数据集使用
    datasets_demo()

结果：

鸢尾花数据集:
 {'data': array([[5.1, 3.5, 1.4, 0.2],
       [4.9, 3. , 1.4, 0.2],
       ...,
       [5.9, 3. , 5.1, 1.8]]),
'target': array([0, 0, 0, 0, ..., 0, 1, 1, ..., 1, 1, 2,..., 2, 2]), 
'frame': None,
 'target_names': array(['setosa', 'versicolor', 'virginica'], dtype='<U10'), 
'DESCR': '.. _iris_dataset:\n\nIris plants dataset...', 
'feature_names': ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'],
'filename': 'iris.csv', 'data_module': 'sklearn.datasets.data'}

data 特征数据数组（特征值），是一个二维数组，它的类型是ndarray，Numpy是很多库的基础库，所以sklearn也是有Numpy的。

target 目标值（标签值），也是一个数组ndarray，目标值。target_names目标值的标签。0对应一类setosa, 1代表另一类versicolor。

DESCR 描述，不是特别清楚。

思考：拿到的数据是否全部都用来训练一个模型？
否

2.1.3 数据集的划分

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

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

划分比例：

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

锚点链接：3.1.1 估计器工作流程

数据集划分api

• sklearn.model_selection.train_test_split(arrays, *options)
  • x 数据集的特征值
  • y 数据集的标签值（目标值）
  • test_size 测试集的大小，一般为float，比如想要设置20%那么就传入0.2。不传默认0.25
    
  • random_state 随机数种子（大家都知道计算机伪随机）,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
  • 返回值 ：return 训练集特征值，测试集特征值，训练集目标值，测试集目标值
    取名x_train, x_test, y_train, y_test

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


def datasets_demo():
    """
    sklearn数据集使用
    :return:
    """
    # 获取数据集
    iris = load_iris()
    print("鸢尾花数据集:\n", iris)
    # 返回值是一个继承自字典的Bench
    print("查看数据集的描述：\n", iris.DESCR)  # iris['DESCR']
    print("鸢尾花的特征值:\n", iris["data"],iris["data"].shape)# (150, 4)
    print("鸢尾花特征的名字：\n", iris.feature_names)  #  ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
    print("鸢尾花的目标值：\n", iris.target,iris.target.shape)
    """
     [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] (150,)
    """
    print("鸢尾花目标值的名字：\n", iris.target_names)

    # 数据集划分
    # 训练集的特征值x_train 测试集的特征值x_test 训练集的目标值y_train 测试集的目标值y_test
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
    print("x_train:\n", x_train, x_train.shape)# (120, 4)
    print("x_test:\n", x_test, x_test.shape)# (30, 4)
    print("y_train:\n", y_train, y_train.shape)# (120,)
    print("y_test:\n", y_test, y_test.shape)# (30,)
    # 随机数种子
    x_train1, x_test1, y_train1, y_test1 = train_test_split(iris.data, iris.target, test_size=0.2, random_state=6)
    x_train2, x_test2, y_train2, y_test2 = train_test_split(iris.data, iris.target, test_size=0.2, random_state=6)
    print("如果随机数种子不一致：\n", x_train == x_train1)
    print("如果随机数种子一致：\n", x_train1 == x_train2)

    return None


if __name__ == "__main__":
    # 代码:sklearn数据集使用
    datasets_demo()

2.2 特征工程介绍

这个图是一个数据科学的网站，里面有很多关于数据科学的比赛，这是有一个比赛的结果，可以看到这里有参赛者、组织、分数。我们可以看到，面对同样的问题就有不同的分数，这些分数其实是比较接近的。

为什么面对同样的问题他们的分数（最终效果、结果）会不一样？

影响最终效果可能的原因就是：
1.使用的算法
2.数据处理的怎么样，也就是特征工程
其实这些人用的工具不是TensorFlow就是什么什么pytorch又或者sklearn等等，能用的工具其实差不多，经典算法大家知道的也是差不多的。能排名靠这么前的，肯定知道的算法也都差不多。所以说根据这个算法，他们很可能用的是同一种算法。为什么结果会有差距呢？
其实就是在于特征工程是千变万化的，可能做特征工程、数据处理部分是不一样的，导致最终的效果差别。

2.2.1 为什么需要特征工程(Feature Engineering)

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

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

2.2.2 什么是特征工程

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

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

2.2.3 特征工程的位置与数据处理的比较

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

特征工程包含内容

• 特征抽取（或者特征提取）
• 特征预处理
• 特征降维

2.3 特征提取（特征抽取）

学习目标

• 目标
  • 应用DictVectorizer实现对类别特征进行数值化、离散化
  • 应用CountVectorizer实现对文本特征进行数值化
  • 应用TfidfVectorizer实现对文本特征进行数值化
  • 说出两种文本特征提取的方式区别

什么是特征提取呢？

第一个例子： 这是一篇英文的短文，我们如果想要对这篇短文做一些处理，比如做文章的分类，分成不同的类别，想要用机器学习算法去做，会出现什么问题？
左边英文短文相当于 数据集，数据集想要用机器学习算法去做，那么什么是机器学习算法呢？
机器学习其实就是当时搞统计的那些人想出来的 去实现人工智能的一个途径，机器学习算法 其实就是一些 统计方法 ，统计方法 又是一个又一个 数学公式。数学公式它能够处理字符串吗？数学公式肯定不能处理字符串，但是我们这个数据就是字符串，我们需要将文本类型的 这个存成的字符串 给它转换成 右边数值的类型 。但是怎么转换比较合适呢？转换成什么样子才能达到我们最终的目的呢？这就是我们特征提取、特征抽取 要考虑的事情。

机器学习算法 - 统计方法 - 数学公式
文本类型 => 数值

类型 => 数值
第二个例子： 我有一组数据，想要对数据进行分类，那么我们数据当中有这些特征 pclass（泰坦尼克号数据集里的特征，pclass代表所乘的舱位，一等舱、二等舱）、sex ，我们发现存成什么了？是不是还是字符串呀，它们都表示的是类别。
我们在前面 数据挖掘基础阶段，当我们想要处理一些数据，这些数据当中有一些数据当中是类别的话，类别我们通常存储成字符串，但我们现在要用机器学习算法去处理这些数据，是不是还是要将类型转换成数值，怎么转？这个当时有讲方法，转换成one-hot编码 或者 哑变量

为什么要进行特征提取？我们一些数据一开始不能直接被机器学习算法处理，需要用一种方式来把它进行这样的转换，至于怎么转换呢，不同的类型的数据有不同的转换方法。

2.3.1 特征提取

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

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

• 字典特征提取(特征离散化)
• 文本特征提取
• 图像特征提取（深度学习将介绍）

2、特征提取API

在sklearn有一个feature_extraction类

sklearn.feature_extraction

2.3.2 字典特征提取 DictVectorizer

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

• sklearn.feature_extraction.DictVectorizer(sparse=True,…)
  • Vector 向量、矢量
    矩阵 matrix 二维数组，从线性代数当中，矩阵可以从另一个角度看它，可以看成它是由向量构成的，可以横着看可以竖着看，都可以看成是由向量构成的。
    如果将向量存储在计算机当中，那就是一维数组。
    向量 vector 一维数组
    DictVectorizer 字典进行向量化，其实就是告诉计算机我要把字典转换成数值。
  • sparse 稀疏
    • 参数值
      • =True 默认参数会返回一个稀疏矩阵（返回sparse矩阵对象 scipy.sparse._csr.csr_matrix ）
        • 将非零值 按位置表示出来
        • 节省内存 - 提高加载效率
        • sparse矩阵对象.toarray() 返回一个二维数组【跟DictVectorizer(sparse=False).fit_transform(X) 一样的结果】
      • =False 会返回一个one-hot编码矩阵
  • DictVectorizer.fit_transform(X) X:字典或者包含字典的迭代器返回值：返回sparse矩阵
  • DictVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值:转换之前数据格式
  • DictVectorizer.get_feature_names() 返回类别名称
    如果报错:AttributeError: ‘DictVectorizer’ object has no attribute ‘get_feature_names’. Did you mean: ‘get_feature_names_out’?
    原因：函数get_feature_names在1.0中已弃用，在1.2中删除。改用DictVectorizer.get_feature_names_out()。 我的版本是 1.3.0

我们调用sklearn.feature_extraction.DictVectorizer()之后相当于实例化了一个 转换器对象 ，它的父类叫TransformerMixin 转换器类，其中一个方法就是把字典转换成数值。

1、应用

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

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

实际上我们发现它是按样本，每一个样本 {‘city’: ‘北京’,‘temperature’:100} 转换成了一个向量，n个样本就是n个向量，就成了一个二维数组，我们可以理解成二维数组，也可以理解成矩阵。

字典特征提取 - 类别 -> one-hot编码

2、流程分析

• 实例化类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()  # 使用默认参数会返回一个稀疏矩阵
    transfer = DictVectorizer(sparse=False)  # 会返回一个one-hot编码矩阵

    # 2、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("type(data_new):\n", type(data_new))
    # 没加参数sparse=False ->  <class 'scipy.sparse._csr.csr_matrix'>
    # 加了参数sparse=False ->  <class 'numpy.ndarray'>

    print("返回的结果:\n", data_new)

    # 打印特征名字
    # print("特征名字：\n", transfer.get_feature_names())
    # 报错:AttributeError: 'DictVectorizer' object has no attribute 'get_feature_names'. Did you mean: 'get_feature_names_out'?
    # 原因: 函数get_feature_names已弃用；get_feature_names在1.0中已弃用，将在1.2中删除。请改用。
    # 我的版本是  1.3.0
    print("特征名字：\n", transfer.get_feature_names_out())

    return None


if __name__ == "__main__":
    dict_demo()

注意观察没有加上sparse=False参数（默认True）的结果

type(data_new):
 <class 'scipy.sparse._csr.csr_matrix'>
返回的结果:
   (0, 1)	1.0
  (0, 3)	100.0
  (1, 0)	1.0
  (1, 3)	60.0
  (2, 2)	1.0
  (2, 3)	30.0
特征名字：
 ['city=上海' 'city=北京' 'city=深圳' 'temperature']

这个结果并不是我们想要看到的，所以加上参数sparse=False，得到想要的结果：

type(data_new):
 <class 'numpy.ndarray'>
返回的结果:
 [[  0.   1.   0. 100.]
 [  1.   0.   0.  60.]
 [  0.   0.   1.  30.]]
特征名字：
 ['city=上海' 'city=北京' 'city=深圳' 'temperature']

之前在学习pandas中的离散化的时候，也实现了类似的效果。

我们把这个处理数据的技巧叫做”one-hot“编码：

转化为：
我们做的是为每个类别生成一个布尔列。这些列中只有一列可以为每个样本取值1。因此，术语一个热编码。

3、对比两个结果理解一下稀疏矩阵和one-hot编码

sparse稀疏矩阵将非0值按照位置表示出来，这样做有什么好处呢？右边的是将类别转换成为one-hot编码，如果类别特别多呢？假设有一千个的时候，这样会使得0特别多，这时候用左边的稀疏矩阵可以提高加载效率，节省内存。
注意：使用one-hot编码是为了让类别更加公平一点，相互之间没有优先级，在特征中对类别信息常用ont-hot编码处理

字典特征抽取-应用场景：

（1）数据集当中类别特征比较多 ， 例如pclass, sex 都是类别特征
         1、将数据集的特征 -> 字典类型
         2、DictVectorizer转换
（2）本身拿到的数据就是字典类型
          就用字典特征抽取

总结

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

2.3.3 文本特征提取

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

单词 作为 特征
句子、短语、单词、字母
特征：特征词（单词）

如果把一篇文章进行分类的话，我们把什么作为它的特征能更容易的进行分类？如果没有标题的话，就把单词作为特征是比较合适的，其实一篇文章要去划分的话可以有很多要素，我们也可以以 句子 作为一个单位，也可以以 短语（短句子），除了单词之外还可以以字母。这些那些作为特征更合适呢？单词最为合适。为什么不用句子呢？其实用句子也不是不可以，但是不太现实，因为一个句子是由多个单词构成的，如果用句子作为特征的话，排列组合起来特征太多了，那就不太好处理了，所以一般我们用单词作为特征。

方法 1：CountVectorizer

• sklearn.feature_extraction.text.CountVectorizer(stop_words=[])
  • stop_words停用的
    我们认为有一些词也是不具备 对最终分类有好处的，比如 “is”、“too” 这种比较虚一点的词，以列表的形式传给CountVectorizer，这些词从哪来？感兴趣的话可以搜索 停用词表 ，这里就不扩展了
  • 返回词频矩阵（返回sparse矩阵对象 scipy.sparse._csr.csr_matrix ）
    • 内部的方法
      • sparse矩阵对象.toarray() 返回一个二维数组
• CountVectorizer.fit_transform(X) X:文本或者包含文本字符串的可迭代对象 返回值：返回sparse矩阵
• CountVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值:转换之前数据格
• CountVectorizer.get_feature_names() 返回值:单词列表
• sklearn.feature_extraction.text.TfidfVectorizer

1、应用

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

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

它会将文章中的单词作为特征词，但是我们发现 ’ i ’ 没有放进来。 为什么不把 ’ i ’ 作为特征词呢？因为我们认为这个 ’ i ’ 是单词的话要想进行分类（或者情感分析）它的意义不大，所以API在设计的时候自动的把标点符号、字母 就直接不统计 不作为最终的特征词列表。
0、1是对单词的一个计数

2、流程分析

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

from sklearn.feature_extraction.text import CountVectorizer


def text_count_demo():
    """
    对文本进行特征提取,countvetorizer
    :return:None
    """
    data = ["python life is short,i like python", "life is too long,i dislike python"]
    # 1、实例化一个转换器类
    transfer = CountVectorizer()
    # transfer = CountVectorizer(sparse=False)  # 报错: 不存在sparse这样一个参数。TypeError: CountVectorizer.__init__() got an unexpected keyword argument 'sparse'

    # 2、调用fit_transform
    data_new = transfer.fit_transform(data)
    print('data_new:\n', data_new)  # sparse矩阵
    print('type(data_new): ', type(data_new))  # <class 'scipy.sparse._csr.csr_matrix'>
    print('data_new.toarray:\n', data_new.toarray())

    # print("返回特征名字：\n", transfer.get_feature_names())
    print("返回特征名字：\n", transfer.get_feature_names_out())
    return None


if __name__ == "__main__":
    text_count_demo()

返回结果：

data_new:
   (0, 5)	2
  (0, 2)	1
  (0, 1)	1
  (0, 6)	1
  (0, 3)	1
  (1, 5)	1
  (1, 2)	1
  (1, 1)	1
  (1, 7)	1
  (1, 4)	1
  (1, 0)	1
type(data_new):  <class 'scipy.sparse._csr.csr_matrix'>
data_new.toarray:
 [[0 1 1 1 0 2 1 0]
 [1 1 1 0 1 1 0 1]]
返回特征名字：
 ['dislike' 'is' 'life' 'like' 'long' 'python' 'short' 'too']

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

中文文本特征抽取

from sklearn.feature_extraction.text import CountVectorizer


def text_count_chinese_demo():
    """
    对中文文本进行特征提取,countvetorizer
    :return:None
    """
    data = ["我爱派森", "派森你好呀"]
    # 1、实例化一个转换器类
    transfer = CountVectorizer()

    # 2、调用fit_transform
    data_new = transfer.fit_transform(data)
    # print('data_new:\n', data_new)
    # print('type(data_new): ', type(data_new))
    print('文本特征抽取的结果:\n', data_new.toarray())

    # print("返回特征名字：\n", transfer.get_feature_names())
    print("返回特征名字：\n", transfer.get_feature_names_out())
    return None


if __name__ == "__main__":
    text_count_chinese_demo()

结果：

文本特征抽取的结果:
 [[1 0]
 [0 1]]
返回特征名字：
 ['我爱派森' '派森你好呀']

我们发现这并不是我们想要的结果，它把 短语 作为 特征 了。这样是不合适的，我们需要把单词作为特征。

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

因为英文本身是有空格去隔开一个又一个的词，中文有那个语言的特写，它就不会有这样一个分隔，所以最终认为这整个是一个词，然后进行这样的一个划分。

如果想要达到比较好的一个效果（正常的效果），我们应该怎么办？把中文隔开进行分词。

data = ["我 爱 派森", "派森 你好 呀"]

结果：

文本特征抽取的结果:
 [[0 1]
 [1 1]]
返回特征名字：
 ['你好' '派森']

刚刚我们是手动分词，现在我们可以借助一些工具来自动的进行分词，比如jieba分词（Python 中文分词库）

CountVectorizer(stop_words=) 体验

from sklearn.feature_extraction.text import CountVectorizer


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

    # print("返回特征名字：\n", transfer.get_feature_names())
    print("返回特征名字：\n", transfer.get_feature_names_out())
    return None


if __name__ == "__main__":
    text_count_demo()

结果：

文本特征抽取的结果:
 [[0 1 1 0 2 1]
 [1 1 0 1 1 0]]
返回特征名字：
 ['dislike' 'life' 'like' 'long' 'python' 'short']

3、jieba分词处理

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

需要安装下jieba库

pip3 install jieba

4、案例

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

沉溺在“如果情况不同又会发生什么”的设想里，
绝对是让人精神失常的不二法门。

我们看到的从很远星系来的光是在几百万年之前发出的，
这样当我们看到宇宙时，我们是在看它的过去。

如果只用一种方式了解某样事物，你就不会真正了解它。
了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。

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

from sklearn.feature_extraction.text import CountVectorizer
import jieba


def cut_words(text):
    """
    进行中文分词
    "我爱北京天安门"————>"我 爱 北京 天安门"
    :param text:
    :return:text
    """
    # print(jieba.cut(text))  # 返回一个词语生成器 <generator object Tokenizer.cut at 0x000002736CC1A140>
    # a = list(jieba.cut(text))# ['我', '爱', '北京', '天安门']
    # a = " ".join(list(jieba.cut(text)))# "我 爱 北京 天安门"
    # a = " ".join(jieba.cut(text))  # 这里直接join生成器也可以, 一样的效果 # "我 爱 北京 天安门"
    # print(a)

    return " ".join(jieba.cut(text))


def text_count_chinese_demo02():
    """
    中文文本特征提取, 自动分词
    :return:None
    """
    data = ["一种还是一种沉溺在“如果情况不同又会发生什么”的设想里，绝对是让人精神失常的不二法门。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
    new_data = []
    # 1.将中文文本进行分词
    for sent in data:
        new_data.append(cut_words(sent))
    print(new_data)
    # 2、实例化一个转换器类
    transfer = CountVectorizer()
    # transfer = CountVectorizer(stop_words=["一种", "所以"])  # 指定的词语去掉,不作为特征
    # 3、调用fit_transform
    data_final = transfer.fit_transform(new_data)
    print('文本特征抽取的结果:\n', data_final.toarray())

    # print("返回特征名字：\n", transfer.get_feature_names())
    print("返回特征名字：\n", transfer.get_feature_names_out())
    return None


if __name__ == "__main__":
    # print(cut_words("我爱北京天安门"))  # 中文分词
    text_count_chinese_demo02()

返回结果：

Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\eliauk\AppData\Local\Temp\jieba.cache
Loading model cost 0.712 seconds.
Prefix dict has been built successfully.
['一种 还是 一种 沉溺在 “ 如果 情况 不同 又 会 发生 什么 ” 的 设想 里 ， 绝对 是 让 人 精神失常 的 不二法门 。', '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。', '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。']
文本特征抽取的结果:
 [[2 1 0 1 0 0 0 1 0 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0 0 0 1 1 0 1 0 1 0]
 [0 0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 1 0 3 0 1 0 0 2 0 0 0 0 0 0 1 0 1]
 [1 0 1 0 0 4 3 0 0 0 0 0 1 1 1 1 1 0 0 1 1 0 1 0 0 2 1 0 0 1 0 0 0 0]]
返回特征名字：
 ['一种' '不二法门' '不会' '不同' '之前' '了解' '事物' '什么' '光是在' '几百万年' '发出' '发生' '取决于'
 '只用' '含义' '如何' '如果' '宇宙' '情况' '我们' '方式' '星系' '某样' '沉溺在' '看到' '真正' '秘密'
 '精神失常' '绝对' '联系' '设想' '过去' '还是' '这样']

但如果把这样的词语特征用于分类，会出现什么问题？

思考

思考一个问题，我们用CountVectorizer的方式进行对文本特征的抽取 是这样的一个结果，这样的结果有什么问题？对于最终想要实现 文本分类 这样一个目的来说 ，这么分词，这么特征提取 有没有什么不好的地方？

        我们看到，在这个二维数组里面，相当于有三个样本，有很多个特征，我们如果进行文本分类的话，那么就是根据特征进行分类。怎样的特征呢？我们认为数值上比较大的，我们认为对最终的结果影响会更大一点。
        在第三个样本中，“了解” 这个词在第三个样本中占了4次，“事物” 出现了三次 ，如果用这样的数据进行分类的话，“了解”、“事物” 这两个词可能会对最终结果产生更大的影响。那么这样我们相当于只是根据一个词在这篇文章中出现的次数来进行分类的，出现的次数越多可能就认为更属于这个类别。
        但现在就有一个问题了，比如像"我们"、“你们”、“他们”、“只有”、“因为”、“所以”…这些词不仅在你这篇文章，在其他文章当中也可能经常出现，像这样的词，如果我们把它统计出来，会得到一个很大的数值，会对最终的结果产生更大的影响，但这样有利于我们进行分类吗？不利于的。
        我们更希望的是找到这样的一种词，在某一个类别的文章中，出现的次数很多，但是在其他类别的文章当中出现很少或者几乎不出现。这样的词更有利于我们分类。我们把这样的词叫做 关键词 。



我们怎么才能找到一种方法，很方便的一下子看出来这个词是关键词呢？这就是我们接下来要介绍的另一种方法 TfidfVectorizer，这种方法就可以自动的找出哪一个词更为重要，哪一个词有利于对我们分类结果的显示。


比如说，看下图，有两篇文章，根据这两篇文章出现的词 在整篇文章的占比情况 来分析这两篇文章属于什么类型的文章。

        我们看左边这个文章，在一篇文章当中大量的出现 “车” 和 “共享” ，很可能在讲共享单车或者共享汽车，那么这篇文章很有可能是属于科技类或者互联网类别的。
        右边的文章大量的出现 “银行”、“证券”、“经济”，很有可能这篇文章是属于财经、金融类型的文章。
        我们看到像找到这些词，它们在自己的类别当中会出现很多次，“车” 、“共享” 一般不会出现在财经、金融类的文章当中，而 “银行”、“证券”、“经济” 也一般不会出现在科技类的文章当中。我们更希望找到这样的关键词。

方法2：TfidfVectorizer

5、Tf-idf文本特征提取

• TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。
• TF-IDF作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。

5.1 公式

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

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

        词频怎么计算？举个例子：现在有两个词“经济”、“非常”
        总共有1000篇文章作为语料库，
        其中100篇文章 都有 “非常”
        而只有 10篇文章 有 “经济”
        2篇文章：文章A(100词) : 10次“经济”
                                         tf:10/100 = 0.1
                                         idf:lg 1000/10 = 2
                                        TF-IDF:0.2
                        文章B(100词) : 10次“非常”
                                        tf:10/100 = 0.1
                                         idf: log 10 1000/100 = 1
                                        TF-IDF:0.1
对数
2 ^ 3 = 8
log 2 8 = 3
log 10 10 = 1

注意：假如一篇文件的总词语数是100个，而词语"非常"出现了5次，那么"非常"一词在该文件中的词频（TF）就是5/100=0.05。而计算文件频率（IDF）的方法是以文件集的文件总数，除以出现"非常"一词的文件数。所以，如果"非常"一词在10,000份文件出现过，而文件总数是10,000,000份的话，其逆向文件频率就是lg（10,000,000 / 1,0000）=3。最后"非常"对于这篇文档的tf-idf的分数为0.05 * 3=0.15

5.2 API

• sklearn.feature_extraction.text.TfidfVectorizer(stop_words=None,...)
  • 返回词的权重矩阵
    • TfidfVectorizer.fit_transform(X)
      • X:文本或者包含文本字符串的可迭代对象
      • 返回值:返回sparse矩阵
    • TfidfVectorizer.inverse_transform(X)
      • X:array数组或者sparse矩阵
      • 返回值:转换之前数据格式
    • TfidfVectorizer.get_feature_names()
      • 返回值:单词列表

5.3 案例

拿上一个案例的代码把 CountVectorizer 改成 TfidfVectorizer

from sklearn.feature_extraction.text import TfidfVectorizer
import jieba


def cut_words(text):
    """
    进行中文分词
    "我爱北京天安门" ————> "我 爱 北京 天安门"
    :param text:
    :return:text
    """
    return " ".join(jieba.cut(text))


def tfidf_demo():
    """
    用TF-IDF的方法进行文本特征抽取
    :return:
    """
    data = ["一种还是一种沉溺在“如果情况不同又会发生什么”的设想里，绝对是让人精神失常的不二法门。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
    new_data = []
    # 1.将中文文本进行分词
    for sent in data:
        new_data.append(cut_words(sent))
    # print(new_data)
    # 2、实例化一个转换器类
    # transfer = TfidfVectorizer()
    transfer = TfidfVectorizer(stop_words=["一种", "所以"])  # 指定的词语去掉,不作为特征
    # 3、调用fit_transform
    data_final = transfer.fit_transform(new_data)
    print('文本特征抽取的结果:\n', data_final.toarray())

    # print("返回特征名字：\n", transfer.get_feature_names())
    print("返回特征名字：\n", transfer.get_feature_names_out())
    return None


if __name__ == '__main__':
    tfidf_demo()

返回结果：

文本特征抽取的结果:
 [[0.30746099 0.         0.30746099 0.         0.         0.
  0.30746099 0.         0.         0.         0.30746099 0.
  0.         0.         0.         0.23383201 0.         0.30746099
  0.         0.         0.         0.         0.30746099 0.
  0.         0.         0.30746099 0.30746099 0.         0.30746099
  0.         0.30746099 0.        ]
 [0.         0.         0.         0.2410822  0.         0.
  0.         0.2410822  0.2410822  0.2410822  0.         0.
  0.         0.         0.         0.         0.2410822  0.
  0.55004769 0.         0.2410822  0.         0.         0.48216441
  0.         0.         0.         0.         0.         0.
  0.2410822  0.         0.2410822 ]
 [0.         0.15980722 0.         0.         0.6392289  0.47942167
  0.         0.         0.         0.         0.         0.15980722
  0.15980722 0.15980722 0.15980722 0.12153751 0.         0.
  0.12153751 0.15980722 0.         0.15980722 0.         0.
  0.31961445 0.15980722 0.         0.         0.15980722 0.
  0.         0.         0.        ]]
返回特征名字：
 ['不二法门' '不会' '不同' '之前' '了解' '事物' '什么' '光是在' '几百万年' '发出' '发生' '取决于' '只用'
 '含义' '如何' '如果' '宇宙' '情况' '我们' '方式' '星系' '某样' '沉溺在' '看到' '真正' '秘密' '精神失常'
 '绝对' '联系' '设想' '过去' '还是' '这样']

我们看到有的是0，有的是0.3、0.2，有个比较大的0.55 。这样的一些数值，大的就能体现出这个词是比较重要的，比较适合用于进行分类的，更具有分类意义的词。我们会在以后如果用传统的机器学习算法sklearn进行文本的处理，那么你就会经常用到 Tfidf 这样的文本特征抽取的方法。

6、Tf-idf的重要性

分类机器学习算法进行文章分类中前期数据处理方式

2.4 特征预处理

• 目标
  • 了解数值型数据、类别型数据特点
  • 应用MinMaxScaler实现对特征数据进行归一化
  • 应用StandardScaler实现对特征数据进行标准化

什么是特征预处理？

2.4.1 什么是特征预处理

# scikit-learn 官网给的解释
provides several common utility functions and transformer classes to change raw feature vectors into a representation that is more suitable for the downstream estimators.

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

可以通过上面那张图来理解

1、包含内容

• 数值型数据的无量纲化：
  • 归一化
  • 标准化

2、特征预处理API

sklearn.preprocessing

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

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

我们需要用到一些方法进行无量纲化，使不同规格的数据转换到同一规格

2.4.2 归一化

1、定义

通过对原始数据进行变换把数据映射到 一个固定的区间(默认为[0,1]) 之间。

2、公式

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

那么怎么理解这个过程呢？我们通过一个例子

特征1 这一列最大值是90、最小值是60，放到指定区间 [0,1]
      X’ = (90-60) / (90-60) =1
      X’’ = 1 * (1-0) + 0 = 1

3、API

• sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )
  Scaler 缩放器
  MinMaxScaler 最小值最大值放缩
  • MinMaxScalar.fit_transform(X)
    • X:numpy array格式（ndarray）的数据 [n_samples,n_features]
      形状是二维数组 [ 样本数, 特征数 ]
  • 返回值：转换后的形状相同的array

4、数据计算

网盘链接：链接：https://pan.baidu.com/s/1za_R-yrzpphy4sVd2JlelA?pwd=6666
提取码：6666

我们对以下数据进行运算，在dating.txt中。保存的就是之前的约会对象数据

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
72993,10.141740,1.032955,1
35948,6.830792,1.213192,3
42666,13.276369,0.543880,3
67497,8.631577,0.749278,1
35483,12.273169,1.508053,3
50242,3.723498,0.831917,1

• 分析
  1、实例化MinMaxScalar
  2、通过fit_transform转换

import pandas as pd
from sklearn.preprocessing import MinMaxScaler


def minmax_demo():
    """
    归一化
    :return:
    """
    # 1.获取数据
    data = pd.read_csv('dating.txt')  # 读取文件用pandas是最方便的
    # print("data:\n", data)  # <class 'pandas.core.frame.DataFrame'>
    data = data.iloc[:, :3]  # 每行前三列取到
    # milage    Liters  Consumtime
    # 飞机里程数  公升数    消耗时间比
    print("data:\n", data)
    # 2.实例化一个转换器类
    transfer = MinMaxScaler()  # 默认[0,1]

    # 3.调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)
    # 飞机里程数很大、公升数很小,但我们看最终转换的效果都在[0,1]区间内,转化就完成了

    return None


if __name__ == '__main__':
    minmax_demo()

返回结果：

data:
      milage     Liters  Consumtime
0     40920   8.326976    0.953952
1     14488   7.153469    1.673904
2     26052   1.441871    0.805124
3     75136  13.147394    0.428964
4     38344   1.669788    0.134296
..      ...        ...         ...
995   11145   3.410627    0.631838
996   68846   9.974715    0.669787
997   26575  10.650102    0.866627
998   48111   9.134528    0.728045
999   43757   7.882601    1.332446

[1000 rows x 3 columns]
data_new:
 [[0.44832535 0.39805139 0.56233353]
 [0.15873259 0.34195467 0.98724416]
 [0.28542943 0.06892523 0.47449629]
 ...
 [0.29115949 0.50910294 0.51079493]
 [0.52711097 0.43665451 0.4290048 ]
 [0.47940793 0.3768091  0.78571804]]

试一下其他范围, 比如 [2,3]

transfer = MinMaxScaler(feature_range=(2, 3)) 

那么它这个结果就是[2-3]这个范围

data_new:
 [[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]]

Process finished with exit code 0

缺点：问题：如果数据中异常点较多，会有什么影响？

异常值通常在最大的地方或者最小的地方突然出现一个值，所以异常值一般是最大值或者最小值。

我们归一化的时候，就是用最大值最小值去求的，一旦我们最大值或者最小值是一个异常值，这么一计算，最终归一化的结果也不会太准。

5、归一化总结

注意最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景。

鲁棒性：其实就是 健壮性、稳定性

怎么办？

2.4.3 标准化

1、定义

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

2、公式

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

所以回到刚才异常点的地方，我们再来看看标准化

标准差 衡量的 离散程度（集中程度）。

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

3、API

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

4、数据计算

同样对上面的数据进行处理

• 分析
  1、实例化StandardScaler
  2、通过fit_transform转换

import pandas as pd
from sklearn.preprocessing import StandardScaler


def stand_demo():
    """
    标准化
    :return:
    """
    # 1.获取数据
    data = pd.read_csv('dating.txt')  # 读取文件用pandas是最方便的
    # print("data:\n", data)  # <class 'pandas.core.frame.DataFrame'>
    data = data.iloc[:, :3]  # 每行前三列取到
    # milage    Liters  Consumtime
    # 飞机里程数  公升数    消耗时间比
    # print("data:\n", data)
    # 2.实例化一个转换器类
    transfer = StandardScaler()

    # 3.调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)

    return None


if __name__ == '__main__':
    stand_demo()

结果：

data_new:
 [[ 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]]

这样返回过来的结果同样也是有无量纲化的效果，飞机里程数很大、公升数很小, 但我们经过这样回答转换之后，都是在均数为0标准差为1的附近, 每一列都有这样的一个特点，就进行了无量纲化处理，也就达到了我们的目的，并且还不容易受到异常点的影响。

如果需要对特征进行无量纲化处理，我们一般用的就是标准化。

5、标准化总结

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

2.5 特征降维

• 目标
  • 知道特征选择的嵌入式、过滤式以及包裹氏三种方式
  • 应用VarianceThreshold实现删除低方差特征
  • 了解相关系数的特点和计算
  • 应用相关性系数实现特征选择

2.5.1 降维

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

降维降的对象 是二维数组，几行代表有几个样本，几列代表有几个特征。我们现在要做的特征工程的特征降维的话，也是对二维数组进行处理的，所以我们明确我们的处理对象是二维数组，这里的降维到底降维降的是什么呢？降维的其实是我们特征的个数，也就是列数。

降维的要求：我们不仅要降低特征的个数，还要求最终的效果是 要求特征与特征之间不相关。这样的话有一个好处，如果这组特征里面有大量的相关的特征的话，这个会有冗余信息，这就导致特征太多了，本来不需要这么多，由于相关的特征太多，造成数据的冗余，如果数据量很大的话，我们处理起来就更不方便了。

• 降低随机变量的个数
  
  比如说一开始是一个三维的空间，我们的数分布在三维当中，我们现在不想让它维数这么多，想让它维数少一点，降成二维的，相当于把它转成平面当中，这样的一个转换就是我们降维做的事情。

• 相关特征(correlated feature)

  • 相对湿度与降雨量之间的相关
  • 等等

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

2.5.2 降维的两种方式

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

2.5.3 什么是特征选择

1 定义

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

2 方法

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

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

3 模块

sklearn.feature_selection

4 过滤式

4.1 低方差特征过滤

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

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

在概率论和统计方差是衡量随机变量或一组数据时离散程度的度量。概率论中方差用来度量随机变量和其数学期望（即均值）之间的偏离程度。

4.1.1 API

• sklearn.feature_selection.VarianceThreshold(threshold = 0.0)
  Variance方差 Threshold 阈值、临界值
  • threshold 临界值，低于临界值的特征都给他删掉，默认是0，意思是这列特征都一样的话就给他删掉。
  • 删除所有低方差特征
  • Variance.fit_transform(X)
    • X:numpy array格式的数据 [n_samples,n_features]
    • 返回值：训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征。

4.1.2 数据计算

网盘链接：链接：https://pan.baidu.com/s/1za_R-yrzpphy4sVd2JlelA?pwd=6666
提取码：6666

我们对某些股票的指标特征之间进行一个筛选，数据在"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

• 分析
  1、初始化VarianceThreshold,指定阀值方差
  2、调用fit_transform

import pandas as pd
from sklearn.feature_selection import VarianceThreshold


def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    # 1.获取数据
    data = pd.read_csv('factor_returns.csv')
    # print("data:\n", data)
    data = data.iloc[:, 1:-2]
    print("data:\n", data)

    # 2.实例化一个转换器类
    transfer = VarianceThreshold() # 默认threshold = 0.0

    # 3.调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new\n", data_new, data_new.shape)

    return None


if __name__ == '__main__':
    variance_demo()

返回结果：

data:
       pe_ratio  pb_ratio  ...       revenue  total_expense
0       5.9572    1.1818  ...  2.070140e+10   1.088254e+10
1       7.0289    1.5880  ...  2.930837e+10   2.378348e+10
2    -262.7461    7.0003  ...  1.167983e+07   1.203008e+07
3      16.4760    3.7146  ...  9.189387e+09   7.935543e+09
4      12.5878    2.5616  ...  8.951453e+09   7.091398e+09
...        ...       ...  ...           ...            ...
2313   25.0848    4.2323  ...  1.148170e+10   1.041419e+10
2314   59.4849    1.6392  ...  1.731713e+09   1.089783e+09
2315   39.5523    4.0052  ...  1.789082e+10   1.749295e+10
2316   52.5408    2.4646  ...  6.465392e+09   6.009007e+09
2317   14.2203    1.4103  ...  4.509872e+10   4.132842e+10

[2318 rows x 9 columns]
data_new
 [[ 5.95720000e+00  1.18180000e+00  8.52525509e+10 ...  2.01000000e+00
   2.07014010e+10  1.08825400e+10]
 [ 7.02890000e+00  1.58800000e+00  8.41133582e+10 ...  3.26000000e-01
   2.93083692e+10  2.37834769e+10]
 [-2.62746100e+02  7.00030000e+00  5.17045520e+08 ... -6.00000000e-03
   1.16798290e+07  1.20300800e+07]
 ...
 [ 3.95523000e+01  4.00520000e+00  1.70243430e+10 ...  2.20000000e-01
   1.78908166e+10  1.74929478e+10]
 [ 5.25408000e+01  2.46460000e+00  3.28790988e+10 ...  1.21000000e-01
   6.46539204e+09  6.00900728e+09]
 [ 1.42203000e+01  1.41030000e+00  5.91108572e+10 ...  2.47000000e-01
   4.50987171e+10  4.13284212e+10]] (2318, 9)

我们可以看到原来是9个特征，现在还是9个特征，说明我们这里面没有方差为0的特征，所以我们阈值设的还是比较苛刻。

transfer = VarianceThreshold(threshold=10)

结果：少了2列

data:
       pe_ratio  pb_ratio  ...       revenue  total_expense
0       5.9572    1.1818  ...  2.070140e+10   1.088254e+10
1       7.0289    1.5880  ...  2.930837e+10   2.378348e+10
2    -262.7461    7.0003  ...  1.167983e+07   1.203008e+07
3      16.4760    3.7146  ...  9.189387e+09   7.935543e+09
4      12.5878    2.5616  ...  8.951453e+09   7.091398e+09
...        ...       ...  ...           ...            ...
2313   25.0848    4.2323  ...  1.148170e+10   1.041419e+10
2314   59.4849    1.6392  ...  1.731713e+09   1.089783e+09
2315   39.5523    4.0052  ...  1.789082e+10   1.749295e+10
2316   52.5408    2.4646  ...  6.465392e+09   6.009007e+09
2317   14.2203    1.4103  ...  4.509872e+10   4.132842e+10

[2318 rows x 9 columns]
data_new
 [[ 5.95720000e+00  8.52525509e+10  8.00800000e-01 ...  1.21144486e+12
   2.07014010e+10  1.08825400e+10]
 [ 7.02890000e+00  8.41133582e+10  1.64630000e+00 ...  3.00252062e+11
   2.93083692e+10  2.37834769e+10]
 [-2.62746100e+02  5.17045520e+08 -5.67800000e-01 ...  7.70517753e+08
   1.16798290e+07  1.20300800e+07]
 ...
 [ 3.95523000e+01  1.70243430e+10  3.34400000e+00 ...  2.42081699e+10
   1.78908166e+10  1.74929478e+10]
 [ 5.25408000e+01  3.28790988e+10  2.74440000e+00 ...  3.88380258e+10
   6.46539204e+09  6.00900728e+09]
 [ 1.42203000e+01  5.91108572e+10  2.03830000e+00 ...  2.02066110e+11
   4.50987171e+10  4.13284212e+10]] (2318, 7)

threshold= 这个设置成什么根据你的需求来设置你的阈值，就可以过滤掉一些不太重要的特征。

4.2 相关系数

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

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

4.2.2 公式计算案例(了解，不用记忆)

• 公式
  

• 比如说我们计算年广告费投入与月均销售额

那么之间的相关系数怎么计算
十个样本，所以n=10

最终计算：

所以我们最终得出结论是广告投入费与月平均销售额之间有高度的正相关关系。

4.2.3 特点

相关系数的值介于–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

4.2.4 API

• from scipy.stats import pearsonr
  • pearsonr(x,y)
    • x : (N,) array_like
    • y : (N,) array_like
    • Returns: (Pearson’s correlation coefficient, p-value)
      • 返回的第一个就是相关性的值

scipy是一个python开源的数学计算库，可以应用于数学、科学以及工程领域，它是基于numpy的科学计算库。
scipy模块下面有很多包，其中 stats 有 统计分布和函数。

scipy的相关资料

• scipy官网：https://scipy.org
• scipy文档：https://docs.scipy.org/
• scipy源码：https://github.com/scipy/scipy
• scipy中文教程：https://wizardforcel.gitbooks.io/scipy-lecture-notes/content/

安装
pip install scipy
有时候通过pip默认的源来安装包的时候会非常的慢，这时候我们可以通过修改pip的源来提供下载包的速度，有清华源、阿里源、豆瓣源等都可以使用，我这里使用的是清华源设置方法如下：
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple scipy

4.2.5 案例：股票的财务指标相关性计算

我们刚才的股票的这些指标进行相关性计算， 假设我们以

factor = ['pe_ratio','pb_ratio','market_cap','return_on_asset_net_profit','du_return_on_equity','ev','earnings_per_share','revenue','total_expense']

这些特征当中的两两进行计算，得出相关性高的一些特征

• 分析
  • 两两特征之间进行相关性计算

import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from scipy.stats import pearsonr


def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    # 1.获取数据
    data = pd.read_csv('factor_returns.csv')
    # print("data:\n", data)
    data = data.iloc[:, 1:-2]
    # print("data:\n", data)

    # 2.实例化一个转换器类
    # transfer = VarianceThreshold()  # 默认threshold = 0.0
    # transfer = VarianceThreshold(threshold=10)

    # 3.调用fit_transform
    # data_new = transfer.fit_transform(data)
    # print("data_new\n", data_new, data_new.shape)

    # 计算某两个变量之间的相关系数
    r = pearsonr(data['pe_ratio'], data['pb_ratio'])
    print("相关系数:\n", r)  # PearsonRResult(statistic=-0.00438932277993627, pvalue=0.8327205496590723)
    print("相关系数:\n", r.statistic)
    return None


if __name__ == '__main__':
    variance_demo()

返回结果：

相关系数:
 PearsonRResult(statistic=-0.00438932277993627, pvalue=0.8327205496590723)
相关系数:
 -0.00438932277993627

-0.00438932277993627就是他的相关系数，是负相关，并且有点接近于0，也就是说这两者不是特别的相关。

import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from scipy.stats import pearsonr


def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    # 1.获取数据
    data = pd.read_csv('factor_returns.csv')
    data = data.iloc[:, 1:-2]
    # factor = ['pe_ratio', 'pb_ratio', 'market_cap', 'return_on_asset_net_profit', 'du_return_on_equity', 'ev', 'earnings_per_share', 'revenue', 'total_expense']
    factor = list(data.columns)
    print("列索引列表 ", factor)
    # 计算某两个变量之间的相关系数
    # r = pearsonr(data['pe_ratio'], data['pb_ratio'])
    # print("相关系数:\n", r)  # PearsonRResult(statistic=-0.00438932277993627, pvalue=0.8327205496590723)
    # print("相关系数:\n", r.statistic)
    for i in range(len(factor)):
        for j in range(i, len(factor) - 1):
            print(
                "指标%s与指标%s之间的相关性大小为%f" % (factor[i], factor[j + 1], pearsonr(data[factor[i]], data[factor[j + 1]])[0]))

    return None


if __name__ == '__main__':
    variance_demo()

返回结果：

列索引列表  ['pe_ratio', 'pb_ratio', 'market_cap', 'return_on_asset_net_profit', 'du_return_on_equity', 'ev', 'earnings_per_share', 'revenue', 'total_expense']
指标pe_ratio与指标pb_ratio之间的相关性大小为-0.004389
指标pe_ratio与指标market_cap之间的相关性大小为-0.068861
指标pe_ratio与指标return_on_asset_net_profit之间的相关性大小为-0.066009
指标pe_ratio与指标du_return_on_equity之间的相关性大小为-0.082364
指标pe_ratio与指标ev之间的相关性大小为-0.046159
指标pe_ratio与指标earnings_per_share之间的相关性大小为-0.072082
指标pe_ratio与指标revenue之间的相关性大小为-0.058693
指标pe_ratio与指标total_expense之间的相关性大小为-0.055551
指标pb_ratio与指标market_cap之间的相关性大小为0.009336
指标pb_ratio与指标return_on_asset_net_profit之间的相关性大小为0.445381
指标pb_ratio与指标du_return_on_equity之间的相关性大小为0.291367
指标pb_ratio与指标ev之间的相关性大小为-0.183232
指标pb_ratio与指标earnings_per_share之间的相关性大小为0.198708
指标pb_ratio与指标revenue之间的相关性大小为-0.177671
指标pb_ratio与指标total_expense之间的相关性大小为-0.173339
指标market_cap与指标return_on_asset_net_profit之间的相关性大小为0.214774
指标market_cap与指标du_return_on_equity之间的相关性大小为0.316288
指标market_cap与指标ev之间的相关性大小为0.565533
指标market_cap与指标earnings_per_share之间的相关性大小为0.524179
指标market_cap与指标revenue之间的相关性大小为0.440653
指标market_cap与指标total_expense之间的相关性大小为0.386550
指标return_on_asset_net_profit与指标du_return_on_equity之间的相关性大小为0.818697
指标return_on_asset_net_profit与指标ev之间的相关性大小为-0.101225
指标return_on_asset_net_profit与指标earnings_per_share之间的相关性大小为0.635933
指标return_on_asset_net_profit与指标revenue之间的相关性大小为0.038582
指标return_on_asset_net_profit与指标total_expense之间的相关性大小为0.027014
指标du_return_on_equity与指标ev之间的相关性大小为0.118807
指标du_return_on_equity与指标earnings_per_share之间的相关性大小为0.651996
指标du_return_on_equity与指标revenue之间的相关性大小为0.163214
指标du_return_on_equity与指标total_expense之间的相关性大小为0.135412
指标ev与指标earnings_per_share之间的相关性大小为0.196033
指标ev与指标revenue之间的相关性大小为0.224363
指标ev与指标total_expense之间的相关性大小为0.149857
指标earnings_per_share与指标revenue之间的相关性大小为0.141473
指标earnings_per_share与指标total_expense之间的相关性大小为0.105022
指标revenue与指标total_expense之间的相关性大小为0.995845

从中我们得出

• 指标revenue与指标total_expense之间的相关性大小为0.995845
• 指标return_on_asset_net_profit与指标du_return_on_equity之间的相关性大小为0.818697

如果我们想要看两个指标两个字段之间是否有一些线性关系的话，我们用什么来展示能很清楚的发现他们之间的关系？散点图

我们也可以通过画图来观察结果

import matplotlib.pyplot as plt
plt.figure(figsize=(20, 8), dpi=100)
plt.scatter(data['revenue'], data['total_expense'])
plt.show()

import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from scipy.stats import pearsonr
import matplotlib.pyplot as plt


def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    # 1.获取数据
    data = pd.read_csv('factor_returns.csv')
    # print("data:\n", data)
    data = data.iloc[:, 1:-2]
    # print("data:\n", data)

    # 2.实例化一个转换器类
    # transfer = VarianceThreshold()  # 默认threshold = 0.0
    # transfer = VarianceThreshold(threshold=10)

    # 3.调用fit_transform
    # data_new = transfer.fit_transform(data)
    # print("data_new\n", data_new, data_new.shape)

    # 计算某两个变量之间的相关系数
    r1 = pearsonr(data['pe_ratio'], data['pb_ratio'])
    print("相关系数:\n", r1)  # PearsonRResult(statistic=-0.00438932277993627, pvalue=0.8327205496590723)
    # print("相关系数:\n", r1.statistic)
    r2 = pearsonr(data['revenue'], data['total_expense'])
    print("revenue与total_expense之间的相关性:\n", r2)#  PearsonRResult(statistic=0.9958450413136116, pvalue=0.0)

    plt.figure(figsize=(20, 8), dpi=100)
    plt.scatter(data['revenue'], data['total_expense'])
    plt.show()
    return None


if __name__ == '__main__':
    variance_demo()

可以看到这个图两者非常有相关性，相关性很强，我们计算的结果（revenue与total_expense之间的相关性大小为0.995845）比较接近于1，所以就应证了这两个指标之间相关性比较大。

这两对指标之间的相关性较大，可以做之后的处理，比如合成这两个指标。

特征与特征之间相关性很高，怎么进行特征选择：
  1）选取其中一个
  2）加权求和
  3）主成分分析

2.6 主成分分析

• 目标
  • 应用PCA实现特征的降维
• 应用
  • 用户与物品类别之间主成分分析

2.6.1 什么是主成分分析(PCA)

• 定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量

• 作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。

• 应用：回归分析或者聚类分析当中

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

那么更好的理解这个过程呢？我们来看一张图

对一个水壶进行拍摄，日常生活中我们接触到的就是一个三维的空间，如果我们用相机把这个三维空间的图像给记录下来，我们做的这个事情是有点类似于降维，照片是二维的，当我们将现实生活中的场景通过相机记录下来，成为一张照片，其实也就相当于在做降维，将三维降到二维。在这样的一个过程中，那么它就可能会有一些信息的损失，我们如何去衡量在这个过程中信息损失了多少？很直观的检验方法就是我们还能不能通过这个二维的图像能够还原出（知道）它还是一个水壶，所以我们看这四张不同角度去拍摄水壶，哪个还能看出它是一个水壶？第四张能看出，也就意味着第四张照片从三维降到二维这个过程，它损失的信息是最少的，其他图片我们基本看不太出来。如果不告诉你是水壶，它也可能是一个钟等等，所以我们pc 主成分分析，它做的一件什么事情呢？它就是在做降维，并且能够尽可能的去保留最多的信息，让你降维后这个数据还能够保持原有的特征，这就是pc做的事情

1 计算案例理解(了解，无需记忆)

假设对于给定5个点，数据如下

(-1,-2)
(-1, 0)
( 0, 0)
( 2, 1)
( 0, 1)

要求：将这个二维的数据简化成一维？ 并且损失少量的信息

五个点投影到线上，原来是五个点，降维之后还是五个点，并且这五个点到线的距离之和比较少。

虽然说也可以选取其他的线，但是可能这样子的话，它的距离之和加起来会大一点，我们希望能让它的距离之和稍微小一点，这个是pca降维希望做的事情。

这个过程如何计算的呢？找到一个合适的直线，通过一个矩阵运算得出主成分分析的结果（不需要理解）

过程比较复杂，可以去看看pca的原理，可以看看过程，这个方法最终达到一个效果就是前面写的理解这张图就可以了。

2 API

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

3 数据计算

先拿个简单的数据计算一下

[[2,8,4,5],
[6,3,0,8],
[5,4,9,1]]

from sklearn.decomposition import PCA


def pca_demo():
    data = [[2, 8, 4, 5],
            [6, 3, 0, 8],
            [5, 4, 9, 1]]
    # 1.实例化一个转换器类
    transfer=PCA(n_components=2)# 四个特征降成两个特征
    data_new=transfer.fit_transform(data)
    print("data_new:",data_new)
    # 2.调用fit_transform
    return None

if __name__ == "__main__":
    pca_demo()

返回结果：

data_new: [[-3.13587302e-16  3.82970843e+00]
 [-5.74456265e+00 -1.91485422e+00]
 [ 5.74456265e+00 -1.91485422e+00]]

我们试一下传小数：

transfer = PCA(n_components=0.95)  # 保留95%的信息

结果：

data_new: [[-3.13587302e-16  3.82970843e+00]
 [-5.74456265e+00 -1.91485422e+00]
 [ 5.74456265e+00 -1.91485422e+00]]

它还是两个特征，说明我们把它降到两个特征，虽然从四个特征降成两个特征好像已经降了一半的特征，但是其实它还保留了原来95%的特征，说明这个方法还是很好的，既降维还保留了尽可能多的信息，这就是PCA降维。

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

数据如下：

• order_products__prior.csv：订单与商品信息
  • 字段：order_id, product_id, add_to_cart_order, reordered
• products.csv：商品信息
  • 字段：product_id, product_name, aisle_id, department_id
• orders.csv：用户的订单信息
  • 字段：order_id,user_id,eval_set,order_number,….
• aisles.csv：商品所属具体物品类别
  • 字段： aisle_id, aisle

1 需求

案例背景：kaggle上一个Instacart公司发布的一个比赛，这个比赛要预测Instacart用户（消费者）下一步将要购买哪些产品。为了完成这样一个目标，首先需要探究这里面的用户，他对这个一些物品的喜好，为了完成这样的一个任务，我们需要准备什么样的数据？
        翻译过来相当于我们要找到用户和物品类别之间的关系，首先我们需要有用户，也有他相应购买物品类别的一些信息。首先我们需要找到 user_id 用户id 这样的一个字段，aisle 物品类别字段 。 但是我们发现一个问题啦，user_id在orders.csv数据文件里，而aisle在aisles.csv数据文件当中，要想找到物品类别与用户之间的关系，它们是不是隔得太远了？所以我们想要了我们之前学过的，要合并不同的表把它合并到一张表中，让我们进一步的去解决问题。

分析的结果（接下来我们要完成的3大步骤）：
1.需要将用户user_id和aisle放 同一张表当中，我们可以用 合并。
2.找到user_id和aisle这两者之间的关系，那我们可以想到用交叉表和透视表
        我们说要找到用户和这个物品之间的一个关系，那我们把它们放到一张表中其实还不够，我们还希望能够具体找到这两个变量之间的关系，想将我们最终的结果处理成这样的一种形式。行索引是user_id用户，列索引就是一个个的物品类别，其中就是某一个物品类别购买的数量，比如2号用户购买asian foods亚洲食物有3次，后来还有其他的比如tea茶有一次。

        根据这样的一些数据，我们用一些机器学习算法其实就可能分析出这些用户他的一些特性，当我们根据用户购买物品类别的偏好进行进一步的对用户的细分，然后对不同的用户采取不同的营销策略。这是Instacart他想做的一个事情。


3.特征冗余过多，所以要降维了，在这里用PCA降维
        我们现在目前学的还是特征工程，也只是对数据进行处理，最终得出消费者要购买哪些产品是我们之后机器学习算法的部分，数据这个部分我们还需要做什么呀?我们看到当我们将这个user_id与aisle放一张表当中并且进行了交叉表和透视表 处理之后是这样一张表，行索引是user_id用户，列索引是我们之后要处理的特征 就是这些物品类别，但是我们发现这些特征有什么样的特点？是不是有大量的0呀，有大量的0就意味着我们的特征有大量的冗余，并且总共有134个特征，之前在做特征工程的时候我们还没遇到这么多特征的。所以我们要做降维，这里就有主成分分析的方法进行降维（PCA降维）。

2 分析

• 合并表，使得user_id与aisle在一张表当中
• 进行交叉表变换
• 进行降维

3 完整代码

网盘链接：链接：https://pan.baidu.com/s/1za_R-yrzpphy4sVd2JlelA?pwd=6666
提取码：6666
数据在instacart文件夹里

数据还是不小的，其中order_products__prior.csv有550.80M，因为我们接下来要进行数据处理，为了数据展示方便，我们用jupyter notebook来做。

打开cmd，输入jupyter notebook

新建一个文件

代码：

# 1.获取数据
# 2.合并表
# 3.找到user_id与aisle之间的关系
# 4.PCA降维
import pandas as pd
# 1. 获取数据
# 也可以写个for循环去遍历读文件，这样会快一点
order_products = pd.read_csv("./instacart/order_products__prior.csv")
products = pd.read_csv("./instacart/products.csv")
orders = pd.read_csv("./instacart/orders.csv")
aisles  = pd.read_csv("./instacart/aisles.csv")

order_products # 订单与商品信息
products #商品信息
orders # 用户的订单信息
aisles # 商品所属具体物品类别

# 2.合并表
# order_products__prior.csv：订单与商品信息
# 字段：order_id, product_id, add_to_cart_order, reordered
# products.csv：商品信息
# 字段：product_id, product_name, aisle_id, department_id
# orders.csv：用户的订单信息
# 字段：order_id,user_id,eval_set,order_number,….
# aisles.csv：商品所属具体物品类别
# 字段： aisle_id, aisle

#  合并aisles和products表（以aisle_id为基准合并）
# 目的：aisles和product_id在一起
#    pd.merge 按索引合并，默认how="inner"内连接,on：按哪一个索引进行拼接
tab1 = pd.merge(aisles,products,on=["aisle_id","aisle_id"])
tab1 # order_products表有 product_id、order_id
tab2 = pd.merge(tab1,order_products,on=["product_id","product_id"])
tab2 # aisle和order_id在一个表中
# orders表中有order_id、user_id
tab3 = pd.merge(tab2,orders,on=["order_id","order_id"])
tab3.head() # 想要的aisles和user_id都在一张表中

# 3. 找到 user_id 和 aisle 这两者之间的关系
# 交叉表用于计算一列数据对于另外一列数据的分组个数（寻找两个列之间的关系）
table = pd.crosstab(tab3["user_id"],tab3["aisle"]) # 交叉表
table
#我们看到，行索引user_id，有206209个用户；
#每个用户购买类别的情况都在这个表当中了，134个物品类别

# 134个特征太多了，并且有大量的0，很显然它里面有很多的冗余
# 所以我们要进行降维
data = table[:10000]# 由于数据量太大，运行要好久，可以先只取1万个数据好了，这样我们数据量就少一点了，处理起来就快一点了
# data = table

# 4. PCA降维
from sklearn.decomposition import PCA
# 4.1 实例化一个转换器类
transfer = PCA(n_components=0.95)# 保留95% 的信息
# 4.2 调用fit_transform
data_new = transfer.fit_transform(data)
data_new # 这个就是我们降维后的结果
data_new.shape # 形状(10000, 42),原来134个特征 降到 42个特征

返回结果：

可以发现：其实我们在处理比较大一点的案例的时候，耗时比较多的是 数据处理 ，而真正用到机器学习相关的方法（特征工程）一两行就搞定了。
之后很大一部分工作都是在做数据处理。

总结

1、数据集的结构是什么?
答案: 特征值+ 目标值

2、机器学习算法分成哪些类别? 如何分类
答案: 根据是否有目标值分为 监督学习和非监督学习

根据目标值的数据类型: 目标值为离散值就是分类问题

目标值为连续值就是回归问题

3、什么是标准化? 和归一化相比有什么优点?
答案: 标准化是通过对原始数据进行变换把数据变换到均值为0,方差为1范围内

优点: 少量异常点, 不影响平均值和方差, 对转换影响小

分类算法

目标值:类别
1、sklearn转换器和预估器
2、KNN算法
3、模型选择与调优
4、朴素贝叶斯算法
5、决策树
6、随机森林

3.1 sklearn转换器和估计器

3.1.1 转换器和估计器

转换器

想一下之前做的特征工程的步骤？

• 1、实例化 (实例化的是一个转换器类(Transformer))
• 2、调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

标准化：
(x - mean) / std
fit_transform()
         fit() 计算 每一列的平均值、标准差
         transform()         (x - mean) / std进行最终的转换

我们把特征工程的接口称之为转换器，其中转换器调用有这么几种形式

• fit_transform
• fit
• transform

这几个方法之间的区别是什么呢？我们看以下代码就清楚了

In [1]: from sklearn.preprocessing import StandardScaler

In [2]: std1 = StandardScaler()

In [3]: a = [[1,2,3], [4,5,6]]

In [4]: std1.fit_transform(a)
Out[4]:
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])

In [5]: std2 = StandardScaler()

In [6]: std2.fit(a)
Out[6]: StandardScaler(copy=True, with_mean=True, with_std=True)

In [7]: std2.transform(a)
Out[7]:
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])

从中可以看出，fit_transform的作用相当于transform加上fit。但是为什么还要提供单独的fit呢, 我们还是使用原来的std2来进行标准化看看

In [8]: b = [[7,8,9], [10, 11, 12]]

In [9]: std2.transform(b)
Out[9]:
array([[3., 3., 3.],
       [5., 5., 5.]])

In [10]: std2.fit_transform(b)
Out[10]:
array([[-1., -1., -1.],
       [ 1.,  1.,  1.]])

估计器(sklearn机器学习算法的实现)

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

1. 用于分类的估计器：
   • sklearn.neighbors k-近邻算法
   • sklearn.naive_bayes 贝叶斯
   • sklearn.linear_model.LogisticRegression 逻辑回归
   • sklearn.tree 决策树与随机森林
2. 用于回归的估计器：
   • sklearn.linear_model.LinearRegression 线性回归
   • sklearn.linear_model.Ridge 岭回归
3. 用于无监督学习的估计器
   • sklearn.cluster.KMeans 聚类

估计器工作流程

回忆本博客 2.1.3 数据集的划分

估计器(estimator)
         1 实例化一个estimator
         2 estimator.fit(x_train, y_train) 计算
                  —— 调用完毕，模型生成
         3 模型评估：
                  1）直接比对真实值和预测值
                           y_predict = estimator.predict(x_test)
                           y_test == y_predict
                  2）计算准确率
                           accuracy = estimator.score(x_test, y_test)

3.2 K-近邻算法

问题：回忆分类问题的判定方法

什么是K-近邻算法

• 核心思想：你的“邻居”来推断出你的类别

K-近邻算法是怎么进行分类的？下面我们通过例子来讲解基本原理

假如说我在这个圆圈的位置，我不知道我在北京的哪个区，我想要知道我现在在北京哪个区，这个可以看成分类问题，我想要解决这个分类问题，如果我用K近邻算法的话就是这样的一个思路，我虽然不知道我在哪，但是我知道我跟这几个人之间的距离，并且我也知道这五个人在哪个区，想要去判断我到底属于哪个区 我是不是可以看最近的人在哪个区 我就有极大的可能性就在哪个区，所以我们就看到我们跟蓝色的小男孩这个距离最近的，而他在朝阳区，所以我就判断我所在的区域就是在北京的朝阳区。这就是K-近邻算法的原理，就这么简单。

1、K-近邻算法(KNN)原理

K Nearest Neighbor算法又叫KNN算法，这个算法是机器学习里面一个比较经典的算法, 总体来说KNN算法是相对比较容易理解的算法。

一句话：根据我的邻居来判断我的类别

1.1 定义

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


注意：
    如果k=1，k值取很小，容易受到异常点的影响。
    k值取很大，受到样本均衡的问题，容易受到样本不均衡的影响。

来源：KNN算法最早是由Cover和Hart提出的一种分类算法

1.2 距离公式

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

扩展：

• 除了欧氏距离可以衡量以外，还有一个叫做 曼哈顿距离(绝对值距离)
  =|a1-b1|+|a2-b2|+|a3-b3|         绝对值
• 闵可夫斯基距离 (Minkowski Distance)，也被称为 闵氏距离。它不仅仅是一种距离，而是将多个距离公式（曼哈顿距离、欧式距离、切比雪夫距离）总结成为的一个公式。
  曼哈顿距离、欧式距离是闵可夫斯基距离的特殊情况。我们说 闵可夫斯基距离 是 曼哈顿距离、欧式距离的一个推广。

2、电影类型分析

其中 ? 号电影不知道类别，如何去预测？我们可以利用K近邻算法的思想

假如说k取了1，那么也就是说离我最近的就是 He’s not Really into dues ，距离18.7，而他是属于爱情片，所以我们就认为 未知电影 属于爱情片。

k=7, 离我 未知电影 最近的7个样本当中，有3个是爱情片，有4个是动作片，导致最终分成了动作片，但是我们看我们 未知电影 的接吻镜头 远远大于 打斗镜头的，那么它很有可能就是爱情片，所以也就意味着 当我们k值取得过大，当样本不均衡的时候，容易受到样本不均衡的影响（分错）。

2.1 问题

• 如果取的最近的电影数量不一样？会是什么结果？
  回答： k 值取得过小，容易受到异常点的影响；k 值取得过大，样本不均衡的影响。

• 结合前面的约会对象数据，分析K-近邻算法需要做什么样的处理？
  无量纲化的处理
          标准化

2.2 K-近邻算法API

• sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
  Neighbors 邻居
  Classifier 分类器
  • n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数。其实就是K近邻中的 k值 。
  • algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’ 将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)
    这个算法其实跟机器学习算法没有什么关系，它只是说我们在计算样本之间的距离的时候， 你需要找到你的邻居，那么它就需要进行 搜索排序查询 这其实是 数据结构层面 的东西。这个你就不用管它，它本来就实现的挺好的，按默认的 ‘auto’ ，它就会根据你fit进来的特征值和目标值 选择最合适的算法进行计算，会选择效率最高的方法。
• 我们在调用KNeighborsClassifier的时候如何去体现这个距离？其实就是这些参数
  • metric=“minkowski”
    "minkowski"其实就是 闵可夫斯基距离 的意思，但是我们在经常在使用的时候是用的 欧氏距离 ，看参数 p
  • p=2 默认欧氏距离
    我们说 闵可夫斯基距离 是 曼哈顿距离、欧式距离的一个推广，闵可夫斯基距离 当中 公式 里面 有一个p值。如果 p值=1 的话，就是 曼哈顿距离(绝对值距离) ；p值=2 那就是 欧氏距离。

3、案例：鸢尾花种类预测

数据集介绍

lris数据集是常用的分类实验数据集，由Fisher,1936收集整理。lris也称鸢尾花卉数据集，是一类多重变量分析的数据集。关于数据集的具体介绍:

实例数量: 150(三个类各有50个)
属性数量: 4(数值型，数值型，帮助预测的属性和类)

Attribute Information:

• sepal length 萼片长度 (厘米)
• sepal width 萼片宽度 (厘米)
• petal length 花瓣长度 (厘米)
• petal width 花瓣宽度 (厘米)
• class:
  • Iris-Setosa 山鸢尾
  • lris-Versicolour 变色尾
  • lris-Virginica 维吉尼亚鸢尾

步骤分析

• 获取数据
• 数据集划分
• 特征工程：标准化
• KNN预估器流程
• 模型评估

代码

KNN算法对鸢尾花进行分类

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


def knn_iris():
    """
    KNN算法对鸢尾花进行分类
    :return:
    """
    # 1.获取数据
    iris = load_iris()
    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=6)
    # 参数: test_size 测试集的大小 默认0.25
    # random_state  随机数种子

    # 3.特征工程: 标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)  # 训练集做了标准化
    x_test = transfer.transform(x_test)  # 测试集也需要做标准化

    # 4.KNN预估器流程
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)  # 得到模型

    # 5.模型评估
    # 方法一: 直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("直接比对真实值和预测值:\n",y_test==y_predict)
    # 方法二: 计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率为:\n",score)
    return None


if __name__ == "__main__":
    knn_iris()

分析代码 3. 特征工程：标准化
因为你其实相当于 让模型最终用同样分布的 分布状况的 数据 来对这个模型进行检验。所以训练集做了什么手脚，那么测试集也必须要做同样的手脚，这样才能真正的检验出来他到底好不好。

在进行标准化的时候，是分两步的
        1.fit 计算 - 每一列的平均值、标准差
        2.transform 转换

如果我要对测试集也要进行标准化，那么这时候用fit_transform还是用transform?
测试集 应该用transform

transfer.fit_transform(x_train) 相当于对训练集每个特征求了一个平均值和标准差, 然后在进行最终的标准化的时候, 用的训练集的平均值和标准差进行 转换, 如果你在调用 x_test 测试集进行标准化的话, 如果你用的是测试集的平均值标准差, 那相当于对测试集做了不一样的处理。我们希望的是对测试集做跟训练集一样的处理, 所以我们就需要用 训练集 特征当中的标准差和平均值来对测试集的数据进行标准化。所以这个时候, 我们在对测试集进行标准化, 要用transform不要用fit_transform。

运行结果

y_predict:
 [0 2 0 0 2 1 1 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
 2]
直接比对真实值和预测值:
 [ True  True  True  True  True  True False  True  True  True  True  True
  True  True  True False  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True False  True
  True  True]
准确率为:
 0.9210526315789473

数据集划分不一样可能结果就不一样

x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)

结果：

y_predict:
 [0 2 1 2 1 1 1 2 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 2 2 2 2 0 0 1 1 1 0 0
 0]
直接比对真实值和预测值:
 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True]
准确率为:
 0.9736842105263158

x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=23)

结果：

y_predict:
 [2 2 1 0 2 1 0 2 0 1 1 0 2 0 0 2 1 1 2 0 2 0 0 0 2 0 0 2 1 1 0 1 0 2 0 0 1
 1]
直接比对真实值和预测值:
 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True]
准确率为:
 1.0

结果分析

• k值取多大? 有什么影响?
  • k值取很小:容易受到异常点的影响
  • k值取很大:受到样本均衡的问题
• 性能问题?
  • 距离计算上面，时间复杂度高
    所以在大数据场景下效率比较低

4、K-近邻总结

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

KNN算法他有一个缺陷，其中一个缺陷就是这个k值取值是不一定的，我们需要选择一个合适的k值取得尽可能好的结果。有没有一个方法能够方便的让我们去选择最合适的k值呢？ 模型选择与调优 这部分 是可以解决这个问题的。

3.3 模型选择与调优

1、为什么需要交叉验证

交叉验证目的：为了让被评估的模型更加准确可信

2、什么是交叉验证(cross validation)

交叉验证：将拿到的训练数据，分为训练和验证集。以下图为例：将数据分成5份，其中一份作为验证集。然后经过 4或者5 次(组)的测试，每次都更换不同的验证集。即得到 4或者5组模型的结果（准确率），取平均值作为最终结果。又称4折交叉验证 或者 5折交叉验证。

2.1 分析

我们之前知道数据分为训练集和测试集，但是为了让从训练得到模型结果更加准确。做以下处理

• 训练集：训练集+验证集
• 测试集：测试集
  
  问题：那么这个只是对于参数得出更好的结果，那么怎么选择或者调优参数呢？

3、超参数搜索-网格搜索(Grid Search)

举个例子，我们要对k值进行选择，我们如何选择合适的k值，我们最能想到的、最简单的方法就是 准备一些k值[1, 3, 5, 7, 9, 11]，我想知道这里面哪个参数能让我们最后分类效果是最好的，能够得到最高的准确率。我们最先想到的是怎么得出这个结论呀？是不是就是遍历，就跟密码暴力破解似的，一个一个试一下，写个for循环一个一个试，其实网格搜索就是在帮助我们自动做这些事情，只不过我们不需要自己去写这个for循环了。

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

3.1 模型选择与调优API

• sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
  Grid 网格 Search 搜索
  CV 交叉验证 cross validation
  • 对估计器的指定参数值进行详尽搜索
  • estimator：估计器对象
    我们用的时候GridSearchCV也相当于一个继承自estimator预估器的一个类，所以我们使用的时候跟预估器的使用方法是一样的。.fit() 和 .score()
  • param_grid：估计器参数(dict) {“n_neighbors”:[1,3,5]}
  • cv：指定几折交叉验证
    最常用的就是10折交叉验证，如果数据量比较大的话，单纯演示的话，10折会很耗时，可以设置小一点。
  • fit()：输入训练数据
  • score()：准确率
  • 属性
    • 结果分析：
      • 最佳参数： best_params_
      • 最佳结果： best_score_
        在交叉验证中验证的最好结果
      • 最佳估计器： best_estimator_
        最好的参数模型
      • 交叉验证结果： cv_results_
        每次交叉验证后的验证集准确率结果和训练集准确率结果

4、鸢尾花案例增加K值调优

拿上一个案例的代码，在这基础上增加K值调优

• 使用GridSearchCV构建估计器

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


def knn_iris_gscv():
    """
    KNN算法对鸢尾花进行分类, 添加网格搜索和交叉验证
    :return:
    """
    # 1.获取数据
    iris = load_iris()
    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    # 参数: test_size 测试集的大小 默认0.25
    # random_state  随机数种子

    # 3.特征工程: 标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)  # 训练集做了标准化
    x_test = transfer.transform(x_test)  # 测试集也需要做标准化

    # 4.KNN预估器流程
    # estimator = KNeighborsClassifier(n_neighbors=3)
    estimator = KNeighborsClassifier()  # 没必要加上k值了
    # 添加网格搜索和交叉验证
    param_dict = {'n_neighbors': [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    # 本身数据量不大,只有150个样本, 10折交叉验证, 还用estimator接收,这样后面的代码就不用改了

    estimator.fit(x_train, y_train)  # 得到模型

    # 5.模型评估
    # 方法一: 直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)
    # 方法二: 计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)

    print("+" * 10 + "分隔线" + "+" * 10)

    print('最佳参数:\n', estimator.best_params_)
    print('最佳结果:\n', estimator.best_score_)
    print('最佳估计器:\n', estimator.best_estimator_)
    print('交叉验证结果:\n', estimator.cv_results_)

    return None


if __name__ == "__main__":
    knn_iris_gscv()

y_predict:
 [0 2 1 2 1 1 1 2 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 2 2 2 2 0 0 1 1 1 0 0
 0]
直接比对真实值和预测值:
 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True]
准确率为:
 0.9736842105263158
++++++++++分隔线++++++++++
最佳参数:
 {'n_neighbors': 3}
最佳结果:
 0.9553030303030303
最佳估计器:
 KNeighborsClassifier(n_neighbors=3)
交叉验证结果:
 {'mean_fit_time': array([0.00138659, 0.        , 0.00150073, 0.00156238, 0.        ,
       0.00010364]), 'std_fit_time': array([0.00374409, 0.        , 0.00450218, 0.00468714, 0.        ,
       0.00031092]), 'mean_score_time': array([0.00169234, 0.00156777, 0.00156312, 0.        , 0.00316582,
       0.00312572]), 'std_score_time': array([0.0033536 , 0.00470331, 0.00468936, 0.        , 0.00526248,
       0.00625143]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
             mask=[False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([0.91666667, 0.91666667, 1.        , 1.        , 0.91666667,
       0.91666667]), 'split1_test_score': array([1., 1., 1., 1., 1., 1.]), 'split2_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 0.90909091,
       0.90909091]), 'split3_test_score': array([0.90909091, 1.        , 0.90909091, 0.90909091, 0.90909091,
       1.        ]), 'split4_test_score': array([1., 1., 1., 1., 1., 1.]), 'split5_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 0.90909091,
       0.90909091]), 'split6_test_score': array([0.90909091, 0.90909091, 0.90909091, 1.        , 1.        ,
       1.        ]), 'split7_test_score': array([0.90909091, 0.90909091, 0.81818182, 0.81818182, 0.81818182,
       0.81818182]), 'split8_test_score': array([1., 1., 1., 1., 1., 1.]), 'split9_test_score': array([1., 1., 1., 1., 1., 1.]), 'mean_test_score': array([0.94621212, 0.95530303, 0.94545455, 0.95454545, 0.94621212,
       0.95530303]), 'std_test_score': array([0.04397204, 0.0447483 , 0.06030227, 0.06098367, 0.05988683,
       0.0604591 ]), 'rank_test_score': array([4, 1, 6, 3, 4, 1])}

首先，预测值y_predict 虽然用的不再是之前的estimator，我们用的是GridSearchCV，但是它一样也是可以得出结果的。
然后就是比对真实值和预测值 准确率 0.97，模型选择与调优的最佳结果 准确率 0.95 ，为什么准确率和最佳结果会不一样 ？注意，best_score_，这个属性会存储模型在交叉验证中所得的最高分，而不是测试数据集上的得分。<\b>

5、案例：预测facebook签到位置

facebook发布在kaggle上的一个比赛

数据介绍：将根据用户的位置，准确性和时间戳预测用户正在查看的业务。

train.csv，test.csv 
row_id：登记事件的ID。签到行为的编码，其实就相当于一个索引，没什么意义。
x y：坐标。x y 其实就是坐标系，就是人所在的位置。
accuracy 准确性：定位准确性 。我们一般是用手机上的GPS定位，但是这个定位也可能不太准，因为不同的卫星它的准确度是不一样的，这是他的一个字段，代表定位的准确度、准确率。
time 时间：时间戳 。1970-01-01 到 某一天的秒数。
place_id：业务的ID，这是您预测的目标。预测我们用户将要签到的位置是什么。

官网：https://www.kaggle.com/navoshta/grid-knn/data

文件我放网盘里了 链接：https://pan.baidu.com/s/1XFWGZJopEeZGw3gIbGQeTg?pwd=1024
提取码：1024
FBlocation 文件夹，train.csv、test.csv

我们看到train.csv文件1.18G是很大的， 所以我们在梳理数据的时候，如果我们要反复的调试这些数据，如果用PyCharm每次运行要重新加载一遍，非常的麻烦，所以我们还是用jupyter

流程分析

1）获取数据
2）数据处理
    目的：
        特征值
        目标值
        a. 缩小数据范围（练习的时候才会这么做，为了节省时间），缩小数据范围跟真实开发情况中不需要去做的这个事，我们本身数据量太大了，2千多万条数据如果我们所有的数据都一并处理的话，比较耗时。

比如说我们按坐标，以xy坐标为基准进行缩小，总共是10万 x 10万这样的一块区域，我们给它取一小块作为我们数据集进行进一步的分析，那么就可以根据坐标来缩小范围，比如说我取坐标在
2 < x <2.5
1.0 < y < 1.5          看你自己想怎么取怎么取

        b. time 一> 年月日时分秒。 time字段只是一个时间戳，但是作为特征来讲，我们希望这个时间更有意义，比如说早上，如果你去预测你签了一次到，很有可能是在公园或者在通勤的路上，这些都有可能；或者说在周六很可能就在商场，可能在家睡觉这些都是有可能的。所以我们如果用时间这个特征的话，我们更希望这个事件不是单一的时间戳，而是更有意义的年月日时分秒…

        c. 过滤签到次数少的地点其实我们这么多签到的数据，里面签到的地点，很有可能有些地点最多只被签到了一次或者两次，对于 这种地点对于facebook没有统计意义，我们更希望知道经常去的地点，它的一个情况。所以我们在数据处理的时候，也可以签到地点 签到次数比较少的地方直接排除掉。

3）特征工程：标准化
4）KNN算法预估流程
5）模型选择与调优
6）模型评估

代码

import pandas as pd
# 1.. 获取数据
data = pd.read_csv("./FBlocation/train.csv")
data
# 2.基本的数据处理
# 1）缩小数据范围（练习的时候才会这么做，为了节省时间）
# 提供的一个思路：以xy坐标为基准进行缩小
data = data.query("x<2.5 & x>2 & y<1.5 & y>1.0")
data
# 2) 处理时间特征
# time 时间戳 -> 年月日时分秒。
time_value = pd.to_datetime(data['time'],unit='s')# 指定时间戳的单位
time_value # 这是一个Series类型的数据
time_value.values
date = pd.DatetimeIndex(time_value)# 转换
date
date.weekday # 1星期二; 0是星期一
date.year # 都是1970  要来没什么用
date.month # 都是1  要来没什么用
date.day # 日期
date.hour # 小时

data['day'] = date.day
data['hour'] = date.hour
data['weekday'] = date.weekday 
# SettingWithCopyWarning: 
# A value is trying to be set on a copy of a slice from a DataFrame.
# Try using .loc[row_indexer,col_indexer] = value instead警告接着用,没事的


data # 时间戳已经转换成一些有用的特征了

# 3）过滤签到次数少的地点
# 统计一下 place_id
# data.groupby("place_id").count() 
place_count = data.groupby("place_id").count()["row_id"]# 每个字段都是统计地点被签到多少次，没必要全都要
place_count
place_count[place_count > 3]# 选出来的是签到次数>3的地点id
data_final = data[  data["place_id"].isin(place_count[place_count > 3].index.values)  ]
data_final# 处理后的结果

# 筛选特征值和目标值
x = data_final[['x','y','accuracy','day','hour','weekday']]
y = data_final["place_id"]
x
y
# 数据集划分
from sklearn.model_selection import train_test_split 
x_train,x_test,y_train,y_test = train_test_split(x,y)# test_size= 测试集的大小默认0.25
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV


# 3.特征工程: 标准化
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)  # 训练集做了标准化
x_test = transfer.transform(x_test)  # 测试集也需要做标准化

# 4.KNN预估器流程
estimator = KNeighborsClassifier()
# 添加网格搜索和交叉验证
param_dict = {'n_neighbors': [ 3, 5, 7, 9, 11]}
estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10) # 10折交叉验证,数据量大建议用cv=3

estimator.fit(x_train, y_train)  # 得到模型

# 5.模型评估
# 方法一: 直接比对真实值和预测值
y_predict = estimator.predict(x_test)
print("y_predict:\n", y_predict)
print("直接比对真实值和预测值:\n", y_test == y_predict)
# 方法二: 计算准确率
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)

print("+" * 10 + "分隔线" + "+" * 10)

print('最佳参数:\n', estimator.best_params_)
print('最佳结果:\n', estimator.best_score_)
print('最佳估计器:\n', estimator.best_estimator_)
print('交叉验证结果:\n', estimator.cv_results_)

运行结果

y_predict:
 [5304570159 1949544719 5232128865 ... 5448001036 5232128865 6787040850]
直接比对真实值和预测值:
 28017380    False
8859899     False
9587364     False
2067248      True
15917174    False
            ...  
4937248     False
23673105    False
27174947     True
13917941     True
28518400    False
Name: place_id, Length: 20228, dtype: bool
准确率为:
 0.3606387186078703
++++++++++分隔线++++++++++
最佳参数:
 {'n_neighbors': 5}
最佳结果:
 0.3597607708017869
最佳估计器:
 KNeighborsClassifier()
交叉验证结果:
 {'mean_fit_time': array([0.08854768, 0.10602798, 0.18479028, 0.11244125, 0.10711095]), 'std_fit_time': array([0.0144927 , 0.0233614 , 0.06470464, 0.0105941 , 0.0051431 ]), 'mean_score_time': array([0.38352401, 0.55316637, 1.04415717, 0.58939171, 0.58459861]), 'std_score_time': array([0.05664922, 0.16247061, 0.36381429, 0.04717116, 0.0345666 ]), 'param_n_neighbors': masked_array(data=[3, 5, 7, 9, 11],
             mask=[False, False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([0.3504696 , 0.3592025 , 0.3592025 , 0.35854342, 0.35376504]), 'split1_test_score': array([0.34453782, 0.35722524, 0.35475367, 0.35425935, 0.35096391]), 'split2_test_score': array([0.34574819, 0.35332894, 0.35431773, 0.35332894, 0.34640738]), 'split3_test_score': array([0.33487146, 0.35613052, 0.35102175, 0.34739618, 0.3436058 ]), 'split4_test_score': array([0.33635465, 0.35596572, 0.35629532, 0.34871457, 0.34459459]), 'split5_test_score': array([0.3590969 , 0.36931444, 0.36783125, 0.35711931, 0.35266974]), 'split6_test_score': array([0.34228741, 0.36189848, 0.36618326, 0.3600857 , 0.35135135]), 'split7_test_score': array([0.34920897, 0.36404087, 0.36189848, 0.35711931, 0.35580092]), 'split8_test_score': array([0.35530653, 0.36255768, 0.35843771, 0.35497693, 0.35266974]), 'split9_test_score': array([0.34772577, 0.35794331, 0.36420567, 0.3600857 , 0.35810811]), 'mean_test_score': array([0.34656073, 0.35976077, 0.35941473, 0.35516294, 0.35099366]), 'std_test_score': array([0.0072188 , 0.00448305, 0.00524071, 0.00416735, 0.00451348]), 'rank_test_score': array([5, 1, 2, 3, 4])}

我们看到有很多错的，因为我们用的数据也是比较少的，我们取了8万多条数据，数据量也不是特别够，最后准确率才30%多。但是这个过程是没有问题的。自己做的时候可以多加一些数据处理，特征工程也可以发挥自己创意 的处理。这里就不拓展了，知道流程就行。

我们可以发现花费时间最多的地方是数据处理，其他的都是别的案例复制过来的

date = pd.to_datetime(value)

• date.year
• date.month
• date.weekday 1星期二; 0是星期一

pandas.to_datetime(arg, errors=‘raise’, dayfirst=False, yearfirst=False, utc=None, format=None, exact=True, unit=None, infer_datetime_format=False, origin=‘unix’, cache=True

• errors：参数raise时，表示传入数据格式不符合是会报错；ignore时，表示忽略报错返回原数据；coerce用NaT时间空值代替。
• dayfirst:表示传入数据的前两位数为天。如‘030820’——>2020-03-08.
• yearfirst:表示传入数据的前两位数为年份。如‘030820’——>2003-08-20.
• format：自定义输出格式，如“%Y-%m-%d”.
• unit：可以为[‘D’, ‘h’ ,‘m’, ‘ms’ ,‘s’, ‘ns’]
  • s 精确到秒
  • ns 精确到纳秒
• infer_datetime_format:加速计算
• origin：自定义开始时间，默认为1990-01-01

DataFrame.query()

DataFrame.groupby(key, as_index=False)

3.4 朴素贝叶斯算法

• 朴素：假设特征与特征之间是相互独立。
• 贝叶斯：贝叶斯公式。
  • 注意：当我们的样本量不够导致计算某一些概率的时候出现了0的情况，我们怎么去解决？我们引入了 拉普拉斯平滑系数 ，这样就解决了。

3.4.1 什么是朴素贝叶斯分类方法

3.4.2 概率基础

概率(Probability)定义

• 概率定义为一件事情发生的可能性
  • 扔出一个硬币，结果头像朝上
  • 某天是晴天
• P(X) : 取值在[0, 1]
  • 取值为0就是不可能事件
  • 取值为1就是必然事件

女神是否喜欢计算案例

在讲这两个概率之前我们通过一个例子，来计算一些结果：

训练集:

测试集: 小明 产品 超重 ？
已知小明是产品经理，体重超重， 是否会被女神喜欢         二分类问题

• 问题如下:
  1、女神喜欢的概率?        P(喜欢) = 4/7
  2、职业是程序员并且体型匀称的概率?        P(程序员,匀称) = 1/7 联合概率
  3、在女神喜欢的条件下，职业是程序员的概率?        P(程序员 | 喜欢) = 2/4 = 1/2 条件概率
  4、在女神喜欢的条件下，职业是程序员，体重是超重的概率?        P(程序员,超重 | 喜欢) = 1/4 既符合联合概率，又符合条件概率

思考题: 在小明是产品经理并且体重超重的情况下，如何计算小明被女神喜欢的概率?
即P(喜欢|产品,超重)= ?

条件概率与联合概率

• 联合概率：包含多个条件，且所有条件同时成立的概率
  • 记作：P(A,B)
  • 例如： P(程序员,匀称) 、P(程序员,超重 | 喜欢)
  • 特性：P(A, B) = P(A)P(B)
• 条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
  • 记作：P(A|B)
  • 例如： P(程序员 | 喜欢) 、P(程序员,超重 | 喜欢)
  • 特性：P(A1,A2|B) = P(A1|B)P(A2|B)
• 相互独立：如果P(A, B) = P(A)P(B)，则称事件A与事件B相互独立。(充要条件)

3.4.3 贝叶斯公式

公式

计算案例

那么思考题就可以套用贝叶斯公式这样来解决

P(喜欢|产品，超重)= P(产品，超重|喜欢)P(喜欢)/P(产品，超重)

显然分母不能等于0。


上式中，P(产品，超重|喜欢)和P(产品, 超重)的结果均为0，导致无法计算结果。这是因为我们的样本量太少了，不具有代表性，本来现实生活中，肯定是存在职业是产品经理并且体重超重的人的，P(产品, 超重)不可能为0; 而且事件“职业是产品经理”和事件“体重超重”通常被认为是相互独立的事件，但是，根据我们有限的7个样本计算"P(产品, 超重)=P(产品)P(超重)"不成立。

朴素贝叶斯，简单理解，就是假定了特征与特征之间相互独立的贝叶斯公式。

也就是说，朴素贝叶斯，之所以朴素，就在于假定了特征与特征相互独立。

朴素：
        假设: 特征与特征之间是相互独立。

所以，思考题如果按照朴素贝叶斯的思路来解决，就可以是

p(产品, 超重) =  P(产品)P(超重) =2/7 * (3/7) = 6/49 
P(产品, 超重|喜欢) = P(产品|喜欢)P(超重|喜欢)=1/2 *  1/4 = 1/8
P(喜欢|产品, 超重) = P(产品, 超重|喜欢)P(喜欢)/P(产品, 超重)= 1/8 * 4/7 /  6/49 = 7/12 

7/12这个结果显然也是不符合实际的，为什么会出现这么大的结果？
1. 样本量太少；
2. 是因为有这样一个假设（特征与特征之间是相互独立），产品经理和超重 根据我们的数据这两个之间也不是相互独立的，但是我们又假定了他们特征和特征之间是相互独立的，所以这个结果不是特别的准。


我们实际在用朴素贝叶斯算法的时候，我们接触的数据量是比较大的，所以那样就会稍微准一点。

朴素贝叶斯算法: 朴素 + 贝叶斯

朴素： 假设 特征与特征之间是相互独立。
贝叶斯 ：贝叶斯公式

应用场景: 文本分类
为什么文本分类当中会比较常用？因为文章给它转换成能够被机器学习算法处理的数据，我们以单词作为特征，一般我们把一些词作为特征，有一个假设 就是词与词之间 相互独立的，所以我们也会经常把文本分类 用 朴素贝叶斯 去做。

那么这个公式如果应用在文章分类的场景当中，我们可以这样看：

公式分为三个部分：

• P( C )：每个文档类别的概率(某文档类别数／总文档数量)
• P(W│C)：给定类别下特征（被预测文档中出现的词）的概率
  • 计算方法：P(F1│C)=Ni/N （训练文档中去计算）
    • Ni为该F1词在C类别所有文档中出现的次数
    • N为所属类别C下的文档所有词出现的次数和
• P(F1,F2,…) 预测文档中每个词的概率

P(科技|文章1)
P(娱乐|文章1)

这个了类似一个条件概率，那么仔细一想，给定文章其实相当于给定什么？结合前面我们将文本特征抽取的时候讲的？所以我们可以理解为

P(科技|文章1)=P(科技|词1, 词2,词3,词4.....)
P(娱乐|文章1)=P(娱乐|词1, 词2,词3,词4.....)

但是这个公式怎么求？前面并没有参考例子，其实是相似的，我们可以使用贝叶斯公式去计算

如果计算两个类别概率比较：

所以我们只要比较前面的大小就可以，得出谁的概率大

文章分类计算

计算结果

P(C | Chinese，Chinese，Chinese，Tokyo，Japan) = P(Chinese，Chinese, Chinese，Tokyo，Japan | C) * P( C ) / P( Chinese，Chinese，Chinese，Tokyo，Japan)

P( 非C | Chinese，Chinese，Chinese，Tokyo，Japan) = P(Chinese，Chinese, Chinese，Tokyo，Japan | 非C) * P( 非C ) / P( Chinese，Chinese，Chinese，Tokyo，Japan)

P( C ) = 3/4

这时候我们前提已经是用的朴素贝叶斯算法了，那么这些特征与特征之间我们已经假定是相互独立的。

P(Chinese，Chinese, Chinese，Tokyo，Japan | C) = P(Chinese | C)^3 *  P(Tokyo | C) *  P(Japan | C)

P(Chinese | C)=5/8
P(Tokyo | C)=0/8 =0
P(Japan | C)=0/8 =0

思考:我们计算出来某个概率为0，合适吗？

概率=0那么肯定就不行啦，代入进去P(C | Chinese，Chinese，Chinese，Tokyo，Japan) = 0 ，岂不是P( 非C | Chinese，Chinese，Chinese，Tokyo，Japan)=100% 。

只能说是 可能 P(C | Chinese，Chinese，Chinese，Tokyo，Japan) 最少也只是0，但是不可能，因为我们根据常识来判断，在这篇文档当中，有三个词都是Chinese，所以这篇文章属于China概率是不可能为0的。

所以当我们概率在算P(Tokyo l C)=0 是不符合实际的，会让我们结果不准，那怎么办呢？

我们之所以在计算的过程中出现0，根本原因是 样本量 太少了，没有出现这个词，就导致我们在计算概率的时候使它为0了。那么怎么避免这种情况出现呢？

在这里我们需要引入一个叫做拉普拉斯平滑系数的东西。

拉普拉斯平滑系数

目的：防止计算出的分类概率为0

m=6
P(ChineselC) = (5+1) / (8+1*6) = 6/14 = 3/7
P(Tokyo|C) = (0+1) / (8+1*6) = 1/14
P(Japan|C) = (0+1) / (8+1*6) = 1/14
P(Chinese，Chinese, Chinese，Tokyo，Japan | C) = P(Chinese | C)^3 *  P(Tokyo | C) *  P(Japan | C)	= (3/7)^3  * 1/14 * 1/14

API

• sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
  • 朴素贝叶斯分类
  • alpha：拉普拉斯平滑系数

3.4.4 案例：20类新闻分类

数据集可以用sklearn里自带的数据集，只不过是因为数据量比较大一点。用datasets.fetch_*()方法

分析

• 分割数据集
• tfidf进行的特征抽取
  • 将文章字符串进行单词抽取
• 朴素贝叶斯预测

1）获取数据
	因为我们是获取sklean里的数据，所以我们不用做数据处理
2）划分数据集
3）特征工程
	文本特征抽取
4）朴素贝叶斯预估器流程
5）模型评估

代码

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


def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    #  1）获取数据
    news = fetch_20newsgroups(subset="all")  # subset= "train" 默认是获取训练集; "all"就是都要
    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    # 3）特征工程
    #     文本特征抽取 --  tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4）朴素贝叶斯预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train,y_train)
    # 5）模型评估
    # 方法一: 直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和预测值:\n", y_test == y_predict)
    # 方法二: 计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)

    return None


if __name__ == "__main__":
    nb_news()

运行结果

y_predict:
 [ 0  3  7 ... 16 11  5]
直接比对真实值和预测值:
 [ True False  True ...  True  True  True]
准确率为:
 0.8391341256366723

报错：sklearn.datasets.fetch_20newsgroups下载报错问题urllib.error.HTTPError: HTTP Error 403: Forbidden

sklearn.datasets.fetch_20newsgroups离线下载导入

fetch_20newsgroups(20类新闻文本)数据集的安装
手动下载地址：https://people.csail.mit.edu/jrennie/20Newsgroups/20news-bydate.tar.gz

文件（20news-bydate.tar.gz、20news-bydate_py3.pkz ）我放网盘里了 链接：https://pan.baidu.com/s/1XFWGZJopEeZGw3gIbGQeTg?pwd=1024
提取码：1024

下载之后得到一个文件，文件名是 20news-bydate.tar.gz

有文件了, Python 怎么读取？
fetch_20newsgroups函数将下载的文件放在C:\Users\你的用户名\scikit_learn_data\20news_home目录下
将你下载的文件放在这里 (没有的话创建一个)

Python下载的文件叫20news-bydate.tar.gz，你下载的名字是其他的，比如叫20newsbydate.tar.gz。改成它那样的就成(不过自己应该先看下, 你那个版本的Python下载的文件名字是啥)

复制你压缩包放的位置：C:\Users\eliauk\scikit_learn_data\20news_home\20news-bydate.tar.gz

进入Python安装文件夹中找到文件 _twenty_newsgroups.py
我的在C:\Users\eliauk\AppData\Local\Programs\Python\Python311\Lib\site-packages\sklearn\datasets

用任意文本编辑器打开它，找到 download_20newsgroups 函数

红色框是下载文件的部分, 绿色框是解压文件的部分
所以, 我们只需要将红色框注释掉, 并加入文件地址即可
然后, Ctrl + S 保存

    """
    logger.info("Downloading dataset from %s (14 MB)", ARCHIVE.url)
    archive_path = _fetch_remote(ARCHIVE, dirname=target_dir)
    """
    archive_path = r'C:\Users\eliauk\scikit_learn_data\20news_home\20news-bydate.tar.gz'

有可能再报一个缩进的错: 看下哪行的4个空格变成一个Tab了, 改过来即可(我的是archive_path前面tab换成4个空格)

运行我们的代码

成功：

如果还是不行就卸载sklearn重装，再做一次上面修改_twenty_newsgroups.py文件这步，我就是这么解决的。

3.4.5 总结

• 优点：

  • 朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
  • 对缺失数据不太敏感，算法也比较简单，常用于文本分类。
  • 分类准确度高，速度快

• 缺点：

  • 由于使用了样本属性独立性的假设，所以如果特征属性有关联时，其效果不好
  • 我们在用朴素贝叶斯算法的时候，它是会计算一些概率值，如果本身样本给的就不是特别好的话，那么概率值算的也不是特别准，也会让最终的效果不是特别好。

• 应用场景：文本分类

3.5 决策树

找到最高效的决策顺序-比如说信息增益

1、认识决策树

决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-then结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法

怎么理解这句话？通过一个对话例子

想一想这个女生为什么把年龄放在最上面判断！！！！！！！！！

决策树的思想：如何高效的进行决策
高效意味着，要决定一下特征的先后顺序。

那怎么才能知道哪个特征应该先看，哪个特征应该后看，而且这样比较高效呢？这就是我们决策树算法需要解决的问题。

2、决策树分类原理详解

为了更好理解决策树具体怎么分类的，我们通过一个问题例子？

已知 四个特征值 预测 是否贷款给某个人

类别指 是否贷款 给这个人。

问题：如何对这些客户进行分类预测？你是如何去划分？
有可能你的划分是这样的

那么我们怎么知道这些特征哪个更好放在最上面，那么决策树的真是划分是这样的

我们发现，凡是有房子的，最终都拿到贷款了。
如果新来的这个人，他是有房子的，那么我就能很快的做出决策，应该贷款给这个人。
如果这个人没有自己的房子，那应该采取怎样的措施呢？
就需要看训练集了，我们看到，没有自己房子的，就不一定给你贷款。
所以光看房子还不够，还得看你别的，比如是否有工作，如果有自己的工作，那么就应该贷款给这个人了。刚好这个人没有工作，就不贷款给这个人了。

1. 先看房子，再工作 -> 是否贷款         只看了两个特征
2. 年龄，信贷情况，工作         看了三个特征
很明显第二种方式就不高效，不如第一种高效

我们希望找到一种数学的方法，能够快速的自动的进行判断先看哪个特征 后看哪个特征，才能像第一种方式一样，很快速的知道结论 。

2.1 原理

• 信息熵、信息增益等

需要用到信息论的知识！！！问题：通过例子引入信息熵

• 1）信息
  • 香农 定义的：消除随机不定性的东西 就是 信息
  • 举个例子：有一个人她叫小依，小依她的年龄目前对我来说是未知的，现在我想知道小依今年多大了，我就问小依今年多少岁。
    小依回答说：“我今年18岁” 。
    如果说我一开始不知道小依的年龄 ，但是当小依告诉我 她今年18岁 ，这一瞬间，我就相当于 “我今年18岁”这句话就消除了我对于小依 年龄 的 不确定性。那么我们就认为这句话（ “我今年18岁”）就是一个信息。
  • 再举一个例子：现在我已经知道小依的年龄是18岁，那么当我和小依的这段对话进行完毕之后，小依的小微听到我们这段对话也抢着去说 ”小依明年19岁” ，这句话算信息吗？这句话不算信息。因为一开始，小依在说这句话（“我今年18岁”）之前，小依的年龄对于我来讲是不确定性的东西。当小依已经告诉我“我今年18岁” ，那么也就意味着这句话消除了我对于小依 年龄 的 不确定性，现在我已经知道小依的年龄是18岁，这时候小依的年龄对我来讲已经不是 不确定的东西了，所以小微说的这句话（”小依明年19岁”）他什么都没有消除，我已经知道她今年18岁了，我肯定也能推断出她明年是19岁，我还需要你告诉我吗？所以小微说的这句话基本上是废话（或者说是一个简单的推论），所以这句话（”小依明年19岁”）不是信息.

那么我们要如何去衡量我消除的这个不确定性的程度大小呢 ?
其实就是我们要去用量化，量化这个信息量，信息的大小其实就是我们 在消除不定性的 不确定性的程度大小是多少。

• 2）信息的衡量 - 信息量 - 信息熵
  bit 比特
  g(D,A) = H(D) - 条件熵H(D|A)

2.2 信息熵的定义

• H的专业术语称之为信息熵，单位为比特。
  
  b随便你定，但是整个计算信息熵的过程当中，这个底数必须保持一致，一般在进行信息熵的计算，一般取2为底。

回到我们前面的贷款案例，去算一下信息熵

首先明确我们的任务：来了一个新的人，想要知道是否应该贷款给这个人，已知他的年龄、工作、房子、信贷情况，想要知道是否贷款给这个人。

现在其实我们转换成信息论里的语言的话，这个问题其实可以转换成 消除是否给这个人贷款的不确定性，现在我们在不知道这个人任何特征的情况下，应不应该贷款给这个人，是不是一个不确定性的东西呀？现在我就用信息熵来衡量这种不确定性的大小是有多少，就用到了信息熵的公式。

可以求总的信息熵 H(总) = -(6/15 * log 6/15 + 9/15*log9/15)=0.971 ，底数常用2。

现在我们知道他的总的不确定性是多少了，接下来我们怎么去确定我知道某一个特征之后，他这个不确定性减少的最多，是不是我们应该先看哪个特征？比如说我们一开始不知道这个人任何特征，有一个总不确定性是这么多0.971，当我们知道了其中一个年龄特征， 他是一个青年人，这种不确定性会减少。如果我们能够求出 知道某一个特征之后这个不确定性减少的程度，然后再比较哪一个 知道哪一个特征之后 这个不确定性减少的程度是最多的，我们是不是就可以先看它，这其实就是决策树来解决问题的一个思路。

接下来我们就需要求另一个不确定性，当知道某个特征之后，它的信息熵是多少，这样我们就引入了一个信息论里面另一个概念，叫做信息增益。

2.3 决策树的划分依据之一------信息增益

知道某一个特征之后这个不确定性减少的程度

定义与公式

特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差，即公式为：
信息增益 = 信息熵 - 条件熵

公式的详细解释：

注：信息增益表示得知特征X的信息而息的不确定性减少的程度使得类Y的信息熵减少的程度

贷款特征重要计算

• 我们以年龄特征来计算：

  1、g(D, 年龄) = H(D) -H(D|年龄) = 0.971-[5/15H(青年)+5/15H(中年)+5/15H(老年]
  2、H(D) = -(6/15log(6/15)+9/15log(9/15))=0.971
  3、H(青年) = -(3/5log(3/5) +2/5log(2/5))    青年拿到贷款有2个
     H(中年)=-(3/5log(3/5) +2/5log(2/5))
     H(老年)=-(4/5og(4/5)+1/5log(1/5))