机器学习算法基础1-数据的特征工程

一、机器学习概述

1.什么是机器学习

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

2.为什么需要机器学习？

1、解放生产力–智能客服
2.解决专业问题–ET医疗
3.提供社会便利–城市大脑
4.机器学习在各领域带来的价值—医疗、航空、教育、物流、电商
让机器学习程序代替手动步骤，减少企业的成本代替企业的效率

3.机器学习的应用场景

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

二、数据集的组成

1.历史数据是什么格式

机器学习的数据：文件CSV
读取工具是pandas
pandas：一个数据读取非常方便以及基本处理数据格式的工具。如缺失值处理、数据转换
numpy：释放了GIL，真正的多线程

不采用mysql的原因
1.性能瓶颈。读取速度慢
2.格式不符合机器学习要求的数据格式

2.可用数据集

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

3.常用数据集数据的结构组成

特征值+目标值

三、数据的特征工程

1.特征工程是什么

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

2.特征工程的意义

直接影响预测结果

3.scikit-learn库介绍

•Python语言的机器学习工具
•Scikit-learn包括许多知名的机器学习算法的实现
•Scikit-learn文档完善，容易上手，丰富的API，使其在学术界颇受欢迎。

4.数据的特征抽取

•特征抽取针对非连续型数据
•特征抽取对文本等进行特征值化，特征值化是为了让计算机更好的理解数

sklearn特征抽取API：sklearn.feature_extraction

1）字典特征抽取—类别数据

作用：对字典数据进行特征值化
类：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)
# 按照原先的标准转换

# 字典特征数据抽取
# 导入包
from sklearn.feature_extraction import DictVectorizer

def dictvec():
    '''字典特征抽取'''
    # 实例化,参数默认为sparse=True，此时返回sparse矩阵;参数为sparse=False，返回ndarray数组
    dict = DictVectorizer(sparse=False)
    # 调用fict_transfrom方法输入数据并转换
    data = dict.fit_transform([{'city': '北京','temperature':100},
                                {'city': '上海','temperature':60},
                                {'city': '深圳','temperature':30}])
    # 调用get_feature_names()方法返回类别名称
    print(dict.get_feature_names())
    print(data)

if __name__ == '__main__':
    dictvec()

# 如果数据是数组形式，有类别的这些特征需要先转换成字典数据
# 字典数据抽取:把字典中一些类别数据，分别进行转换成特征(one-hot编码)
# ['city=上海', 'city=北京', 'city=深圳', 'temperature']
# sparse=False，如下
# [[  0.   1.   0. 100.]
#  [  1.   0.   0.  60.]
#  [  0.   0.   1.  30.]]
# one-hot编码：为每个类别生成一个布尔列，这些列中每列只有一个可以为样本取值1

# sparse=True
#   (0, 1) 1.0
#   (0, 3) 100.0
#   (1, 0) 1.0
#   (1, 3) 60.0
#   (2, 2) 1.0
#   (2, 3) 30.0

2）文本特征抽取

第一种方式：CountVectorizer-统计次数

作用：对文本数据进行特征值化
类：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()
# 返回值:单词列表

# 文本特征抽取---英文
# 导入包
from sklearn.feature_extraction.text import CountVectorizer

def countvec():
    '''对文本进行特征值化
    return None'''
    # 实例化
    cv = CountVectorizer()
    # 调用fit_transform方法输入数据并转换，返回sparse矩阵
    data = cv.fit_transform(["life is short,i like python","life is too long,i dislike python"])
    # 调用get_feature_names()方法，返回单词列表
    print(cv.get_feature_names())
    # CountVectorizer()这个API没有sparse参数，利用toarray()方法将sparse矩阵转换array数组
    print(data.toarray())
    return None

if __name__ == '__main__':
    countvec()

# ['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']
# [[0 1 1 1 0 1 1 0]
#  [1 1 1 0 1 1 0 1]]
'''1.统计所有文章当中所有的词，重复的只看做一次-词的列表
   2.对每篇文章在词的列表里面进行统计每个词出现的次数
   3.单个字母不统计-单个英文字母没有分类依据'''

# 文本特征抽取-中文
from sklearn.feature_extraction.text import CountVectorizer
import jieba

# 利用jieba包，利用jieba.cut进行分词，返回值是词语生成器
# 需要对中文进行分词才能详细的进行特征值化
def cutword():
    
    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)

    return c1, c2, c3

def hanzivec():
    """
    中文特征值化
    :return: None
    """
    c1, c2, c3 = cutword()
    print(c1, c2, c3)

    cv = CountVectorizer()

    data = cv.fit_transform([c1, c2, c3])

    print(cv.get_feature_names())

    print(data.toarray())

    return None

if __name__ == '__main__':
    hanzivec()

['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
[[0 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 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 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]]

第二种方式：TfidfVectorizer–分类机器算法的重要依据

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

tf*idf---重要性程度
tf:词的频率（term frequency）      出现的次数
idf:逆文档频率（inverse document frequency） log(总文档数量/该词出现的文档数量)

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()
# 返回值:单词列表

# tfidf文本特征抽取
from sklearn.feature_extraction.text import TfidfVectorizer
import jieba
def cutword():

    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)

    return c1, c2, c3

def tfidfvec():
    """
    中文特征值化
    :return: None
    """
    c1, c2, c3 = cutword()

    print(c1, c2, c3)

    tf = TfidfVectorizer()

    data = tf.fit_transform([c1, c2, c3])

    print(tf.get_feature_names())

    print(data.toarray())

    return None
if __name__ == '__main__':
    tfidfvec()

# ['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
# [[0.         0.         0.21821789 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.        ]
#  [0.         0.         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.2410822 ]
#  [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891
#   0.         0.         0.         0.         0.15698297 0.15698297
#   0.         0.15698297 0.         0.15698297 0.15698297 0.
#   0.1193896  0.         0.         0.15698297 0.         0.
#   0.         0.15698297 0.         0.         0.         0.31396594
#   0.15698297 0.         0.         0.15698297 0.         0.        ]]

5.数据的特征预处理

1）特征预处理概念

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

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

sklearn特征处理API:sklearn. preprocessing

2）归一化

特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间
使得某一特征对最终结果不会造成更大影响，需要进行归一化

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

# 归一化
from sklearn.preprocessing import MinMaxScaler
def mm():
    """
    归一化处理
    :return: NOne
    """
    # 修改feature_range参数来控制缩放范围，默认（0,1）
    mm = MinMaxScaler(feature_range=(2, 3))

    data = mm.fit_transform([[90,2,10,40],[60,4,15,45],[75,3,13,46]])

    print(data)

    return None

if __name__ == '__main__':
    mm()
    
# [[3.         2.         2.         2.        ]
#  [2.         3.         3.         2.83333333]
#  [2.5        2.5        2.6        3.        ]]

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

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

2）标准化

特点：通过对原始数据进行变换把数据变换到均值为0,方差为1范围内

结合归一化来谈标准化

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

sklearn特征化API:  scikit-learn.preprocessing.StandardScaler

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

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

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

# 标准化
from sklearn.preprocessing import StandardScaler

def stand():
    """
    标准化缩放
    :return:
    """
    # 处理之后每列来说所有数据都聚集在均值0附近方差为1
    std = StandardScaler()

    data = std.fit_transform([[ 1., -1., 3.],[ 2., 4., 2.],[ 4., 6., -1.]])

    print(data)

    return None

if __name__ == '__main__':
    stand()

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

标准化总结与缺失值处理

标准化总结与缺失值处理
标准化总结：
在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

缺失值处理：
1.删除-如果每列或者行数据缺失值达到一定的比例，建议放弃整行或者整列
2.插补-可以通过缺失值每行或者每列的平均值、中位数来填充

sklearn缺失值API:  sklearn.preprocessing.Imputer

Imputer语法
# 初始化Imputer,指定”缺失值”，指定填补策略，指定行或列
# 注：缺失值也可以是别的，missing_values指定要替换的值
Imputer(missing_values='NaN', strategy='mean', axis=0)
# 完成缺失值插补
# 方法
Imputer.fit_transform(X,y)      
# X:numpy array格式的数据[n_samples,n_features]
# 返回值：转换后的形状相同的array

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

# 缺失值处理-SimpleImputer
from sklearn.preprocessing import Imputer
import numpy as np

def im():
    """
    缺失值处理
    :return:NOne
    """
    # NaN, nan
    im = Imputer(missing_values='NaN', strategy='mean',axis=0)

    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6]])

    print(data)

    return None
if __name__ == '__main__':
    im()
    
# [[1. 2.]
#  [4. 3.]
#  [7. 6.]]   

6.数据降维

1）特征选择

特征选择原因
冗余：部分特征的相关度高，容易消耗计算性能
噪声：部分特征对预测结果有负影响
特征选择是什么及主要方法
特征选择就是单纯地从提取到的所有特征中选择部分特征作为训练集特征，特征在选择前和选择后可以改变值、也不改变值，但是选择后的特征维数肯定比选择前小，毕竟我们只选择了其中的一部分特征。
主要方法（三大武器）：Filter(过滤式):VarianceThreshold
Embedded(嵌入式)：正则化、决策树
Wrapper(包裹式)
其他特征选择方法-神经网络

VarianceThreshold

sklearn特征选择API：sklearn.feature_selection.VarianceThreshold

VarianceThreshold语法

# 初始化VarianceThreshold,指定阀值方差
VarianceThreshold(threshold = 0.0)
# 删除所有低方差特征

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

# 特征选择
from sklearn.feature_selection import VarianceThreshold

def var():
    '''特征选择：删除低方差的特征
    return None'''
    var = VarianceThreshold(threshold=0.0)
    data = var.fit_transform([[0, 2, 0, 3], [0, 1, 4, 3], [0, 1, 1, 3]])
    print(data)
    return None

if __name__ == '__main__':
    var()

# [[2 0]
#  [1 4]
#  [1 1]]

2）主成分分析

PCA是什么
本质：PCA是一种分析、简化数据集的技术
目的：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。特征数量达到上百个的时候，考虑数据简化，此时，数据也会改变，特征数量也会减少
作用：可以削减回归分析或者聚类分析中特征的数量
高维度数据容易出现的问题：特征之间通常是线性相关的，此时就需要PCA
PCA

sklearn降维API：sklearn. decomposition

PCA语法
# n_components为小数（0-1）表示百分比，动态指定保留多少特征 90%~95%最佳
# n_components为整数时，减少到的特征数量，一般不使用
PCA(n_components=None)
# 将数据分解为较低维数空间

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

# PCA降维
from sklearn.decomposition import PCA

def pca():
    '''主成分分析进行特征降维
        return None'''
    pca = PCA(n_components=0.9)
    data = pca.fit_transform([[2,8,4,5],[6,3,0,8],[5,4,9,1]])
    print(data)
    return None

if __name__ == '__main__':
    pca()
    
# [[ 1.22879107e-15  3.82970843e+00]
#  [ 5.74456265e+00 -1.91485422e+00]
#  [-5.74456265e+00 -1.91485422e+00]]

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

# 用户对物品类别的喜好细分降维-应该使用juyper notebook

# 导入模块
import pandas as pd
from sklearn.decomposition import PCA

# 读取四张表数据
# 订单与商品信息
prior = pd.read_csv('./data/instacart/order_products_prior.csv')
# 商品信息
products = pd.read_csv('./data/instacart/products.csv')
# 用户的订单信息
orders = pd.read_csv('./data/instacart/orders.csv')
# 商品所属具体物品类别
aisles = pd.read_csv('./data/instacart/aisles.csv ')

# 合并4张表到一张表  （用户-物品类别）
_mg = pd.merge(prior,products,on=('product_id','product_id'))
_mg = pd.merge(_mg,orders,on=('order_id','order_id'))
_mg = pd.merge(_mg,aisles,on=('aisle_id','aisle_id'))

# 查看合并表的前10行
_mg.head(10)

# 建立行、列数据，行是用户、列是物品类别
# 交叉表（特殊分组工具）
cross = pd.crosstab(_mg['use_id'],_mg['aisle'])
cross.head(10)

# PCA主成分分析-列表中冗余信息较多
pca = PCA(n_components=0.9)
data = pca.fit_transform(cross)
print(data)