class_docstr: 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".
  
  However, note that this transformer will only do a binary one-hot encoding
  when feature values are of type string. If categorical features are
  represented as numeric values such as int, the DictVectorizer can be
  followed by OneHotEncoder to complete binary one-hot encoding.
  
  Features that do not occur in a sample (mapping) will have a zero value
  in the resulting array/matrix.
  
  Read more in the :ref:`User Guide <dict_feature_extraction>`.
  
  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.
  sort : boolean, optional.
      Whether ``feature_names_`` and ``vocabulary_`` should be sorted when fitting.
      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").
  
  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.]])
  
  See also
  --------
  FeatureHasher : performs vectorization using only a hash function.
  sklearn.preprocessing.OneHotEncoder : handles nominal/categorical features
    encoded as columns of integers.
docstr: 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.
docstr_tok: ["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","."]
code: def inverse_transform(self, X, dict_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.
      """
      # COO matrix is not subscriptable
      X = check_array(X, accept_sparse=["csr", "csc"])
      n_samples = X.shape[0]
  
      names = self.feature_names_
      dicts = [dict_type() for _ in xrange(n_samples)]
  
      if sp.issparse(X):
          for i, j in zip(*X.nonzero()):
              dicts[i][names[j]] = X[i, j]
      else:
          for i, d in enumerate(dicts):
              for j, v in enumerate(X[i, :]):
                  if v != 0:
                      d[names[j]] = X[i, j]
  
      return dicts
  
imports: from array import array
  from collections import Mapping
  from operator import itemgetter
  import numpy
  import scipy.sparse
  from ..base import BaseEstimator, TransformerMixin
  from ..externals import six
  from ..externals.six.moves import xrange
  from ..utils import check_array, tosequence
  from ..utils.fixes import frombuffer_empty
label_desc: Use image node_id 5 for calling the DictVectorizer obj's underlying member method code with example usage: obj.inverse_transform(X, dict_type) and returns: dicts