class_docstr: Imputation transformer for completing missing values.
  
  Read more in the :ref:`User Guide <imputation>`.
  
  Parameters
  ----------
  missing_values : integer or "NaN", optional (default="NaN")
      The placeholder for the missing values. All occurrences of
      `missing_values` will be imputed. For missing values encoded as np.nan,
      use the string value "NaN".
  
  strategy : string, optional (default="mean")
      The imputation strategy.
  
      - If "mean", then replace missing values using the mean along
        the axis.
      - If "median", then replace missing values using the median along
        the axis.
      - If "most_frequent", then replace missing using the most frequent
        value along the axis.
  
  axis : integer, optional (default=0)
      The axis along which to impute.
  
      - If `axis=0`, then impute along columns.
      - If `axis=1`, then impute along rows.
  
  verbose : integer, optional (default=0)
      Controls the verbosity of the imputer.
  
  copy : boolean, optional (default=True)
      If True, a copy of X will be created. If False, imputation will
      be done in-place whenever possible. Note that, in the following cases,
      a new copy will always be made, even if `copy=False`:
  
      - If X is not an array of floating values;
      - If X is sparse and `missing_values=0`;
      - If `axis=0` and X is encoded as a CSR matrix;
      - If `axis=1` and X is encoded as a CSC matrix.
  
  Attributes
  ----------
  statistics_ : array of shape (n_features,)
      The imputation fill value for each feature if axis == 0.
  
  Notes
  -----
  - When ``axis=0``, columns which only contained missing values at `fit`
    are discarded upon `transform`.
  - When ``axis=1``, an exception is raised if there are rows for which it is
    not possible to fill in the missing values (e.g., because they only
    contain missing values).
docstr: Fit the transformer on dense data.
docstr_tok: ["Fit","the","transformer","on","dense","data","."]
code: def _dense_fit(self, X, strategy, missing_values, axis):
      """Fit the transformer on dense data."""
      X = check_array(X, force_all_finite=False)
      mask = _get_mask(X, missing_values)
      masked_X = ma.masked_array(X, mask=mask)
  
      # Mean
      if strategy == "mean":
          mean_masked = np.ma.mean(masked_X, axis=axis)
          # Avoid the warning "Warning: converting a masked element to nan."
          mean = np.ma.getdata(mean_masked)
          mean[np.ma.getmask(mean_masked)] = np.nan
  
          return mean
  
      # Median
      elif strategy == "median":
          if tuple(int(v) for v in np.__version__.split(".")[:2]) < (
              1,
              5,
          ):
              # In old versions of numpy, calling a median on an array
              # containing nans returns nan. This is different is
              # recent versions of numpy, which we want to mimic
              masked_X.mask = np.logical_or(masked_X.mask, np.isnan(X))
          median_masked = np.ma.median(masked_X, axis=axis)
          # Avoid the warning "Warning: converting a masked element to nan."
          median = np.ma.getdata(median_masked)
          median[np.ma.getmaskarray(median_masked)] = np.nan
  
          return median
  
      # Most frequent
      elif strategy == "most_frequent":
          # scipy.stats.mstats.mode cannot be used because it will no work
          # properly if the first element is masked and if its frequency
          # is equal to the frequency of the most frequent valid element
          # See https://github.com/scipy/scipy/issues/2636
  
          # To be able access the elements by columns
          if axis == 0:
              X = X.transpose()
              mask = mask.transpose()
  
          most_frequent = np.empty(X.shape[0])
  
          for i, (row, row_mask) in enumerate(zip(X[:], mask[:])):
              row_mask = np.logical_not(row_mask).astype(np.bool)
              row = row[row_mask]
              most_frequent[i] = _most_frequent(row, np.nan, 0)
  
          return most_frequent
  
imports: import warnings
  import numpy
  import numpy.ma
  from scipy import sparse
  from scipy import stats
  from ..base import BaseEstimator, TransformerMixin
  from ..utils import check_array
  from ..utils.fixes import astype
  from ..utils.sparsefuncs import _get_median
  from ..utils.validation import check_is_fitted
  from ..utils.validation import FLOAT_DTYPES
  from ..externals import six
label_desc: Use image node_id 4 for calling the Imputer obj's underlying member method code with example usage: obj._dense_fit(X, strategy, missing_values, axis) and returns: mean, median, most_frequent