python 机器学习（一）机器学习概述与特征工程

 

 

一、机器学习概述

1.1、什么是机器学习？

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

1.2、为什么需要机器学习？

• 解放生产力，智能客服，可以不知疲倦的24小时作业
• 解决专业问题，ET医疗，帮助看病
• 提供社会便利，例如杭州的城市大脑

1.3、机器学习应用场景

• 自然语言处理
• 无人驾驶
• 计算机视觉
• 推荐系统

二、数据来源与类型

2.1、数据的来源

• 企业日益积累的大量数据（互联网公司更为显著）
• 政府掌握的各种数据
• 科研机构的实验数据

2.2、数据的类型

数据的类型将是机器学习模型不同问题不同处理的依据。数据的类型包括：

离散型数据：由记录不同类别个体的数目所得到的数据，又称计数数据，所有这些数据全部都是整数，而且不能再细分，也不能进一步提高他们的精确度。

连续型数据：变量可以在某个范围内取任一数，即变量的取值可以是连续的，如，长度、时间、质量值等，这类整数通常是非整数，含有小数部分。

注意：

• 只要记住一点，离散型是区间内不可分，连续型是区间内可分

2.3、可用的数据集

scikit-learn：数据量较小 ，方便学习。
UCI：收录了360个数据集，覆盖科学、生活、经济等领域 ，数据量几十万。
Kaggle：大数据竞赛平台，80万科学家，真实数据，数据量巨大。

常用数据集数据的结构组成：特征值+目标值，如下图：

 

 

常用数据集结构

三、数据的特征工程

3.1、特征工程是什么？

特征工程是将原始数据转换为更好地代表预测模型的潜在问题的特征的过程，从而提高了对未知数据的模型准确性。

3.2、特征工程的意义

意义：直接影响模型的预测结果。

3.3、scikit-learn

• Python语言的机器学习工具
• Scikit-learn包括许多知名的机器学习算法的实现
• Scikit-learn文档完善，容易上手，丰富的API，使其在学术界颇受欢迎。
• 目前稳定版本0.18
• 安装：pip3 install Scikit-learn
• 引用：import sklearn

3.4、数据的特征抽取

3.4.1、特点：

• 特征抽取针对非连续型数据
• 特征抽取对文本等进行特征值化

3.4.2、sklearn特征抽取API :

sklearn.feature_extraction

3.4.3、字典特征抽取 :

作用：对字典数据进行特征值化
类：sklearn.feature_extraction.DictVectorizer
DictVectorizer语法:

DictVectorizer(sparse=True,…)

DictVectorizer.fit_transform(X)       
    X:字典或者包含字典的迭代器
    返回值：返回sparse矩阵

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

DictVectorizer.get_feature_names()
    返回类别名称

DictVectorizer.transform(X)
    按照原先的标准转换

流程：
1、实例化类DictVectorizer
2、调用fit_transform方法输入数据并转换

举一个栗子：

from sklearn.feature_extraction import DictVectorizer
dict = DictVectorizer(sparse=False)
data = dict.fit_transform([{'name': '张飞','score': 70}, {'name': '赵云','score':100}, {'name': '刘备','score': 98}])
print(dict.get_feature_names())
print(data)

运行结果：

['name=刘备', 'name=张飞', 'name=赵云', 'score']
[[  0.   1.   0.  70.]
 [  0.   0.   1. 100.]
 [  1.   0.   0.  98.]]

从中，我们可以看出：对于字典 [{'name': '张飞','score': 70}, {'name': '赵云','score':100}, {'name': '刘备','score': 98}] ，DictVectorizer类将汉字（张飞，赵云，刘备）转成了one-hot编码（0,1,0），而数值类型的数据（70,100,98）是不做处理的。

什么是one-hot编码？
One-Hot编码，又称为一位有效编码，主要是采用N位状态寄存器来对N个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候只有一位有效。

3.4.4、文本特征抽取

作用：对文本数据进行特征值化
类：sklearn.feature_extraction.text.CountVectorizer
CountVectorizer语法：

CountVectorizer(max_df=1.0,min_df=1,…)
    返回词频矩阵

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

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

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

流程:
1、实例化类CountVectorizer
2、调用fit_transform方法输入数据并转换

举一个栗子：

from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
data = cv.fit_transform(["我爱学习，学习使我进步", "我爱work，work 使我快乐"])
print(cv.get_feature_names())
print(data.toarray())

运行结果：

['work', '使我快乐', '学习使我进步', '我爱work', '我爱学习']
[[0 0 1 0 1]
 [1 1 0 1 0]]

可以看到，API中的CountVectorizer类将中文转换成了单个词语，并给每个词语的出现个数进行了统计。有一点要注意的是，程序并不会给中文分词，所以，例子中，‘学习使我进步’程序认为是一个词语，这种情况下，可以用空格，或者逗号，将中文进行分割。还有一点要注意的是，如果是英文的话，是不会统计单个字母的，因为字母的统计是没有意义的，同理，CountVectorizer也不支持单个中文字。

我们可以验证一下栗子：
英文栗子：

from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
data = cv.fit_transform(["I like study , study makes me happy", "I am a good student"])
print(cv.get_feature_names())
print(data.toarray())

运行结果：

['am', 'good', 'happy', 'like', 'makes', 'me', 'student', 'study']
[[0 0 1 1 1 1 0 2]
 [1 1 0 0 0 0 1 0]]

中文栗子：

from sklearn.feature_extraction.text import CountVectorizer
cv = CountVectorizer()
data = cv.fit_transform(["我 热爱 学习， 学习 使我 进步", "我 是 一个 好学生"])
print(cv.get_feature_names())
print(data.toarray())

运行结果：

['一个', '使我', '好学生', '学习', '热爱', '进步']
[[0 1 0 2 1 1]
 [1 0 1 0 0 0]]

从中文栗子和英文栗子中，我们可以看到单个英文和单个中文是不会统计数量的，因为统计单个中文或者英文是没有意义的。

手动加空格，或者加逗号分隔始终是指标不治本，如果给我们一篇文章，让我们去处理的话，那要累到手瘫了。那么，有没有好的办法呢？是有的，那就是用 python 里提供的 jieba 分词类库。
我们再来举一个栗子：

import jieba
from sklearn.feature_extraction.text import CountVectorizer

con1 = jieba.cut("我热爱学习，学习使我感到进步。")
con2 = jieba.cut("我热爱工作，工作可以让我感到快乐。")
con3 = jieba.cut("如果不让我学习，也不让我工作，我会觉得浑身不舒服。")

# 转换成列表
content1 = list(con1)
content2 = list(con2)
content3 = list(con3)

# 把列表转换成字符串
c1 = ' '.join(content1)
c2 = ' '.join(content2)
c3 = ' '.join(content3)

print(c1, c2, c3)
cv = CountVectorizer()
data = cv.fit_transform([c1, c2, c3])
print(cv.get_feature_names())
print(data.toarray())

运行结果：

我 热爱 学习 ， 学习 使 我 感到 进步 。 我 热爱工作 ， 工作 可以 让 我 感到 快乐 。 如果 不让 我 学习 ， 也 不让 我 工作 ， 我会 觉得 浑身 不 舒服 。
['不让', '可以', '如果', '学习', '工作', '快乐', '感到', '我会', '浑身', '热爱', '热爱工作', '舒服', '觉得', '进步']
[[0 0 0 2 0 0 1 0 0 1 0 0 0 1]
 [0 1 0 0 1 1 1 0 0 0 1 0 0 0]
 [2 0 1 1 1 0 0 1 1 0 0 1 1 0]]

从栗子中可以看到，jieba分词包把句子进行了分词，然后对每个词语的个数进行了统计，但是对于 ‘我’、 ‘也’ 这样的单个中文，并没有统计个数，因为这样的单个中文统计没有意义。

至此，我们学会了统计文章中英文和中文的词语的个数，那么，单纯统计一个词语出现的个数越多就表示这个词语在文章中越重要吗？那比如，“我们”，“你们”，“他们”，“你的”，这样的指示代词出现的频率应该是最高的，能说明代词是文章的重点吗？显然不是。怎么过滤掉这种出现很多，但是并不是重点的词语呢？我们就要开始学习一种 TF-IDF 的处理方法了。

3.4.5、TF-IDF

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

TfidfVectorizer(stop_words=None,…)
    返回词的权重矩阵

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

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

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

我们开始举个栗子：

import jieba
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer

con1 = jieba.cut("我们热爱学习，学习使我们感到进步。")
con2 = jieba.cut("我们热爱工作，工作可以让我们感到快乐。")
con3 = jieba.cut("如果不让我们学习，不让我们工作，就会感到浑身不舒服。")

# 转换成列表
content1 = list(con1)
content2 = list(con2)
content3 = list(con3)

# 把列表转换成字符串
c1 = ' '.join(content1)
c2 = ' '.join(content2)
c3 = ' '.join(content3)

print(c1, c2, c3)
tf = TfidfVectorizer()
data = tf.fit_transform([c1, c2, c3])
print(tf.get_feature_names())
print(data.toarray())

运行结果：

我们 热爱 学习 ， 学习 使 我们 感到 进步 。 我们 热爱工作 ， 工作 可以 让 我们 感到 快乐 。 如果 不让 我们 学习 ， 不让 我们 工作 ， 就 会 感到 浑身 不 舒服 。
['不让', '可以', '如果', '学习', '工作', '快乐', '感到', '我们', '浑身', '热爱', '热爱工作', '舒服', '进步']
[[0.         0.         0.         0.61800047 0.         0.
  0.23996625 0.4799325  0.         0.40629818 0.         0.
  0.40629818]
 [0.         0.43345167 0.         0.         0.32965117 0.43345167
  0.25600354 0.51200708 0.         0.         0.43345167 0.
  0.        ]
 [0.63561168 0.         0.31780584 0.24169953 0.24169953 0.
  0.18770125 0.3754025  0.31780584 0.         0.         0.31780584
  0.        ]]

我们可以看到，通过 TF-IDF 的处理，把每句话的重点单词找出来了，第一句话 “我们” 和 “学习” 都出现了2次 ，但 “学习”是0.61800047，“我们” 是0.4799325， 重点是 “学习” ， 第三句话“我们” 和 “ 不让 ” 都出现了2次 ，但 “不让”是0.63561168 ，“我们” 是0.3754025 ， 第三句话重点强调 “不让” ，因为 “我们” 在三句话中都频繁出现，并不是每一句话的 “专属” ， 也就不是一句话的重点了。

3.5、数据的特征处理

3.5.1、特征处理是什么？

通过特定的统计方法（数学方法）将数据转换成算法要求的数据。

3.5.2、为什么需要特征处理？

每个特征的单位不一样，比如相亲的时候，有乘坐飞机的里程数，人的身高，玩游戏的时间，里程数的数值很大，身高相对里程数值很小，那么在做分析的时候，里程数的数值就会起决定性作用。事实在，在统计分析的时候，分析人员认为每个特征同样重要。所以我们需要把不同单位的数值进行特征处理，不因为数值的相差巨大而造成特征的差别。

3.5.3、特征处理的方法

数值型数据：（标准缩放）
1、归一化
2、标准化
3、缺失值
类别型数据：one-hot编码
时间类型：时间的切分

3.5.4、归一化：

特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间。
公式：   𝑋′= (𝑥−𝑚𝑖𝑛)/(𝑚𝑎𝑥−𝑚𝑖𝑛)      𝑋′′=𝑋′∗(𝑚𝑥−𝑚𝑖)+𝑚𝑖
其中：作用于每一列，max为一列的最大值，min为一列的最小值，那么X’’为最终结果，mx，mi分别为指定区间值默认mx为1,mi为0。

 

归一化计算过程

 

 

归一化计算过程

 

sklearn归一化API : sklearn.preprocessing.MinMaxScaler
MinMaxScaler语法：

MinMaxScalar(feature_range=(0,1)…)
    每个特征缩放到给定范围(默认[0,1])

MinMaxScalar.fit_transform(X)       
    X:numpy array格式的数据[n_samples,n_features]
    返回值：转换后的形状相同的array

归一化步骤：
1、实例化MinMaxScalar
2、通过fit_transform转换

举一个栗子

from sklearn.preprocessing import MinMaxScaler
mm = MinMaxScaler(feature_range=(0, 1))
data = mm.fit_transform([[90,2,10,40],[60,4,15,45],[75,3,15,46]])
print(data)

运行结果：

[[1.         0.         0.         0.        ]
 [0.         1.         1.         0.83333333]
 [0.5        0.5        1.         1.        ]]

我们可以看到，之前的数据，特征一（ 90,60,75） 是比特征二（2,4,3）在数值上大很多的，那么，如果不做特征处理，直接带入模型处理的话，特征一显然就占决定性作用了，就没有特征二什么事情了。而进行归一化转换之后，特征一和特征二在数值上就在同一量级了，他们就变得“同等重要”了。

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

对于归一化来说：如果出现异常点，影响了最大值和最小值，那么结果显然会发生改变。那么，我们有没有好的解决办法呢？有的，那就是标准化。

3.5.5、标准化

特点：通过对原始数据进行变换把数据变换到均值为0,方差为1范围内
公式 ：𝑋′= (𝑥−mean)/𝜎
其中，mean为平均值，𝜎为标准差(考量数据的稳定性)

 

标准差

 

对于标准化来说：如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小。

sklearn特征处理API : scikit-learn.preprocessing.StandardScaler

StandardScaler(…)
    处理之后每列来说所有数据都聚集在均值0附近方差为1

StandardScaler.fit_transform(X,y)       
    X:numpy array格式的数据[n_samples,n_features]
    返回值：转换后的形状相同的array

StandardScaler.mean_
    原始数据中每列特征的平均值

StandardScaler.std_
    原始数据每列特征的方差

标准化步骤：
1、实例化StandardScaler
2、通过fit_transform转换

举个栗子：

from sklearn.preprocessing import StandardScaler
std = StandardScaler()
data = std.fit_transform([[ 1., -1., 3.],[ 2., 4., 2.],[ 4., 6., -1.]])
print(data)

运行结果：

[[-1.06904497 -1.35873244  0.98058068]
 [-0.26726124  0.33968311  0.39223227]
 [ 1.33630621  1.01904933 -1.37281295]]

标准化总结：标准化可以避免最大值，最小值发生异常值的干扰。在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

缺失值处理方法
删除：如果每列或者行数据缺失值达到一定的比例，建议放弃整行或者整列。

插补：可以通过缺失值每行或者每列的平均值、中位数来填充。（主要方法）

sklearn缺失值API: sklearn.preprocessing.Imputer
Imputer语法：

Imputer(missing_values='NaN', strategy='mean', axis=0)
    完成缺失值插补

Imputer.fit_transform(X,y)       
    X:numpy array格式的数据[n_samples,n_features]
    返回值：转换后的形状相同的array

Imputer流程：
1、初始化Imputer,指定”缺失值”，指定填补策略，指定行或列
2、调用fit_transform

关于np.nan(np.NaN)
1、 numpy的数组中可以使用np.nan/np.NaN来代替缺失值，属于float类型。
2、如果是文件中的一些缺失值，可以替换成nan，通过np.array转化成float型的数组即可。

3.6、数据的特征选择

3.6.1、特征选择是什么？

特征选择就是单纯地从提取到的所有特征中选择部分特征作为训练集特征，特征在选择前和选择后可以改变值、也不改变值，但是选择后的特征维数肯定比选择前小，毕竟我们只选择了其中的一部分特征。

3.6.2、为什么要做特征选择？

冗余：部分特征的相关度高，容易消耗计算性能
噪声：部分特征对预测结果有负影响

3.6.3、特征选择主要方法：

Filter(过滤式):VarianceThreshold
Embedded(嵌入式)：正则化、决策树

3.6.4、sklearn特征选择API

sklearn.feature_selection.VarianceThreshold
VarianceThreshold语法：

VarianceThreshold(threshold = 0.0)
    删除所有低方差特征

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

3.6.5、VarianceThreshold流程：

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

3.6.6、举个栗子：

from sklearn.feature_selection import VarianceThreshold
var = VarianceThreshold(threshold=1.0)
data = var.fit_transform([[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]])
print(data)

运行结果：

[[0]
 [4]
 [1]]

从栗子中，可以看到，把方差是0的第一个特征值（0,0,0），第4个特征值（3,3,3），和方差小于1的第2个特征值（2,1,2）都给删除了，只剩下（0,4,1）这个方差大于1的特征值。默认情况下，threshold 等于1.0 。

3.7、降维 （PCA）

3.7.1、sklearn降维API ：

sklearn. decomposition

3.7.2、本质：

PCA是一种分析、简化数据集的技术。

3.7.3、目的：

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

3.7.4、作用：

可以削减回归分析或者聚类分析中特征的数量。

3.7.5、PCA语法：

PCA(n_components=None)
    将数据分解为较低维数空间

PCA.fit_transform(X)       
    X:numpy array格式的数据[n_samples,n_features]
    返回值：转换后指定维度的array

3.7.6、PCA流程：

1、初始化PCA,指定减少后的维度
2、调用fit_transform

3.7.7、举个栗子

from sklearn.decomposition import PCA
pca = PCA(n_components=0.9)
data = pca.fit_transform([[90,2,10,40],[60,4,15,45],[75,3,15,46]])
print(data)

运行结果：

[[ 15.77507261]
 [-15.11129418]
 [ -0.66377843]]

该栗子中，原本有4个特征的数据，变成了一个特征，并且该特征保留了原来90%的信息，n_components=0.9 。

四、机器学习基础

4.1、机器学习开发流程

 

机器学习开发流程

 

首先要根据原始数据明确问题做什么，建立模型： 根据数据类型划分应用种类；然后做数据的基本处理：（缺失值，合并表等）和特征工程（特征进行处理） （重要）；其次，找到合适的算法进行预测： 最后，对模型评估，根据模型的准确率，判定效果，如果合格 ，则上线使用，以API形式提供，如果不合格，则要换算法 或者重新提取特征工程，如此循环往复继续下去，直到得到满意的模型。

4.2、机器学习模型是什么？

定义：通过一种映射关系将输入值到输出值。
简单来讲，模型 = 算法 + 数据。

 

模型

 

4.3、机器学习算法分类

 

算法分类