class_docstr: Automatic Machine Learning
  
  The Automatic Machine Learning (AutoML) function automates the supervised machine learning model training process.
  It trains several models, cross-validated by default, by using the following available algorithms:
  
  - XGBoost
  - GBM (Gradient Boosting Machine)
  - GLM (Generalized Linear Model)
  - DRF (Distributed Random Forest)
  - XRT (eXtremely Randomized Trees)
  - DeepLearning (Fully Connected Deep Neural Network)
  
  It also applies HPO on the following algorithms:
  
  - XGBoost
  - GBM
  - DeepLearning
  
  In some cases, there will not be enough time to complete all the algorithms, so some may be missing from the
  leaderboard. 
  Finally, AutoML also trains several Stacked Ensemble models at various stages during the run.
  Mainly two kinds of Stacked Ensemble models are trained:
  
  - one of all available models at time t
  - one of only the best models of each kind at time t.
  
  Note that Stacked Ensemble models are trained only if there isn't another stacked ensemble with the same base models.
  
  :examples:
  
  >>> import h2o
  >>> from h2o.automl import H2OAutoML
  >>> h2o.init()
  >>> # Import a sample binary outcome train/test set into H2O
  >>> train = h2o.import_file("https://s3.amazonaws.com/erin-data/higgs/higgs_train_10k.csv")
  >>> test = h2o.import_file("https://s3.amazonaws.com/erin-data/higgs/higgs_test_5k.csv")
  >>> # Identify the response and set of predictors
  >>> y = "response"
  >>> x = list(train.columns)  #if x is defined as all columns except the response, then x is not required
  >>> x.remove(y)
  >>> # For binary classification, response should be a factor
  >>> train[y] = train[y].asfactor()
  >>> test[y] = test[y].asfactor()
  >>> # Run AutoML for 30 seconds
  >>> aml = H2OAutoML(max_runtime_secs = 30)
  >>> aml.train(x = x, y = y, training_frame = train)
  >>> # Print Leaderboard (ranked by xval metrics)
  >>> aml.leaderboard
  >>> # (Optional) Evaluate performance on a test set
  >>> perf = aml.leader.model_performance(test)
  >>> perf.auc()
code: def __validate_algo_parameters(self, algo_parameters):
      if algo_parameters is None:
          return None
      algo_parameters_json = []
      for k, v in algo_parameters.items():
          scope, __, name = k.partition("__")
          if len(name) == 0:
              name, scope = scope, "any"
          value = (
              [dict(key=k, value=v) for k, v in v.items()]
              if isinstance(v, dict)
              else v
          )  # we can't use stringify_dict here as this will be converted into a JSON string
          algo_parameters_json.append(
              dict(scope=scope, name=name, value=value)
          )
      return algo_parameters_json
  
imports: import functools
  from inspect import getdoc
  import re
  import h2o
  from h2o.base import Keyed
  from h2o.estimators import H2OEstimator
  from h2o.exceptions import H2OResponseError, H2OValueError
  from h2o.frame import H2OFrame
  from h2o.job import H2OJob
  from h2o.utils.compatibility import *
  from h2o.utils.shared_utils import check_id
  from h2o.utils.typechecks import assert_is_type, is_type, numeric
  from ._base import H2OAutoMLBaseMixin, _fetch_state
label_desc: Use image node_id 8 for calling the H2OAutoML obj's underlying member method code with example usage: obj.__validate_algo_parameters(algo_parameters) and returns: algo_parameters_json, None