基础机器学习与特征工程，特征预处理

概述

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

用途

1. 替代重复劳动
2. 解决需要经验的专业问题

---

数据集的组成

数据以文件形式存储（.csv等）
读取工具：pandas，numpy（释放GIL，多线程并行）

可用数据集

1. kaggle
2. Scikit-learn：数据量小，易学

结构组成

• 特征值+目标值（注：有些数据集没有目标值）
  ![[ML数据集结构组成.png]]
• 机器学习有重复值不需要去重，数据一样对学习结果没有影响

---

特征工程

定义

数据中对特征进行处理，在算法和数据相同的情况下，特征工程会影响到最后的准确度。

特征抽取

1. 定义
   特征抽取对文本，字符串等数据进行特征值化（数字），方便计算机理解

字典特征抽取

1. 语法

• DictVectorizer.fit_transform(X)
  X:字典或者包含字典的迭代器
  返回值：返回sparse矩阵
• DictVectorizer.inverse_transform(X)
  X:array数组或者sparse矩阵
  返回值:转换之前数据格式
• DictVectorizer.get_feature_names()
  返回类别名称
• DictVectorizer.transform(X)
  按照原先的标准转换

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

from sklearn.feature_extraction import DictVectorizer  
# import 类  
  
def dictvec():  
  
    # 实例化  
 	dict = DictVectorizer()  
  
    # 调用fit_transform,输入数据  
 	data = dict.fit_transform([{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}])  
    
	print(data)  
    return None  
  
if __name__ == "__main__":  
    dictvec()
	
--------------------------------------
  (0, 1)	1.0
  (0, 3)	100.0
  (1, 0)	1.0
  (1, 3)	60.0
  (2, 2)	1.0
  (2, 3)	30.0	#返回sparse矩阵（了解，一般不用）
  
  

# 实例化  
dict = DictVectorizer(sparse=False)
--------------------------------------
[[  0.   1.   0. 100.]  #返回ndarray矩阵,{0，1，0}前面代表城市
 [  1.   0.   0.  60.]  #字符转化成one-hot编码
 [  0.   0.   1.  30.]]

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


# 调用fit_transform,输入数据  
data = dict.fit_transform([{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}])  
print(dict.get_feature_names())  #返回类别名称
--------------------------------------
['city=上海', 'city=北京', 'city=深圳', 'temperature']


print(dict.inverse_transform(data)) #按照原先的标准转换
--------------------------------------
[{'city=北京': 1.0, 'temperature': 100.0}, {'city=上海': 1.0, 'temperature': 60.0}, {'city=深圳': 1.0, 'temperature': 30.0}]

文本特征抽取

• 类：sklearn.feature_extraction.text.CountVectorizer

1. 语法

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

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

from sklearn.feature_extraction.text import CountVectorizer  
  
def countvec():  
    cv = CountVectorizer()  
  
    data = cv.fit_transform(["life is short,i like python","life is too long,i dislike python"])  
  
    print(cv.get_feature_names())  
  
    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]]	
 #对每篇文章,在词的列表里面进行统计每个词出现的次数，但单个字母不统计（“i”，“，”）

TF-IDF分析问题

TF：term-frequency（词频）
IDF： inverse document frequency（逆文档频率）= log（总文档数量/该词出现的文档数量）
$sig=TF\times IDF$

1. 语法
   类：sklearn.feature_extraction.text.TfidfVectorizer

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

2. 流程

def tfidfvec():  
    tf = TfidfVectorizer()  
  
    data = tf.fit_transform(["life is short,i like python","life is too long,i dislike python"])  
  
    print(tf.get_feature_names())  
  
    print(data.toarray()) #转化为数组形式  
  
 	return None
 
-------------------------------------- 
 ['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']
[[0.         0.37930349 0.37930349 0.53309782 0.         0.37930349
  0.53309782 0.        ]
 [0.47042643 0.33471228 0.33471228 0.         0.47042643 0.33471228
  0.         0.47042643]]

特征预处理

• 对数据进行处理，对不符合标准的数据进行处理
• API: sklearn.preprocessing

归一化

1. 定义
   通过对原始数据进行变换把数据映射到$[0,1]$之间

2. 公式
   $$X^{\prime }=\frac{x-min}{max-min},x^{\prime \prime }=x^{\prime }\ast (mx-mi)+mi$$

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

3. 实现
   (1) 语法

• MinMaxScalar(feature_range=(0,1)…)
  每个特征缩放到给定范围(默认[0,1])
• MinMaxScalar.fit_transform(X)
  X:numpy array格式的数据[n_samples,n_features]
  返回值：转换后的形状相同的array

(2) 步骤

• 实例化MinMaxScalar
• 通过fit_transform转换

from sklearn.preprocessing import MinMaxScaler  
  
def mm():  
    mm = MinMaxScaler()  #实例化
    data = mm.fit_transform([[90,2,10,40],[60,4,15,45],[75,3,13,46]])  
    print(data)  
    return None  
  
if __name__ == "__main__":  
    mm()
--------------------------------
[[1.         0.         0.         0.        ]
 [0.         1.         1.         0.83333333]
 [0.5        0.5        0.6        1.        ]]

4. 适用性（少量精确数据）
   最大值与最小值非常容易受异常点影响，所以稳定性较差，只适合传统精确小数据场景（几乎不用）。

标准化

1. 定义
   通过对原始数据进行变换把数据变换到均值为0,方差为1范围内。
   API: scikit-learn.preprocessing.StandardScaler
2. 公式
   $$x^{\prime }=\frac{x-mean}{\sigma }$$
3. 实现
   （1）语法

• StandardScaler.fit_transform(X,y)
  X:numpy array格式的数据[n_samples,n_features]
  返回值：转换后的形状相同的array
• StandardScaler.mean_
  原始数据中每列特征的平均值
• StandardScaler.std_
  原始数据每列特征的方差

（2）步骤

• 实例化StandardScalar
• 通过fit_transform转换

def stand():  
   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]]

4. 适用性（大量数据）
   样本足够多的时候比较稳定。

缺失值

• 插补：可以通过缺失值每行或者每列的平均值、中位数来填充
  API: sklearn.preprocessing.Imputer

1. 语法

• Imputer(missing_values=‘NaN’, strategy=‘mean’, axis=0)
  完成缺失值插补
• Imputer.fit_transform(X)
  返回值：转换后的形状相同的array

2. 实现
   （1）初始化Imputer，指定”缺失值”，指定填补策略，指定行或列
   （2）调用fit_transform

from sklearn.impute import SimpleImputer

def simple():  
    sim = SimpleImputer(missing_values=np.nan,strategy="mean")  
    data_2 = sim.fit_transform([[1,2],[np.nan,3],[7,6]])  
  
    print(data_2)  
    return None  
  
if __name__ == "__main__":  
    simple()