算法基础——数据集、数据特征选择和处理
数据集
数据集的特征
1.数据集的结构：特征值+目标值
2.Scikit-learn库：
(1).分类：Classfication
(2).回归：Regression
(3).聚类：Clustering
(4).降维：Dimensionality reduction
(5).模型选择：Model selection
(6).特征工程：Preprocessing
数据集的特征抽取
字典特征抽取：对字典数据进行特征值化
类：sklearn.feature_extraction.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 #引入处理字典的函数
def dictvec():
#实例化
dict = DictVectorizer(sparse=False)
#调用fit_transform
data = dict.fit_transform([{'city': '北京','temperature':100},
{'city': '上海','temperature':60},
{'city': '深圳','temperature':30}])
print(dict.get_feature_names())
#字典数据抽取：把字典中一些类别的特征分别转换为特征，数值型不转换
print(data)
return None
if __name__ == '__main__':
dictvec() #得到 one-hot 编码的数组
*********************************************************************
['city=上海', 'city=北京', 'city=深圳', 'temperature']
[[ 0. 1. 0. 100.]
[ 1. 0. 0. 60.]
[ 0. 0. 1. 30.]]
文本特征抽取：对文本数据进行特征值化
类：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方法输入数据并转换
PS：返回格式，利用toarray()进行sparse矩阵转换array数组
from sklearn.feature_extraction.text import CountVectorizer
#导入文本特征抽取的函数
def countvec():
cv = CountVectorizer()
data = cv.fit_transform(['life is is short,i like python','life is too long,i dislike python']) #一个列表代表一个小文章
print(data.toarray()) #将 sparse 矩阵转换为数组
print(cv.get_feature_names()) #统计文章中所有出现的词，不含重复。得到词的列表
##对每个文章，在词的列表里统计每个词出现的次数； 单个字母不做统计
return None
if __name__ == '__main__':
countvec()
#用于文本分类、情感分析
***********************************************************************
[[0 2 1 1 0 1 1 0]
[1 1 1 0 1 1 0 1]]
['dislike', 'is', 'life', 'like', 'long', 'python', 'short', 'too']
汉字中文分词：
1.准备句子，利用jieba.cut进行分词
2.实例化CountVectorizer
3.将分词结果变成字符串当作 fit_transform 的输入值
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 hanzivec():
c1,c2,c3 = cutword()
print(c1,c2,c3)
cv = CountVectorizer()
data = cv.fit_transform([c1,c2,c3])
print(data.toarray()) #将 sparse 矩阵转换为数组
print(cv.get_feature_names())
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]]
['一种', '不会', '不要', '之前', '了解', '事物', '今天', '光是在', '几百万年', '发出', '取决于', '只用', '后天', '含义', '大部分', '如何', '如果', '宇宙', '我们', '所以', '放弃', '方式', '明天', '星系', '晚上', '某样', '残酷', '每个', '看到', '真正', '秘密', '绝对', '美好', '联系', '过去', '这样']
Tfidf 统计词语占比
类：sklearn.feature_extraction.text.TfidfVectorizer
TF-IDF：
TF：term frequency 词的频率
IDF：inverse document frequency 逆文本频率指数
IDF=lg(语料库中的文件总数/包含指定词语的文件数目)
用 TF*IDF 来衡量词语的重要程度
TfidfVectorizer(stop_words=None,…) (stop_words表示忽略哪些词语)
返回词的权重矩阵
●TfidfVectorizer.fit_transform(X,y)
X:文本或者包含文本字符串的可迭代对象
返回值：返回sparse矩阵
●TfidfVectorizer.inverse_transform(X)
X:array数组或者sparse矩阵
返回值:转换之前数据格式
●TfidfVectorizer.get_feature_names()
返回值:单词列表
from sklearn.feature_extraction.text import TfidfVectorizer #导入Tfidf
def tfidfvec():
c1,c2,c3 = cutword()
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. ]....]
特征的预处理
特征处理定义和方法
1.特征处理
通过特定的统计方法（数学方法）将数据转换成算法要求的数据。
2.特征处理方法
类：sklearn.preprocessing
数值型数据：标准缩放：（1）归一化 （2）标准化
缺失值
类别型数据：one-hot编码
时间类型：时间的切分
归一化
特点：通过对原始数据进行变换把数据映射到(默认为[0,1])之间。
公式：
X
′
=
x
−
m
i
n
m
a
x
−
m
i
n
X' = \frac {x-min}{max-min}
X′=max−minx−min
X
′
′
=
X
′
∗
(
m
x
−
m
i
n
)
+
m
i
X'' = X'*(mx-min)+mi
X′′=X′∗(mx−min)+mi
注：作用于每一列，max为一列的最大值，min为一列的最小值,那么X’’为最终结果，mx，mi分别为指定区间值，默认mx为1,mi为0。
sklearn归一化API
类：sklearn.preprocessing.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():
mm = MinMaxScaler() #实例化 MinMaxScaler
##通过 fit_transform 转换
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. ]]
ps:在特定场景下最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景。（很少使用归一化）
标准化
通过对原始数据进行变换把数据变换到均值为0,标准差为1范围内。异常点对于标准化的稳定性影响很小。
公式：
X
′
=
x
−
m
e
a
n
σ
X' =\frac{x-mean}{\sigma}
X′=σx−mean
注：作用于每一列，mean为平均值，σ为标准差，var为方差。
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_
原始数据每列特征的方差
from sklearn.preprocessing import StandardScaler
def stand():
std = StandardScaler() #实例化 StandardScaler
##通过 fit_transform 转换
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]]
PS：在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。
缺失值处理
删除：如果每列或者行数据缺失值达到一定的比例，建议放弃整行或者整列。
插补：可以通过缺失值每行或者每列的平均值、中位数来填充。
sklearn缺失值API:sklearn.preprocessing.Imputer
Imputer(missing_values=‘NaN’, strategy=‘mean’, axis=0)
完成缺失值插补
●Imputer.fit_transform(X,y)
X:numpy array格式的数据[n_samples,n_features]
返回值：转换后的形状相同的array
import numpy as np
from sklearn.preprocessing import Imputer
def im():
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.]]
关于：np.nan(np.Nan)
1、 numpy的数组中可以使用 np.nan/np.NaN 来代替缺失值，属于float类型。
2、如果是文件中的一些缺失值，可以替换成nan，通过np.array转化成 float 型的数组即可。
特征选择
特征选择定义和方法
特征选择就是单纯地从提取到的所有特征中选择部分特征作为训练集特征，特征在选择前和选择后可以改变值、也不改变值，但是选择后的特征维数肯定比选择前小，毕竟我们只选择了其中的一部分特征。
主要方法（三大武器）：（1）Filter(过滤式):VarianceThreshold、（2）Embedded(嵌入式)：正则化、决策树（3）Wrapper(包裹式)
Filter(VarianceThreshold)过滤式
类：sklearn.feature_selection.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():
#特征选择：删除低方差特征
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]]
主成分分析
（1）本质：PCA是一种分析、简化数据集的技术。
（2）目的：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。
（3）作用：可以削减回归分析或者聚类分析中特征的数量。
PS：适用于特征数量在100以上
类：**sklearn. decomposition **
PCA(n_components=None)
##n_components：取小数在0-1之间，表示保存了多少原数据信息（一般取90%~95%）；取整数表示保留多少特征数量
将数据分解为较低维数空间
●PCA.fit_transform(X)
X:numpy array格式的数据[n_samples,n_features]
返回值：转换后指定维度的array
from sklearn.decomposition import PCA
def pca():
#主成分分析进行特征降维
pca = PCA(n_components=0.9) #初始化PCA,指定减少后的维度
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]]
【案例】
import pandas as pd
from sklearn.decomposition import PCA
##读取四张表的数据
prior = pd.read_csv('F:\Python\Python学习\Instacart\order_products__prior.csv')
products = pd.read_csv('F:\Python\Python学习\Instacart\products.csv')
orders = pd.read_csv('F:\Python\Python学习\Instacart\orders.csv')
aisles = pd.read_csv('F:\Python\Python学习\Instacart\aisles.csv')
##用相同的键去合并，用户——购买的物品类别
##合并四张表到一张表
_mg = pd.merge(prior,products,on=['product_id','product_id'])
_mg = pd.merge(_mg,orders,on=['order_id','order_id'])
mt = pd.merge(_mg,aisles,on=['aisle_id','aisle_id'])
mt.head(10)
##交叉表：特殊的分组工具，用于统计分组频率的特殊透视表
cross = pd.crosstab(mt['user_id'],mt['aisle'])
##进行主成分分析
pca = PCA(n_components=0.9)
data = pca.fit_transform(cross)
data.head(10)
机器学习
算法分类
●监督学习：
分类：k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络
回归：线性回归、岭回归
●无监督学习
聚类：k-means
机器学习开发流程
（1）明确解决什么问题：根据数据类型划分应用种类
（2）数据的基本处理：pandas 处理数据（合并表格、缺失值处理）
（3）特征工程：特征处理
（4）找到合适算法去进行预测 （模型=算法+数据）
（5）模型的评估，判定效果
（6）上线使用，以API形式提供
扫一扫
25万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
