sklearn.feature_extraction模块，对数据进行特征提取，以支持机器学习算法使用。
一、DictVectorizer
sklearn.feature_extraction.DictVectorizer(dtype=<class 'numpy.float64'>,
separator='=',sparse=True,sort=True)
将<特征-值>映射转化为向量。字典类型的对象转化为numpy.array或者scipy.sparse
特征值为string类型时，向量表示为one-hot二元编码，出现的string为1，其余为0.
特征值为int等数字类型时，对应的值为相应的数字。
参数：
dtype:特征值的类型。
separator:可选，string。当特征值为string时，用来连接特征名称和值的符号，默认为'='。
例，当特征名为'f',而特征值含有'pam'和'spam'时，one-hot对应的向量名为'f=pam'和'f=spam'
sparse:boolean,可选。默认为True,转换过程中生成一个scipy.sparse矩阵。当数据多表示为one-hot
类型时，占用内存过大，稀疏表示可以节约大量空间。
sort:boolean,可选，默认为True。转化完成后对feature_names_和vocabulary_按字典序排列。
属性：
feature_names_:长度为n_features的列表，含有所有特征名称.
vocabulary_:字典类型，特征名映射到特征在list中的index的字典对象
方法：
fit(X,y=None):学习一个将特征名称映射到索引的列表，返回值是其自身(DictVectorizer)
fit_transform(X,y=None):学习一个将特征名称映射到索引的列表，返回值是为对应的特征向量，一般2维等价于fit(X).transform(X)
get_feature_names():返回一个含有特征名称的列表，通过索引排序，如果含有one-hot表示的特征，则显示相应的特征名
get_params(deep=True):返回模型的参数（string到任何类型的映射）
inverse_transform(X,dict_type=<class 'dict'>):将转化好的特征向量恢复到转化之前的表示状态。X必须是通过transform或者fit_transform生成的向量。
restrict(support,indices=False):对支持使用特征选择的模型进行特征限制，例如只选择前几个特征：support:矩阵类型，boolean或者索引列表，一般是feature selectors.get_support()的返回值。indices:boolean，可选，表示support是不是索引的列表，返回值是其自身(DictVectorizer)
# -*- coding: utf-8 -*-
from sklearn.feature_extraction import DictVectorizer
v = DictVectorizer(sparse=False)
dict1 = {'city': 'Beijing','temperature': 36}
dict2 = {'city': 'Shaihai','temperature': 37}
dict3 = {'city': 'Shenzhen','temperature': 39}
d = [dict1,dict2,dict3]
x = v.fit_transform(d)
print(v.feature_names_)
print('-' * 50)
print(x)
print('-' * 50)
print(v.vocabulary_)
print('-' * 50)
print(v.fit(d))
print('-' * 50)
print(v.fit_transform(d))
print('-' * 50)
print(v.get_feature_names())
print('-' * 50)
print(v.get_params())
print('-' * 50)
print(v.inverse_transform(x))
结果：
['city=Beijing', 'city=Shaihai', 'city=Shenzhen', 'temperature']
--------------------------------------------------
[[ 1. 0. 0. 36.]
[ 0. 1. 0. 37.]
[ 0. 0. 1. 39.]]
--------------------------------------------------
{'city=Beijing': 0, 'city=Shaihai': 1, 'city=Shenzhen': 2, 'temperature': 3}
--------------------------------------------------
DictVectorizer(dtype=<type 'numpy.float64'>, separator='=', sort=True,
sparse=False)
--------------------------------------------------
[[ 1. 0. 0. 36.]
[ 0. 1. 0. 37.]
[ 0. 0. 1. 39.]]
--------------------------------------------------
['city=Beijing', 'city=Shaihai', 'city=Shenzhen', 'temperature']
--------------------------------------------------
{'sort': True, 'dtype': <type 'numpy.float64'>, 'separator': '=', 'sparse': False}
--------------------------------------------------
[{'city=Beijing': 1.0, 'temperature': 36.0}, {'city=Shaihai': 1.0, 'temperature': 37.0}, {'city=Shenzhen': 1.0, 'temperature': 39.0}]二、FeatureHasher
sklearn.feature_extraction.FeatureHasher(n_features=1048576,input_type='dict',dytpe=<class 'numpy.float64'>,alternate_sign=True,non_negative=False)
采用哈希方法将象征性的特征序列转化为scipy.sparse矩阵，可以节约时间和空间。
参数：
n_features:int,可选。输出矩阵的特征个数（行数）
input_type:string,可选，默认为'dict'，参数可为:'dict','pair' or string
'pair':(string,int)，string经过哈希映射，同一个string对应的int值相加作为特征值。
string:(string,1)，类似于pair的int为1。
dtype:numpy.type,可选，默认为np.float64特征值的类型
alternate_sign:boolean,可选，默认True。为True时为特征添加一个交替符号保存哈希空间的内积值。可以近似看作随机稀疏化。
non_negative:boolean,可选，默认False，为True时特征矩阵必须为非负数。
方法：
fit([X,y]):什么都不干233，存在是为了保证scikit-learn transformer API的完整性
fit_transform(X[,y]):
X:shape(n_samples,n_features)的numpy矩阵，训练集
y:shape(n_samples,)的numpy矩阵，目标值
返回X_new:shape(n_samples,n_features_new)的numpy矩阵，转化后的矩阵
get_params(deep=True)
set_params(**params)
transform(raw_X)，用法和DictVectorizer类似
from sklearn.feature_extraction import FeatureHasher
h = FeatureHasher(n_features=10,alternate_sign=False)
dict1 = {'city': 'Beijing','temperature': 36}
dict2 = {'city': 'Shaihai','temperature': 37}
dict3 = {'city': 'Shenzhen','temperature': 39}
d = [dict1,dict2,dict3]
f = h.transform(d)
print(f)
print(f.toarray())结果：
(0, 3) 1.0
(0, 5) 36.0
(1, 5) 37.0
(1, 6) 1.0
(2, 5) 39.0
(2, 7) 1.0
[[ 0. 0. 0. 1. 0. 36. 0. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 37. 1. 0. 0. 0.]
[ 0. 0. 0. 0. 0. 39. 0. 1. 0. 0.]]三、CountVectorizer
sklearn.feature_extraction.text.CountVectorizer(input='content',encoding='utf-8',decode_error='strict',strip_accents=None,lowercase=True,preprocessor=None,tokenizer=None,stop_words=None,token_pattern='(?u)\b\w\w+\b',ngram_range=(1,1),analyzer='word',max_df=1.0,min_df=1,max_features=None,vocabulary=None,binary=False,dtype=<class 'numpy.int64'>)
将文本文档的集和转化为表示单词数量的矩阵，采用scipy.sparse.csr_matrix构造稀疏表示。
参数：
input:string{'filename','file','content'}
filename:使用fit方法的参数是一个文件路径的列表集和，自动读入list中所有文件内容。
file:fit的参数是一个文件路径，且该文件可读
content:fit的参数是string或者bytes，即要处理的文本
encoding:string，默认utf-8。解码格式
decode_error:{'strict','ignore','replace'}，当给定的文本含有上述encoding不能解码的字符时，strict抛出编码错误异常，ignore为忽略.
strip_accents:{'ascii','unicode',None}，预处理时去掉口音，应该是一些俗语。ascii只在ASCII编码的字符上操作，速度快。unicode，用于任何字符，速度较慢。None不进行操作
analyzer:string,{'word','char','char_wb'}，特征被分为word还是n-grams.char_wb只从文本范围内产生n-grams.
preprocessor:callable or None(默认)
重载预处理过程
tokenizer:callable or None(默认)
重载字符串的标记化步骤。只在analyzer=='word'时有效
ngram_range:tuple(min_n,max_n)
参数为元组，满足min_n<=n<=max_n的n会产生相应的n-grams。
stop_words:'english',list or None(默认)
english:使用英语中的停用词
list:含有停用词的list集合，所有在list中的单词会被删除。只在analyzer=='word'时有效
None:不会删除停用词。max_df被设置为[0.7,1.0)的值根据单词在文本中出现的频率自动滤除停用词。
lowercase:boolean,True（默认）。将所有字符变为小写
token_pattern:string
指示构成单词形式的正则表达式，只在analyzer=='word'时有效。例如默认的(?u)\b\w\w+\b表示两个字母及以上的会被当作单词，标点符号视作单词分隔符
max_df:float in range[0.0,1.0]或者int ,默认=1
建立单词表时，忽略频率严格大于给定阀值的项。float表示比率，int表示数量
min_df:float in range[0.0,1.0]或者int ,默认=1
建立单词表时，忽略频率严格小于给定阀值的项。float表示比率，int表示数量
max_features:int or None(默认)
int时建立单词表只选择按出现频率的top max_features个项。vocabulary不是None时忽略
vocabulary:可选，映射或迭代器，映射:如字典类型，keys是单词，value是在特征矩阵中的索引，None时单词表由输入文本决定。
binary:boolean,默认False。为True时所有非零项设为1，表示其出现过而不是统计出现次数。
dtype:type,可选，设定fit_transform()或transfrom()的返回矩阵类型
属性：
vocabulary_:字典类型，单词到特征索引的映射
stop_words_:集合，识别出的停用词集合.
方法：
build_analyzer():返回一个处理预处理和词语切分的调用
build_preprocessor():返回一个词语切分前预处理文本的函数
build_tokenizer():返回一个将字符串分成词语序列的函数
decode(doc):将输入编码为unicode字符串，编码方式取决于向量化参数
fit(raw_documents,y=None):从原始文档中学习一个包含所有单词的词汇表字典
raw_documents:一个str,unicode或文件对象的迭代器，返回自身
fit_transform(raw_documents,y=None):学习一个词汇表字典返回一个文档-单词的矩阵，shape(n_samples,n_featrues)，相当于fit.transform,但是效率更高
raw_documents:一个str,unicode或文件对象的迭代器
get_feature_names():特征索引到特征名称的映射
get_params(deep=True):获取模型的参数。
get_stop_words():建立有效的停用词表
inverse_transform(X):将非零矩阵X恢复到每个文档的terms表示
X:{array,sparse matrix},shape(n_samples,n_features)，返回值X_inv:矩阵列表，长度为n_samples
set_params(**params):设置参数，返回设置好的模型
transform(raw_documents):将文档转化为文档-单词矩阵。
# -*- coding: utf-8 -*-
from sklearn.feature_extraction.text import CountVectorizer
# 实例化CountVectorizer
vector = CountVectorizer()
# 调用fit_transform输入并转换数据
s1 = "life is short,i like python"
s2 = "life is too long,i dislike python"
res = vector.fit_transform([s1,s2])
# 打印结果
print(vector.get_feature_names())
print(res.toarray())
结果：
[u'dislike', u'is', u'life', u'like', u'long', u'python', u'short', u'too']
[[0 1 1 1 0 1 1 0]
[1 1 1 0 1 1 0 1]]四、TfidfTransformer
TfidfTransformer用于统计vectorizer中每个词语的TF-IDF值
sklearn.feature_extraction.text.TfidfTransformer(norm='l2',use_idf=True,smooth_idf=True,sublinear_idf=False)
smooth_idf=True：
idf = log((1+总文档数)/(1+包含ti的文档数)) +1
smooth_idf=False:
idf = log log((总文档数)/(包含ti的文档数)) +1
tf-idf =tf*idf
之后需进行 the Euclidean (L2) norm，得到最终的tf-idf权重。
# encoding: UTF-8
from __future__ import print_function
from sklearn.feature_extraction.text import TfidfVectorizer
import jieba
def cutword():
con1 = jieba.cut(u"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。")
con2 = jieba.cut(u"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。")
con3 = jieba.cut(u"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。")
# 转换成列表
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())
if __name__ == '__main__':
tfidfvec()结果：由于我用的时python2，字符转化有点问题，我就不查了
今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。
[u'\u4e00\u79cd', u'\u4e0d\u4f1a', u'\u4e0d\u8981', u'\u4e4b\u524d', u'\u4e86\u89e3', u'\u4e8b\u7269', u'\u4eca\u5929', u'\u5149\u662f\u5728', u'\u51e0\u767e\u4e07\u5e74', u'\u53d1\u51fa', u'\u53d6\u51b3\u4e8e', u'\u53ea\u7528', u'\u540e\u5929', u'\u542b\u4e49', u'\u5927\u90e8\u5206', u'\u5982\u4f55', u'\u5982\u679c', u'\u5b87\u5b99', u'\u6211\u4eec', u'\u6240\u4ee5', u'\u653e\u5f03', u'\u65b9\u5f0f', u'\u660e\u5929', u'\u661f\u7cfb', u'\u665a\u4e0a', u'\u67d0\u6837', u'\u6b8b\u9177', u'\u6bcf\u4e2a', u'\u770b\u5230', u'\u771f\u6b63', u'\u79d8\u5bc6', u'\u7edd\u5bf9', u'\u7f8e\u597d', u'\u8054\u7cfb', u'\u8fc7\u53bb', u'\u8fd9\u6837']
[[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. ]]
扫一扫
1066
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
