code: def acq_max(
      f_acq, gp, y_max, bounds, space, num_warmup, num_starting_points
  ):
      """
      A function to find the maximum of the acquisition function
  
      It uses a combination of random sampling (cheap) and the 'L-BFGS-B'
      optimization method. First by sampling ``num_warmup`` points at random,
      and then running L-BFGS-B from ``num_starting_points`` random starting points.
  
      Parameters
      ----------
      f_acq : UtilityFunction.utility
          The acquisition function object that return its point-wise value.
  
      gp : GaussianProcessRegressor
          A gaussian process fitted to the relevant data.
  
      y_max : float
          The current maximum known value of the target function.
  
      bounds : numpy array
          The variables bounds to limit the search of the acq max.
  
      num_warmup : int
          number of times to randomly sample the aquisition function
  
      num_starting_points : int
          number of times to run scipy.minimize
  
      Returns
      -------
      numpy array
          The parameter which achieves max of the acquisition function.
      """
  
      # Warm up with random points
      x_tries = [space.random_sample() for _ in range(int(num_warmup))]
      ys = f_acq(x_tries, gp=gp, y_max=y_max)
      x_max = x_tries[ys.argmax()]
      max_acq = ys.max()
  
      # Explore the parameter space more throughly
      x_seeds = [
          space.random_sample() for _ in range(int(num_starting_points))
      ]
  
      bounds_minmax = np.array(
          [
              [
                  bound["_value"][0],
                  bound["_value"][
                      1
                      if bound["_type"] == "quniform"
                      or bound["_type"] == "qloguniform"
                      else -1
                  ],
              ]
              for bound in bounds
          ]
      )
  
      for x_try in x_seeds:
          # Find the minimum of minus the acquisition function
          res = minimize(
              lambda x: -f_acq(x.reshape(1, -1), gp=gp, y_max=y_max),
              x_try.reshape(1, -1),
              bounds=bounds_minmax,
              method="L-BFGS-B",
          )
  
          # See if success
          if not res.success:
              continue
  
          # Store it if better than previous minimum(maximum).
          if max_acq is None or -res.fun[0] >= max_acq:
              x_max = _match_val_type(res.x, bounds)
              max_acq = -res.fun[0]
  
      # Clip output to make sure it lies within the bounds. Due to floating
      # point technicalities this is not always the case.
      return np.clip(x_max, bounds_minmax[:, 0], bounds_minmax[:, 1])
  
file_path: nni/nni/algorithms/hpo/gp_tuner/util.py
imports: import warnings
  import numpy
  from scipy.stats import norm
  from scipy.optimize import minimize
label_desc: Use image node_id 2 for calling a global function with example usage: acq_max(f_acq, gp, y_max, bounds, space, num_warmup, num_starting_points) and returns: np