class_docstr: Standardize channel data.
  
  This class scales data for each channel. It differs from scikit-learn
  classes (e.g., :class:`sklearn.preprocessing.StandardScaler`) in that
  it scales each *channel* by estimating μ and σ using data from all
  time points and epochs, as opposed to standardizing each *feature*
  (i.e., each time point for each channel) by estimating using μ and σ
  using data from all epochs.
  
  Parameters
  ----------
  %(info)s Only necessary if ``scalings`` is a dict or None.
  scalings : dict, str, default None
      Scaling method to be applied to data channel wise.
  
      * if scalings is None (default), scales mag by 1e15, grad by 1e13,
        and eeg by 1e6.
      * if scalings is :class:`dict`, keys are channel types and values
        are scale factors.
      * if ``scalings=='median'``,
        :class:`sklearn.preprocessing.RobustScaler`
        is used (requires sklearn version 0.17+).
      * if ``scalings=='mean'``,
        :class:`sklearn.preprocessing.StandardScaler`
        is used.
  
  with_mean : bool, default True
      If True, center the data using mean (or median) before scaling.
      Ignored for channel-type scaling.
  with_std : bool, default True
      If True, scale the data to unit variance (``scalings='mean'``),
      quantile range (``scalings='median``), or using channel type
      if ``scalings`` is a dict or None).
code: def __init__(
      self, info=None, scalings=None, with_mean=True, with_std=True
  ):
      self.info = info
      self.with_mean = with_mean
      self.with_std = with_std
      self.scalings = scalings
  
      if not (scalings is None or isinstance(scalings, (dict, str))):
          raise ValueError(
              "scalings type should be dict, str, or None, "
              "got %s" % type(scalings)
          )
      if isinstance(scalings, str):
          _check_option("scalings", scalings, ["mean", "median"])
      if scalings is None or isinstance(scalings, dict):
          if info is None:
              raise ValueError(
                  'Need to specify "info" if scalings is'
                  "%s" % type(scalings)
              )
          self._scaler = _ConstantScaler(info, scalings, self.with_std)
      elif scalings == "mean":
          from sklearn.preprocessing import StandardScaler
  
          self._scaler = StandardScaler(
              with_mean=self.with_mean, with_std=self.with_std
          )
      else:  # scalings == 'median':
          from sklearn.preprocessing import RobustScaler
  
          self._scaler = RobustScaler(
              with_centering=self.with_mean, with_scaling=self.with_std
          )
  
imports: import numpy
  from .._fiff.pick import _pick_data_channels, _picks_by_type, _picks_to_idx, pick_info, pick_types
  from ..cov import _check_scalings_user
  from ..filter import filter_data
  from ..time_frequency import psd_array_multitaper
  from ..utils import _check_option, _validate_type, fill_doc, verbose
  from .base import BaseEstimator
  from .mixin import TransformerMixin
label_desc: Use image node_id 1 to create a new Scaler object from inherited base classes: TransformerMixin, BaseEstimator with example: obj = Scaler(info, scalings, with_mean, with_std)