Method run

hyperopt/fmin.py:228–346

Run `self.algo` iteratively (use existing `self.trials` to produce the new ones), update, and repeat block_until_done means that the process blocks until ALL jobs in trials are not in running or new state

(self, N, block_until_done=True)

            self.serial_evaluate()

    def run(self, N, block_until_done=True):
        """
        Run `self.algo` iteratively (use existing `self.trials` to produce the new
        ones), update, and repeat
        block_until_done  means that the process blocks until ALL jobs in
        trials are not in running or new state

        """
        trials = self.trials
        algo = self.algo
        n_queued = 0

        def get_queue_len():
            return self.trials.count_by_state_unsynced(base.JOB_STATE_NEW)

        def get_n_done():
            return self.trials.count_by_state_unsynced(base.JOB_STATE_DONE)

        def get_n_unfinished():
            unfinished_states = [base.JOB_STATE_NEW, base.JOB_STATE_RUNNING]
            return self.trials.count_by_state_unsynced(unfinished_states)

        stopped = False
        initial_n_done = get_n_done()
        with self.progress_callback(
            initial=initial_n_done, total=self.max_evals
        ) as progress_ctx:

            all_trials_complete = False
            best_loss = float("inf")
            while (
                # more run to Q     || ( block_flag & trials not done )
                (n_queued < N or (block_until_done and not all_trials_complete))
                # no timeout        || < current last time
                and (self.timeout is None or (timer() - self.start_time) < self.timeout)
                # no loss_threshold || < current best_loss
                and (self.loss_threshold is None or best_loss >= self.loss_threshold)
            ):
                qlen = get_queue_len()
                while (
                    qlen < self.max_queue_len and n_queued < N and not self.is_cancelled
                ):
                    n_to_enqueue = min(self.max_queue_len - qlen, N - n_queued)
                    # get ids for next trials to enqueue
                    new_ids = trials.new_trial_ids(n_to_enqueue)
                    self.trials.refresh()
                    # Based on existing trials and the domain, use `algo` to probe in
                    # new hp points. Save the results of those inspections into
                    # `new_trials`. This is the core of `run`, all the rest is just
                    # processes orchestration
                    new_trials = algo(
                        new_ids, self.domain, trials, self.rstate.integers(2 ** 31 - 1)
                    )
                    assert len(new_ids) >= len(new_trials)

                    if len(new_trials):
                        self.trials.insert_trial_docs(new_trials)
                        self.trials.refresh()