docs: def minimize(self, model, session=None, var_list=None, feed_dict=None,
                   maxiter=1000, initialize=False, anchor=True, step_callback=None, **kwargs):
          """
          Minimizes objective function of the model.
  
          :param model: GPflow model with objective tensor.
          :param session: Session where optimization will be run.
          :param var_list: List of extra variables which should be trained during optimization.
          :param feed_dict: Feed dictionary of tensors passed to session run method.
          :param maxiter: Number of run interation.
          :param initialize: If `True` model parameters will be re-initialized even if they were
              initialized before for gotten session.
          :param anchor: If `True` trained variable values computed during optimization at
              particular session will be synchronized with internal parameter values.
          :param step_callback: A callback function to execute at each optimization step.
              The callback should accept variable argument list, where first argument is
              optimization step number.
          :type step_callback: Callable[[], None]
          :param kwargs: This is a dictionary of extra parameters for session run method.
          """
  
          if model is None or not isinstance(model, Model):
              raise ValueError('The `model` argument must be a GPflow model.')
  
          opt = self.make_optimize_action(model,
              session=session,
              var_list=var_list,
              feed_dict=feed_dict, **kwargs)
  
          self._model = opt.model
          self._minimize_operation = opt.optimizer_tensor
  
          session = model.enquire_session(session)
          with session.as_default():
              for step in range(maxiter):
                  opt()
                  if step_callback is not None:
                      step_callback(step)
  
          if anchor:
              opt.model.anchor(session)