code: def fmin(
      fn,
      space,
      algo,
      max_evals,
      trials=None,
      rstate=None,
      allow_trials_fmin=True,
      pass_expr_memo_ctrl=None,
      catch_eval_exceptions=False,
      verbose=0,
      return_argmin=True,
      points_to_evaluate=None,
  ):
      """Minimize a function over a hyperparameter space.
  
      More realistically: *explore* a function over a hyperparameter space
      according to a given algorithm, allowing up to a certain number of
      function evaluations.  As points are explored, they are accumulated in
      `trials`
  
  
      Parameters
      ----------
  
      fn : callable (trial point -> loss)
          This function will be called with a value generated from `space`
          as the first and possibly only argument.  It can return either
          a scalar-valued loss, or a dictionary.  A returned dictionary must
          contain a 'status' key with a value from `STATUS_STRINGS`, must
          contain a 'loss' key if the status is `STATUS_OK`. Particular
          optimization algorithms may look for other keys as well.  An
          optional sub-dictionary associated with an 'attachments' key will
          be removed by fmin its contents will be available via
          `trials.trial_attachments`. The rest (usually all) of the returned
          dictionary will be stored and available later as some 'result'
          sub-dictionary within `trials.trials`.
  
      space : hyperopt.pyll.Apply node
          The set of possible arguments to `fn` is the set of objects
          that could be created with non-zero probability by drawing randomly
          from this stochastic program involving involving hp_<xxx> nodes
          (see `hyperopt.hp` and `hyperopt.pyll_utils`).
  
      algo : search algorithm
          This object, such as `hyperopt.rand.suggest` and
          `hyperopt.tpe.suggest` provides logic for sequential search of the
          hyperparameter space.
  
      max_evals : int
          Allow up to this many function evaluations before returning.
  
      trials : None or base.Trials (or subclass)
          Storage for completed, ongoing, and scheduled evaluation points.  If
          None, then a temporary `base.Trials` instance will be created.  If
          a trials object, then that trials object will be affected by
          side-effect of this call.
  
      rstate : numpy.RandomState, default numpy.random or `$HYPEROPT_FMIN_SEED`
          Each call to `algo` requires a seed value, which should be different
          on each call. This object is used to draw these seeds via `randint`.
          The default rstate is
          `numpy.random.RandomState(int(env['HYPEROPT_FMIN_SEED']))`
          if the `HYPEROPT_FMIN_SEED` environment variable is set to a non-empty
          string, otherwise np.random is used in whatever state it is in.
  
      verbose : int
          Print out some information to stdout during search.
  
      allow_trials_fmin : bool, default True
          If the `trials` argument
  
      pass_expr_memo_ctrl : bool, default False
          If set to True, `fn` will be called in a different more low-level
          way: it will receive raw hyperparameters, a partially-populated
          `memo`, and a Ctrl object for communication with this Trials
          object.
  
      return_argmin : bool, default True
          If set to False, this function returns nothing, which can be useful
          for example if it is expected that `len(trials)` may be zero after
          fmin, and therefore `trials.argmin` would be undefined.
  
      points_to_evaluate : list, default None
          Only works if trials=None. If points_to_evaluate equals None then the
          trials are evaluated normally. If list of dicts is passed then
          given points are evaluated before optimisation starts, so the overall
          number of optimisation steps is len(points_to_evaluate) + max_evals.
          Elements of this list must be in a form of a dictionary with variable
          names as keys and variable values as dict values. Example
          points_to_evaluate value is [{'x': 0.0, 'y': 0.0}, {'x': 1.0, 'y': 2.0}]
  
      Returns
      -------
  
      argmin : None or dictionary
          If `return_argmin` is False, this function returns nothing.
          Otherwise, it returns `trials.argmin`.  This argmin can be converted
          to a point in the configuration space by calling
          `hyperopt.space_eval(space, best_vals)`.
  
  
      """
      if rstate is None:
          env_rseed = os.environ.get("HYPEROPT_FMIN_SEED", "")
          if env_rseed:
              rstate = np.random.RandomState(int(env_rseed))
          else:
              rstate = np.random.RandomState()
  
      if allow_trials_fmin and hasattr(trials, "fmin"):
          return trials.fmin(
              fn,
              space,
              algo=algo,
              max_evals=max_evals,
              rstate=rstate,
              pass_expr_memo_ctrl=pass_expr_memo_ctrl,
              verbose=verbose,
              catch_eval_exceptions=catch_eval_exceptions,
              return_argmin=return_argmin,
          )
  
      if trials is None:
          if points_to_evaluate is None:
              trials = base.Trials()
          else:
              assert type(points_to_evaluate) == list
              trials = generate_trials_to_calculate(points_to_evaluate)
  
      domain = base.Domain(
          fn, space, pass_expr_memo_ctrl=pass_expr_memo_ctrl
      )
  
      rval = FMinIter(
          algo,
          domain,
          trials,
          max_evals=max_evals,
          rstate=rstate,
          verbose=verbose,
      )
      rval.catch_eval_exceptions = catch_eval_exceptions
      rval.exhaust()
      if return_argmin:
          return trials.argmin
  
imports: from __future__ import print_function
  from __future__ import absolute_import
  from future import standard_library
  from builtins import str
  from builtins import object
  import functools
  import logging
  import os
  import sys
  import time
  import numpy
  from .None import pyll
  from .utils import coarse_utcnow
  from .None import base
label_desc: Use image node_id 5 for calling a global function with example usage: fmin(fn, space, algo, max_evals, trials, rstate, allow_trials_fmin, pass_expr_memo_ctrl, catch_eval_exceptions, verbose, return_argmin, points_to_evaluate) and returns: trials, trials