code: def main(tmpdir):
      boston = load_boston()
      X, y = shuffle(boston.data, boston.target, random_state=13)
      X = X.astype(np.float32)
      X_train, X_test, y_train, y_test = train_test_split(
          X, y, test_size=0.25, shuffle=False
      )
  
      # Note that the hyperparameter spaces are defined here during the pipeline definition, but it could be already set
      # within the classes ar their definition if using custom classes, or also it could be defined after declaring the
      # pipeline using a flat dict or a nested dict.
  
      p = Pipeline(
          [
              AddFeatures(
                  [
                      SKLearnWrapper(
                          PCA(n_components=2),
                          HyperparameterSpace(
                              {"n_components": RandInt(1, 3)}
                          ),
                      ),
                      SKLearnWrapper(
                          FastICA(n_components=2),
                          HyperparameterSpace(
                              {"n_components": RandInt(1, 3)}
                          ),
                      ),
                  ]
              ),
              ModelStacking(
                  [
                      SKLearnWrapper(
                          GradientBoostingRegressor(),
                          HyperparameterSpace(
                              {
                                  "n_estimators": RandInt(50, 300),
                                  "max_depth": RandInt(1, 4),
                                  "learning_rate": LogUniform(
                                      0.07, 0.7
                                  ),
                              }
                          ),
                      ),
                      SKLearnWrapper(
                          KMeans(),
                          HyperparameterSpace(
                              {"n_clusters": RandInt(5, 10)}
                          ),
                      ),
                  ],
                  joiner=NumpyTranspose(),
                  judge=SKLearnWrapper(
                      Ridge(),
                      HyperparameterSpace(
                          {
                              "alpha": LogUniform(0.7, 1.4),
                              "fit_intercept": Boolean(),
                          }
                      ),
                  ),
              ),
          ]
      )
  
      print("Meta-fitting on train:")
      auto_ml = AutoML(
          p,
          validation_splitter=ValidationSplitter(0.20),
          n_trials=10,
          epochs=1,  # 1 epoch here due to using sklearn models that just fit once.
          callbacks=[
              MetricCallback(
                  "mse",
                  metric_function=mean_squared_error,
                  higher_score_is_better=False,
              )
          ],
      )
  
      fitted_random_search = auto_ml.fit(X_train, y_train)
      print("")
  
      print("Transforming train and test:")
      y_train_predicted = fitted_random_search.predict(X_train)
      y_test_predicted = fitted_random_search.predict(X_test)
  
      print("")
  
      print("Evaluating transformed train:")
      score_transform = r2_score(y_train_predicted, y_train)
      print("R2 regression score:", score_transform)
  
      print("")
  
      print("Evaluating transformed test:")
      score_test = r2_score(y_test_predicted, y_test)
      print("R2 regression score:", score_test)
  
file_path: Neuraxle/examples/sklearn/plot_boston_housing_meta_optimization.py
imports: import numpy
  from sklearn.cluster import KMeans
  from sklearn.datasets import load_boston
  from sklearn.decomposition import PCA, FastICA
  from sklearn.ensemble import GradientBoostingRegressor
  from sklearn.linear_model import Ridge
  from sklearn.metrics import r2_score, mean_squared_error
  from sklearn.model_selection import train_test_split
  from sklearn.utils import shuffle
  from neuraxle.hyperparams.distributions import RandInt, LogUniform, Boolean
  from neuraxle.hyperparams.space import HyperparameterSpace
  from neuraxle.metaopt.auto_ml import AutoML, ValidationSplitter
  from neuraxle.metaopt.callbacks import MetricCallback
  from neuraxle.pipeline import Pipeline
  from neuraxle.steps.numpy import NumpyTranspose
  from neuraxle.steps.sklearn import SKLearnWrapper
  from neuraxle.union import AddFeatures, ModelStacking
label_desc: Use image node_id 1 for calling a global function with example usage: main(tmpdir) without return types