class_docstr: Implements a hyperparameter optimization algorithm.
  
  In a parallel tuning setting, there is only one `Oracle` instance. The
  workers would communicate with the centralized `Oracle` instance with gPRC
  calls to the `Oracle` methods.
  
  `Trial` objects are often used as the communication packet through the gPRC
  calls to pass information between the worker `Tuner` instances and the
  `Oracle`. For example, `Oracle.create_trial()` returns a `Trial` object, and
  `Oracle.end_trial()` accepts a `Trial` in its arguments.
  
  New copies of the same `Trial` instance are reconstructed as it going
  through the gRPC calls. The changes to the `Trial` objects in the worker
  `Tuner`s are synced to the original copy in the `Oracle` when they are
  passed back to the `Oracle` by calling `Oracle.end_trial()`.
  
  Args:
      objective: A string, `keras_tuner.Objective` instance, or a list of
          `keras_tuner.Objective`s and strings. If a string, the direction of
          the optimization (min or max) will be inferred. If a list of
          `keras_tuner.Objective`, we will minimize the sum of all the
          objectives to minimize subtracting the sum of all the objectives to
          maximize. The `objective` argument is optional when
          `Tuner.run_trial()` or `HyperModel.fit()` returns a single float as
          the objective to minimize.
      max_trials: Integer, the total number of trials (model configurations)
          to test at most. Note that the oracle may interrupt the search
          before `max_trial` models have been tested if the search space has
          been exhausted.
      hyperparameters: Optional `HyperParameters` instance. Can be used to
          override (or register in advance) hyperparameters in the search
          space.
      tune_new_entries: Boolean, whether hyperparameter entries that are
          requested by the hypermodel but that were not specified in
          `hyperparameters` should be added to the search space, or not. If
          not, then the default value for these parameters will be used.
          Defaults to True.
      allow_new_entries: Boolean, whether the hypermodel is allowed to
          request hyperparameter entries not listed in `hyperparameters`.
          Defaults to True.
      seed: Int. Random seed.
      max_retries_per_trial: Integer. Defaults to 0. The maximum number of
          times to retry a `Trial` if the trial crashed or the results are
          invalid.
      max_consecutive_failed_trials: Integer. Defaults to 3. The maximum
          number of consecutive failed `Trial`s. When this number is reached,
          the search will be stopped. A `Trial` is marked as failed when none
          of the retries succeeded.
code: def __init__(
      self,
      objective=None,
      max_trials=None,
      hyperparameters=None,
      allow_new_entries=True,
      tune_new_entries=True,
      seed=None,
      max_retries_per_trial=0,
      max_consecutive_failed_trials=3,
  ):
      self.objective = obj_module.create_objective(objective)
      self.max_trials = max_trials
      if not hyperparameters:
          if not tune_new_entries:
              raise ValueError(
                  "If you set `tune_new_entries=False`, you must"
                  "specify the search space via the "
                  "`hyperparameters` argument."
              )
          if not allow_new_entries:
              raise ValueError(
                  "If you set `allow_new_entries=False`, you must"
                  "specify the search space via the "
                  "`hyperparameters` argument."
              )
          self.hyperparameters = hp_module.HyperParameters()
      else:
          self.hyperparameters = hyperparameters
      self.allow_new_entries = allow_new_entries
      self.tune_new_entries = tune_new_entries
  
      # trial_id -> Trial
      self.trials = {}
      # tuner_id -> Trial
      self.ongoing_trials = {}
      # List of trial_ids in the order of the trials start
      self.start_order = []
      # List of trial_ids in the order of the trials end
      self.end_order = []
      # Map trial_id to failed times
      self._run_times = collections.defaultdict(lambda: 0)
      # Used as a queue of trial_id to retry
      self._retry_queue = []
      # Client Tuner IDs
      self.tuner_ids = set()
  
      self.seed = seed or random.randint(1, 10000)
      self._seed_state = self.seed
      # Hashes of values in the trials, which only hashes the active values.
      self._tried_so_far = set()
      # Dictionary mapping trial_id to the the hash of the values.
      self._id_to_hash = collections.defaultdict(lambda: None)
      # Maximum number of identical values that can be generated
      # before we consider the space to be exhausted.
      self._max_collisions = 20
  
      # Set in `BaseTuner` via `set_project_dir`.
      self.directory = None
      self.project_name = None
  
      # In multi-worker mode, only the chief of each cluster should report
      # results. These 2 attributes exist in `Oracle` just make it consistent
      # with `OracleClient`, in which the attributes are utilized.
      self.multi_worker = False
      self.should_report = True
  
      # Handling the retries and failed trials.
      self.max_retries_per_trial = max_retries_per_trial
      self.max_consecutive_failed_trials = max_consecutive_failed_trials
  
      # Print the logs to screen
      self._display = Display(oracle=self)
  
imports: import collections
  import hashlib
  import os
  import random
  import threading
  import warnings
  from datetime import datetime
  import numpy
  from keras_tuner import backend
  from keras_tuner import utils
  from keras_tuner.api_export import keras_tuner_export
  from keras_tuner.engine import hyperparameters
  from keras_tuner.engine import objective
  from keras_tuner.engine import stateful
  from keras_tuner.engine import trial
label_desc: Use image node_id 1 to create a new Oracle object from inherited base classes: stateful with example: obj = Oracle(objective, max_trials, hyperparameters, allow_new_entries, tune_new_entries, seed, max_retries_per_trial, max_consecutive_failed_trials)