class_docstr: Base class for H2O Estimators.
  
  H2O Estimators implement the following methods for model construction:
  
      - ``start()`` - Top-level user-facing API for asynchronous model build
      - ``join()``  - Top-level user-facing API for blocking on async model build
      - ``train()`` - Top-level user-facing API for model building.
      - ``fit()`` - Used by scikit-learn.
  
  Because H2OEstimator instances are instances of ModelBase, these objects can use the H2O model API.
code: def _resolve_model(self, model_id, model_json):
      (
          metrics_class,
          model_class,
          metrics_class_valid,
      ) = H2OEstimator._metrics_class(model_json)
      m = model_class() if model_class else self._model
      m._id = model_id
      m._model_json = model_json
      m._have_pojo = model_json.get("have_pojo", True)
      m._have_mojo = model_json.get("have_mojo", True)
      m._start_time = model_json.get("output", {}).get(
          "start_time", None
      )
      m._end_time = model_json.get("output", {}).get("end_time", None)
      m._run_time = model_json.get("output", {}).get("run_time", None)
      m._metrics_class = metrics_class
      m._metrics_class_valid = metrics_class_valid
      m._parms = self._parms
      m._estimator_type = self._estimator_type
      m._options_ = self._options_
  
      if (
          model_id is not None
          and model_json is not None
          and metrics_class is not None
      ):
          # build Metric objects out of each metrics
          for metric in [
              "training_metrics",
              "validation_metrics",
              "cross_validation_metrics",
          ]:
              metrics = model_json["output"].get(metric, None)
              if metrics is not None:
                  if metric == "cross_validation_metrics":
                      m._is_xvalidated = True
                  mc = (
                      metrics_class_valid
                      if metric == "validation_metrics"
                      else metrics_class
                  )
                  # fixme: never ever ever modify the original payload!!! put the metric object somewhere else
                  model_json["output"][metric] = mc(
                      metrics, metric, model_json["algo"]
                  )
          # if m._is_xvalidated:
          if (
              m._is_xvalidated
              and model_json["output"]["cross_validation_models"]
              is not None
          ):
              m._xval_keys = [
                  i["name"]
                  for i in model_json["output"][
                      "cross_validation_models"
                  ]
              ]
  
          # build a useful dict of the params
          for p in m._model_json["parameters"]:
              m.parms[p["name"]] = p
  
      extensions = [
          load_ext(ext)
          for ext in self._options_.get("model_extensions", [])
      ]
      mixin(self._model, model_class, *extensions)
      assign(self._model, m)
  
imports: from h2o.utils.compatibility import *
  from datetime import datetime
  import inspect
  import warnings
  import h2o
  from h2o.base import Keyed
  from h2o.exceptions import H2OValueError, H2OResponseError
  from h2o.frame import H2OFrame
  from h2o.job import H2OJob
  from h2o.utils.mixin import assign, load_ext, mixin
  from h2o.utils.shared_utils import quoted, LookupSeq
  from h2o.utils.typechecks import assert_is_type, is_type, numeric, FunctionType
  from h2o.model import ModelBase, H2OSegmentModels
  from h2o.model.models import *
  from h2o.model.metrics import *
label_desc: Use image node_id 11 for calling the H2OEstimator obj's underlying member method code with example usage: obj._resolve_model(model_id, model_json) without return types