content: import numpy as np
  import pandas as pd
  from sklearn.preprocessing import MinMaxScaler, StandardScaler
  
  
  class data_scaler(object):
      def __init__(self):
          self.norm = None
          self.norm_1 = None
          self.std = None
          self.case = None
          self.scale = 1
          self.bias = 1e-20
          #         self.bias = 1
  
          self.switcher = {
              'min_std': 'min_std',
              'std2': 'std2',
              'std_min': 'std_min',
              'min': 'min',
              'no': 'no',
              'log': 'log',
              'log_min': 'log_min',
              'log2': 'log2',
              'tan': 'tan'
          }
  
      def fit_transform(self, input_data, case):
          self.case = case
          if self.switcher.get(self.case) == 'min_std':
              self.norm = MinMaxScaler()
              self.std = StandardScaler()
              out = self.norm.fit_transform(input_data)
              out = self.std.fit_transform(out)
  
          if self.switcher.get(self.case) == 'std2':
              self.std = StandardScaler()
              out = self.std.fit_transform(input_data)
  
          if self.switcher.get(self.case) == 'std_min':
              self.norm = MinMaxScaler()
              self.std = StandardScaler()
              out = self.std.fit_transform(input_data)
              out = self.norm.fit_transform(out)
  
          if self.switcher.get(self.case) == 'min':
              self.norm = MinMaxScaler()
              out = self.norm.fit_transform(input_data)
  
          if self.switcher.get(self.case) == 'no':
              self.norm = MinMaxScaler()
              self.std = StandardScaler()
              out = input_data
  
          if self.switcher.get(self.case) == 'log':
              out = - np.log(np.asarray(input_data / self.scale) + self.bias)
              self.std = StandardScaler()
              out = self.std.fit_transform(out)
  
          if self.switcher.get(self.case) == 'log_min':
              out = - np.log(np.asarray(input_data / self.scale) + self.bias)
              self.norm = MinMaxScaler()
              out = self.norm.fit_transform(out)
  
          if self.switcher.get(self.case) == 'log2':
              self.norm = MinMaxScaler()
              self.norm_1 = MinMaxScaler()
              out = self.norm.fit_transform(input_data)
              out = np.log(np.asarray(out) + self.bias)
              out = self.norm_1.fit_transform(out)
  
          if self.switcher.get(self.case) == 'tan':
              self.norm = MaxAbsScaler()
              self.std = StandardScaler()
              out = self.std.fit_transform(input_data)
              out = self.norm.fit_transform(out)
              out = np.tan(out / (2 * np.pi + self.bias))
  
          return out
  
      def transform(self, input_data):
          if self.switcher.get(self.case) == 'min_std':
              out = self.norm.transform(input_data)
              out = self.std.transform(out)
  
          if self.switcher.get(self.case) == 'std2':
              out = self.std.transform(input_data)
  
          if self.switcher.get(self.case) == 'std_min':
              out = self.std.transform(input_data)
              out = self.norm.transform(out)
  
          if self.switcher.get(self.case) == 'min':
              out = self.norm.transform(input_data)
  
          if self.switcher.get(self.case) == 'no':
              out = input_data
  
          if self.switcher.get(self.case) == 'log':
              out = - np.log(np.asarray(input_data / self.scale) + self.bias)
              out = self.std.transform(out)
  
          if self.switcher.get(self.case) == 'log_min':
              out = - np.log(np.asarray(input_data / self.scale) + self.bias)
              out = self.norm.transform(out)
  
          if self.switcher.get(self.case) == 'log2':
              out = self.norm.transform(input_data)
              out = np.log(np.asarray(out) + self.bias)
              out = self.norm_1.transform(out)
  
          if self.switcher.get(self.case) == 'tan':
              out = self.std.transform(input_data)
              out = self.norm.transform(out)
              out = np.tan(out / (2 * np.pi + self.bias))
  
          return out
  
      def inverse_transform(self, input_data):
  
          if self.switcher.get(self.case) == 'min_std':
              out = self.std.inverse_transform(input_data)
              out = self.norm.inverse_transform(out)
  
          if self.switcher.get(self.case) == 'std2':
              out = self.std.inverse_transform(input_data)
  
          if self.switcher.get(self.case) == 'std_min':
              out = self.norm.inverse_transform(input_data)
              out = self.std.inverse_transform(out)
  
          if self.switcher.get(self.case) == 'min':
              out = self.norm.inverse_transform(input_data)
  
          if self.switcher.get(self.case) == 'no':
              out = input_data
  
          if self.switcher.get(self.case) == 'log':
              out = self.std.inverse_transform(input_data)
              out = (np.exp(-out) - self.bias) * self.scale
  
          if self.switcher.get(self.case) == 'log_min':
              out = self.norm.inverse_transform(input_data)
              out = (np.exp(-out) - self.bias) * self.scale
  
          if self.switcher.get(self.case) == 'log2':
              out = self.norm_1.inverse_transform(input_data)
              out = np.exp(out) - self.bias
              out = self.norm.inverse_transform(out)
  
          if self.switcher.get(self.case) == 'tan':
              out = (2 * np.pi + self.bias) * np.arctan(input_data)
              out = self.norm.inverse_transform(out)
              out = self.std.inverse_transform(out)
  
          return out
  
  
  def read_h5_data(fileName, input_features, labels):
      df = pd.read_hdf(fileName)
      df = df[df['f'] < 0.45]
  
      input_df = df[input_features]
      in_scaler = data_scaler()
      input_np = in_scaler.fit_transform(input_df.values, 'no')
  
      label_df = df[labels].clip(0)
      #     if 'PVs' in labels:
      #       label_df['PVs']=np.log(label_df['PVs']+1)
      out_scaler = data_scaler()
      label_np = out_scaler.fit_transform(label_df.values, 'std2')
  
      return input_np, label_np, df, in_scaler, out_scaler