sklearn.feature_extraction.DictVectorizer

class sklearn.feature_extraction.DictVectorizer(dtype=<type 'numpy.float64'>, separator='=', sparse=True)

Transforms lists of feature-value mappings to vectors.

This transformer turns lists of mappings (dict-like objects) of feature names to feature values into Numpy arrays or scipy.sparse matrices for use with scikit-learn estimators.

When feature values are strings, this transformer will do a binary one-hot (aka one-of-K) coding: one boolean-valued feature is constructed for each of the possible string values that the feature can take on. For instance, a feature “f” that can take on the values “ham” and “spam” will become two features in the output, one signifying “f=ham”, the other “f=spam”.

Features that do not occur in a sample (mapping) will have a zero value in the resulting array/matrix.

Parameters:

dtype : callable, optional

The type of feature values. Passed to Numpy array/scipy.sparse matrix constructors as the dtype argument.

separator: string, optional :

Separator string used when constructing new features for one-hot coding.

sparse: boolean, optional. :

Whether transform should produce scipy.sparse matrices. True by default.

Attributes:

`vocabulary_` : dict

A dictionary mapping feature names to feature indices.

`feature_names_` : list

A list of length n_features containing the feature names (e.g., “f=ham” and “f=spam”).

See also

FeatureHasher

performs vectorization using only a hash function.

sklearn.preprocessing.OneHotEncoder

handles nominal/categorical features encoded as columns of integers.

Examples

>>> from sklearn.feature_extraction import DictVectorizer
>>> v = DictVectorizer(sparse=False)
>>> D = [{'foo': 1, 'bar': 2}, {'foo': 3, 'baz': 1}]
>>> X = v.fit_transform(D)
>>> X
array([[ 2.,  0.,  1.],
       [ 0.,  1.,  3.]])
>>> v.inverse_transform(X) ==         [{'bar': 2.0, 'foo': 1.0}, {'baz': 1.0, 'foo': 3.0}]
True
>>> v.transform({'foo': 4, 'unseen_feature': 3})
array([[ 0.,  0.,  4.]])

Methods

fit(X[, y])	Learn a list of feature name -> indices mappings.
fit_transform(X[, y])	Learn a list of feature name -> indices mappings and transform X.
get_feature_names()	Returns a list of feature names, ordered by their indices.
get_params([deep])	Get parameters for this estimator.
inverse_transform(X[, dict_type])	Transform array or sparse matrix X back to feature mappings.
restrict(support[, indices])	Restrict the features to those in support.
set_params(**params)	Set the parameters of this estimator.
transform(X[, y])	Transform feature->value dicts to array or sparse matrix.

__init__(dtype=<type 'numpy.float64'>, separator='=', sparse=True)

fit(X, y=None)

Learn a list of feature name -> indices mappings.

Parameters:

X : Mapping or iterable over Mappings

Dict(s) or Mapping(s) from feature names (arbitrary Python objects) to feature values (strings or convertible to dtype).

y : (ignored)

Returns:

self :

fit_transform(X, y=None)

Learn a list of feature name -> indices mappings and transform X.

Like fit(X) followed by transform(X).

Parameters:

X : Mapping or iterable over Mappings

Dict(s) or Mapping(s) from feature names (arbitrary Python objects) to feature values (strings or convertible to dtype).

y : (ignored)

Returns:

Xa : {array, sparse matrix}

Feature vectors; always 2-d.

Notes

Because this method requires two passes over X, it materializes X in memory.

get_feature_names()

Returns a list of feature names, ordered by their indices.

If one-of-K coding is applied to categorical features, this will include the constructed feature names but not the original ones.

get_params(deep=True)

Get parameters for this estimator.

Parameters:

deep: boolean, optional :

If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:

params : mapping of string to any

Parameter names mapped to their values.

inverse_transform(X, dict_type=<type 'dict'>)

Transform array or sparse matrix X back to feature mappings.

X must have been produced by this DictVectorizer’s transform or fit_transform method; it may only have passed through transformers that preserve the number of features and their order.

In the case of one-hot/one-of-K coding, the constructed feature names and values are returned rather than the original ones.

Parameters:

X : {array-like, sparse matrix}, shape = [n_samples, n_features]

Sample matrix.

dict_type : callable, optional

Constructor for feature mappings. Must conform to the collections.Mapping API.

Returns:

D : list of dict_type objects, length = n_samples

Feature mappings for the samples in X.

restrict(support, indices=False)

Restrict the features to those in support.

Parameters:

support : array-like

Boolean mask or list of indices (as returned by the get_support member of feature selectors).

indices : boolean, optional

Whether support is a list of indices.

set_params(**params)

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The former have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Returns:self :

transform(X, y=None)

Transform feature->value dicts to array or sparse matrix.

Named features not encountered during fit or fit_transform will be silently ignored.

Parameters:

X : Mapping or iterable over Mappings, length = n_samples

Dict(s) or Mapping(s) from feature names (arbitrary Python objects) to feature values (strings or convertible to dtype).

y : (ignored)

Returns:

Xa : {array, sparse matrix}

Feature vectors; always 2-d.