sklearn特征提取方法学习

sklearn.feature_extraction模块主要处理从原始数据中特征提取，目前主要包括从文本或图像中提取特征方法。

• sklearn.feature_extraction.DictVectorizer(dtype=<type ‘numpy.float64’>, separator=’=’,sparse=True, sort=True)：将字典列表映射成矩阵

参数说明：

dtype：特征值数据类型，默认值numpy.float64，支持Numpy数组、scipy稀疏矩阵

separator：哑变量构造新特征使用的分隔符，默认‘=’

sparse：表示经过处理后的数据是否是稀疏标识，True表示生产稀疏矩阵，False表示生产数组

sort：训练时，特征名称和特征值是否进行排序标识，默认True

①利用DictVectorizer特征提取例子

a、字典的values都是数字型

In [1]: from sklearn.feature_extraction import DictVectorizer
   ...: import numpy as np
   ...: v = DictVectorizer(dtype=np.float64,sparse=False,sort=True)
   ...: D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
   ...: X = v.fit_transform(D)
   ...: print(type(v.fit_transform(D)))
   ...: X
   ...:
   ...:
<class 'numpy.ndarray'>
Out[1]:
array([[ 2.,  0.,  1.],
       [ 0.,  1.,  3.]])

b、字典values是字符型

In [3]: from sklearn.feature_extraction import DictVectorizer
   ...: measurements = [{'city': 'Dubai', 'temperature': 33.},
   ...:                 {'city': 'London', 'temperature': 12.},
   ...:                 {'city': 'San Fransisco', 'temperature': 18.} ]
   ...: vec = DictVectorizer(sparse=True,separator=':',sort=True)
   ...: print(type(vec.fit_transform(measurements)))
   ...: vec.fit_transform(measurements).toarray()
   ...:
<class 'scipy.sparse.csr.csr_matrix'>
Out[3]:
array([[  1.,   0.,   0.,  33.],
       [  0.,   1.,   0.,  12.],
       [  0.,   0.,   1.,  18.]])

从上面两种情况看：若字典的values都是数字型，则将字典的键映射成特征名称，字典values映射成特征值；若字典的values是字符型(即分类类型)，则进行哑变量处理，将字符型的"字典字符键+分隔符separator+字典字符values"映射成特征名称，特征值为0或1

②属性值

vocabulary_:返回特征名称及索引组成的字典

In [4]: v.vocabulary_
Out[4]: {'bar': 0, 'baz': 1, 'foo': 2}

In [5]: vec.vocabulary_
Out[5]: {'city:Dubai': 0, 'city:London': 1, 'city:San Fransisco': 2, 'temperatur
e': 3}

feature_names_：返回特征名称组成的列表

In [6]: v.feature_names_
Out[6]: ['bar', 'baz', 'foo']

In [7]: vec.feature_names_
Out[7]: ['city:Dubai', 'city:London', 'city:San Fransisco', 'temperature']

③方法

• fit(X, y=None)

In [8]: v.fit(D)
Out[8]:
DictVectorizer(dtype=<class 'numpy.float64'>, separator='=', sort=True,
        sparse=False)

In [9]: vec.fit(measurements)
Out[9]:
DictVectorizer(dtype=<class 'numpy.float64'>, separator=':', sort=True,
        sparse=True)

• fit_transform(X, y=None)
  

In [10]: v.fit_transform(D)
Out[10]:
array([[ 2.,  0.,  1.],
       [ 0.,  1.,  3.]])

In [11]: vec.fit_transform(measurements).toarray()
Out[11]:
array([[  1.,   0.,   0.,  33.],
       [  0.,   1.,   0.,  12.],
       [  0.,   0.,   1.,  18.]])

In [12]: vec.fit_transform(measurements)
Out[12]:
<3x4 sparse matrix of type '<class 'numpy.float64'>'
        with 6 stored elements in Compressed Sparse Row format>

• get_feature_names()
  

In [13]: v.get_feature_names()
Out[13]: ['bar', 'baz', 'foo']

In [14]: vec.get_feature_names()
Out[14]: ['city:Dubai', 'city:London', 'city:San Fransisco', 'temperature']

• inverse_transform(X, dict_type=<type ‘dict’>)
  

In [15]: v.inverse_transform(X,dict)
Out[15]: [{'bar': 2.0, 'foo': 1.0}, {'baz': 1.0, 'foo': 3.0}]

In [16]: X2 = vec.fit_transform(measurements).toarray()

In [17]: X2
Out[17]:
array([[  1.,   0.,   0.,  33.],
       [  0.,   1.,   0.,  12.],
       [  0.,   0.,   1.,  18.]])

In [18]: vec.inverse_transform(X2,dict_type=dict)
Out[18]:
[{'city:Dubai': 1.0, 'temperature': 33.0},
 {'city:London': 1.0, 'temperature': 12.0},
 {'city:San Fransisco': 1.0, 'temperature': 18.0}]

• restrict(support, indices=False)
  

In [19]: from sklearn.feature_extraction import DictVectorizer
    ...: from sklearn.feature_selection import SelectKBest,chi2
    ...: import numpy as np
    ...: v = DictVectorizer(dtype=np.float64,sparse=False,sort=True)
    ...: D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
    ...: X = v.fit_transform(D)
    ...: support = SelectKBest(chi2,k=2).fit(X,[0,1])
    ...: print(support.get_support())
    ...: print(v.restrict(support.get_support()))
    ...: v.get_feature_names()
    ...:
[ True False  True]
DictVectorizer(dtype=<class 'numpy.float64'>, separator='=', sort=True,
        sparse=False)
Out[19]: ['bar', 'foo']

• transform(X, y=None)

In [20]: v.transform(D)
Out[20]:
array([[ 2.,  1.],
       [ 0.,  3.]])

• get_params(deep=True)
  

In [21]: v.get_params()
Out[21]: {'dtype': numpy.float64, 'separator': '=', 'sort': True, 'sparse': Fals
e}

• set_params(**params)
  

In [22]: v.set_params(sparse=True)
Out[22]:
DictVectorizer(dtype=<class 'numpy.float64'>, separator='=', sort=True,
        sparse=True)