code: def _partial_fit(model_and_meta, X, y, fit_params):
      
      with log_errors():
          start = time()
          model, meta = model_and_meta
  
          if len(X):
              model = deepcopy(model)
              model.partial_fit(X, y, **(fit_params or {}))
  
          meta = dict(meta)
          meta["partial_fit_calls"] += 1
          meta["partial_fit_time"] = time() - start
  
          return model, meta
docs: Call partial_fit on a classifiers with training data X and y
  
      Arguments
      ---------
      model_and_meta : Tuple[Estimator, dict]
      X, y : np.ndarray, np.ndarray
          Training data
      fit_params : dict
          Extra keyword arguments to pass to partial_fit
  
      Returns
      -------
      Results
          A namedtuple with four fields: info, models, history, best
  
          * info : Dict[model_id, List[Dict]]
              Keys are integers identifying each model. Values are a
              List of Dict
          * models : Dict[model_id, Future[Estimator]]
              A dictionary with the same keys as `info`. The values
              are futures to the fitted models.
          * history : List[Dict]
              The history of model fitting for each model. Each element
              of the list is a dictionary with the following elements:
  
              * model_id : int
                  A superset of the keys for `info` and `models`.
              * params : Dict[str, Any]
                  Parameters this model was trained with.
              * partial_fit_calls : int
                  The number of *consecutive* partial fit calls at this stage in
                  this models training history.
              * partial_fit_time : float
                  Time (in seconds) spent on this partial fit
              * score : float
                  Score on the test set for the model at this point in history
              * score_time : float
                  Time (in seconds) spent on this scoring.
          * best : Tuple[model_id, Future[Estimator]]]
              The estimator with the highest validation score in the final
              round.