code: def transform(self, sequences):
          
          check_iter_of_sequences(sequences, max_iter=3)  # we might be lazy-loading
          sequences_new = []
  
          for X in sequences:
              X = array2d(X)
              if self.means_ is not None:
                  X = X - self.means_
              X_transformed = np.dot(X, self.components_.T)
  
              if self.kinetic_mapping:
                  X_transformed *= self.eigenvalues_
  
              if self.commute_mapping:
                  # thanks to @maxentile and @jchodera for providing/directing to a
                  # reference implementation in pyemma
                  #(markovmodel/PyEMMA#963)
                  # dampening smaller timescales based recommendtion of  [7]
                  #
                  # some timescales are NaNs and regularized timescales will 
                  # be negative when they are less than the lag time; all these
                  # are set to zero using nan_to_num before returning
                  regularized_timescales = 0.5 * self.timescales_ *\
                                           np.tanh( np.pi *((self.timescales_ - self.lag_time)
                                                            /self.lag_time) + 1)
                  X_transformed *= np.sqrt(regularized_timescales / 2)
                  X_transformed = np.nan_to_num(X_transformed)
              sequences_new.append(X_transformed)
  
          return sequences_new
docs: Apply the dimensionality reduction on X.
  
          Parameters
          ----------
          sequences: list of array-like, each of shape (n_samples_i, n_features)
              Training data, where n_samples_i in the number of samples
              in sequence i and n_features is the number of features.
  
          Returns
          -------
          sequence_new : list of array-like, each of shape (n_samples_i, n_components)