code: def test_prepare_normalization_and_normalize(self) -> None:
      feature_value_map = read_data()
  
      normalization_parameters = {}
      for name, values in feature_value_map.items():
          normalization_parameters[
              name
          ] = normalization.identify_parameter(
              name,
              values,
              10,
              feature_type=self._feature_type_override(name),
          )
      for k, v in normalization_parameters.items():
          if id_to_type(k) == CONTINUOUS:
              self.assertEqual(v.feature_type, CONTINUOUS)
              self.assertIs(v.boxcox_lambda, None)
              self.assertIs(v.boxcox_shift, None)
          elif id_to_type(k) == BOXCOX:
              self.assertEqual(v.feature_type, BOXCOX)
              self.assertIsNot(v.boxcox_lambda, None)
              self.assertIsNot(v.boxcox_shift, None)
          elif id_to_type(k) == DO_NOT_PREPROCESS:
              self.assertEqual(v.feature_type, CONTINUOUS)
              self.assertIs(v.boxcox_lambda, None)
              self.assertIs(v.boxcox_shift, 0)
              self.assertIs(v.min_value, None)
              self.assertIs(v.max_value, None)
          else:
              assert v.feature_type == id_to_type(k)
  
      preprocessor = Preprocessor(normalization_parameters, False)
      sorted_features, _ = sort_features_by_normalization(
          normalization_parameters
      )
      input_matrix = torch.zeros([10000, len(sorted_features)])
      for i, feature in enumerate(sorted_features):
          input_matrix[:, i] = torch.from_numpy(
              feature_value_map[feature]
          )
      normalized_feature_matrix = preprocessor(
          input_matrix, (input_matrix != MISSING_VALUE)
      )
  
      normalized_features = {}
      on_column = 0
      for feature in sorted_features:
          norm = normalization_parameters[feature]
          if norm.feature_type == ENUM:
              column_size = len(norm.possible_values)
          else:
              column_size = 1
          normalized_features[feature] = normalized_feature_matrix[
              :, on_column : (on_column + column_size)
          ]
          on_column += column_size
  
      self.assertTrue(
          all(
              [
                  np.isfinite(parameter.stddev)
                  and np.isfinite(parameter.mean)
                  for parameter in normalization_parameters.values()
              ]
          )
      )
      for k, v in six.iteritems(normalized_features):
          v = v.numpy()
          self.assertTrue(np.all(np.isfinite(v)))
          feature_type = normalization_parameters[k].feature_type
          if feature_type == identify_types.PROBABILITY:
              sigmoidv = special.expit(v)
              self.assertTrue(
                  np.all(
                      np.logical_and(
                          np.greater(sigmoidv, 0), np.less(sigmoidv, 1)
                      )
                  )
              )
          elif feature_type == identify_types.ENUM:
              possible_values = normalization_parameters[
                  k
              ].possible_values
              self.assertEqual(v.shape[0], len(feature_value_map[k]))
              self.assertEqual(v.shape[1], len(possible_values))
  
              possible_value_map = {}
              for i, possible_value in enumerate(possible_values):
                  possible_value_map[possible_value] = i
  
              for i, row in enumerate(v):
                  original_feature = feature_value_map[k][i]
                  if abs(original_feature - MISSING_VALUE) < 0.01:
                      self.assertEqual(0.0, np.sum(row))
                  else:
                      self.assertEqual(
                          possible_value_map[original_feature],
                          np.where(row == 1)[0][0],
                      )
          elif feature_type == identify_types.QUANTILE:
              for i, feature in enumerate(v[0]):
                  original_feature = feature_value_map[k][i]
                  expected = NumpyFeatureProcessor.value_to_quantile(
                      original_feature,
                      normalization_parameters[k].quantiles,
                  )
                  self.assertAlmostEqual(feature, expected, 2)
          elif feature_type == identify_types.BINARY:
              pass
          elif (
              feature_type == identify_types.CONTINUOUS
              or feature_type == identify_types.BOXCOX
          ):
              one_stddev = np.isclose(np.std(v, ddof=1), 1, atol=0.01)
              zero_stddev = np.isclose(np.std(v, ddof=1), 0, atol=0.01)
              zero_mean = np.isclose(np.mean(v), 0, atol=0.01)
              self.assertTrue(
                  np.all(zero_mean),
                  "mean of feature {} is {}, not 0".format(
                      k, np.mean(v)
                  ),
              )
              self.assertTrue(
                  np.all(np.logical_or(one_stddev, zero_stddev))
              )
          elif feature_type == identify_types.CONTINUOUS_ACTION:
              less_than_max = v < 1
              more_than_min = v > -1
              self.assertTrue(
                  np.all(less_than_max),
                  "values are not less than 1: {}".format(
                      v[less_than_max == False]
                  ),
              )
              self.assertTrue(
                  np.all(more_than_min),
                  "values are not more than -1: {}".format(
                      v[more_than_min == False]
                  ),
              )
          else:
              raise NotImplementedError()
  
imports: import unittest
  import numpy
  import numpy.testing
  import six
  import torch
  from reagent.preprocessing import identify_types, normalization, transforms
  from reagent.preprocessing.identify_types import BOXCOX, CONTINUOUS, DO_NOT_PREPROCESS, ENUM
  from reagent.preprocessing.normalization import MISSING_VALUE, NormalizationParameters, sort_features_by_normalization
  from reagent.preprocessing.preprocessor import Preprocessor
  from reagent.test.base.utils import NumpyFeatureProcessor
  from reagent.test.preprocessing.preprocessing_util import BOXCOX_FEATURE_ID, CONTINUOUS_FEATURE_ID, CONTINUOUS_SMALL_FEATURE_ID, ENUM_FEATURE_ID, id_to_type, PROBABILITY_FEATURE_ID, read_data
  from scipy import special
label_desc: Use image node_id 2 for calling the TestPreprocessing obj's underlying member method code with example usage: obj.test_prepare_normalization_and_normalize() without return types