class_docstr: An abstract class that represents tabular dataset.
  
  This class represents a tabular dataset.
  In a tabular dataset, all examples have the same number of elements.
  For example, all examples of the dataset below have three elements
  (:obj:`a[i]`, :obj:`b[i]`, and :obj:`c[i]`).
  
  .. csv-table::
      :header: , a, b, c
  
      0, :obj:`a[0]`, :obj:`b[0]`, :obj:`c[0]`
      1, :obj:`a[1]`, :obj:`b[1]`, :obj:`c[1]`
      2, :obj:`a[2]`, :obj:`b[2]`, :obj:`c[2]`
      3, :obj:`a[3]`, :obj:`b[3]`, :obj:`c[3]`
  
  Since an example can be represented by both tuple and dict (
  :obj:`(a[i], b[i], c[i])` and :obj:`{'a': a[i], 'b': b[i], 'c': c[i]}`),
  this class uses :attr:`mode` to indicate which representation will be used.
  If there is only one column, an example also can be represented by a value
  (:obj:`a[i]`). In this case, :attr:`mode` is :obj:`None`.
  
  An inheritance should implement
  :meth:`__len__`, :attr:`keys`, :attr:`mode` and :meth:`get_examples`.
  
  >>> import numpy as np
  >>>
  >>> from chainer import dataset
  >>>
  >>> class MyDataset(dataset.TabularDataset):
  ...
  ...     def __len__(self):
  ...         return 4
  ...
  ...     @property
  ...     def keys(self):
  ...          return ('a', 'b', 'c')
  ...
  ...     @property
  ...     def mode(self):
  ...          return tuple
  ...
  ...     def get_examples(self, indices, key_indices):
  ...          data = np.arange(12).reshape((4, 3))
  ...          if indices is not None:
  ...              data = data[indices]
  ...          if key_indices is not None:
  ...              data = data[:, list(key_indices)]
  ...          return tuple(data.transpose())
  ...
  >>> dataset = MyDataset()
  >>> len(dataset)
  4
  >>> dataset.keys
  ('a', 'b', 'c')
  >>> dataset.astuple()[0]
  (0, 1, 2)
  >>> sorted(dataset.asdict()[0].items())
  [('a', 0), ('b', 1), ('c', 2)]
  >>>
  >>> view = dataset.slice[[3, 2], ('c', 0)]
  >>> len(view)
  2
  >>> view.keys
  ('c', 'a')
  >>> view.astuple()[1]
  (8, 6)
  >>> sorted(view.asdict()[1].items())
  [('a', 6), ('c', 8)]
docstr: Apply a transform to each example.
  
  Args:
      keys (tuple of strs): The keys of transformed examples.
      transform (callable): A callable that takes an example
          and returns transformed example. :attr:`mode` of
          transformed dataset is determined by the transformed
          examples.
  
  Returns:
      A transfromed dataset.
docstr_tok: ["Apply","a","transform","to","each","example",".","Args",":","keys","(","tuple","of","strs",")",":","The","keys","of","transformed","examples",".","transform","(","callable",")",":","A","callable","that","takes","an","example","and","returns","transformed","example",".",":","attr",":","`","mode","`","of","transformed","dataset","is","determined","by","the","transformed","examples",".","Returns",":","A","transfromed","dataset","."]
code: def transform(self, keys, transform):
      """Apply a transform to each example.
  
      Args:
          keys (tuple of strs): The keys of transformed examples.
          transform (callable): A callable that takes an example
              and returns transformed example. :attr:`mode` of
              transformed dataset is determined by the transformed
              examples.
  
      Returns:
          A transfromed dataset.
      """
      return chainer.dataset.tabular._transform._Transform(
          self, keys, transform
      )
  
imports: import six
  import chainer
  from chainer.dataset import dataset_mixin
label_desc: Use image node_id 12 for calling the TabularDataset obj's underlying member method code with example usage: obj.transform(keys, transform) and returns: chainer