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

本文介绍了机器学习的基础，包括数据集的组成和处理，特别是特征工程的定义、字典与文本特征抽取，如DictVectorizer和CountVectorizer的使用。同时详细讲解了TF-IDF分析，并探讨了特征预处理的重要性，如归一化、标准化和缺失值处理的实践方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

概述

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

用途

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

数据集的组成

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

可用数据集

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

结构组成

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

特征工程

定义

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

特征抽取

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

字典特征抽取

语法

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  
# 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

语法

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  
  
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（总文档数量/该词出现的文档数量）
$TF\times IDF$

语法
类：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()
返回值:单词列表

流程

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

归一化

定义
通过对原始数据进行变换把数据映射到 $[0, 1]$ 之间
公式
$X′=x−minmax−min,x′′=x′∗(mx−mi)+miX'=\frac{x-min}{max-min}, x''=x'*(mx-mi)+mi$

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

实现
(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.        ]]

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

标准化

定义
通过对原始数据进行变换把数据变换到均值为0,方差为1范围内。
API: scikit-learn.preprocessing.StandardScaler
公式
$x′=x−meanσx'=\frac{x-mean}{\sigma}$
实现
（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]]

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

缺失值

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

语法

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

实现
（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()