Method start_training

rlkit/core/base_algorithm.py:162–287

(self, start_epoch=0)

        pass

    def start_training(self, start_epoch=0):
        # self._current_path_builder = PathBuilder()
        self.ready_env_ids = np.arange(self.env_num)
        observations = self._start_new_rollout(
            self.ready_env_ids
        )  # Do it for support vec env

        self._current_path_builder = [
            PathBuilder() for _ in range(len(self.ready_env_ids))
        ]

        for epoch in gt.timed_for(
            range(start_epoch, self.num_epochs),
            save_itrs=True,
        ):
            self._start_epoch(epoch)
            total_rews = np.array([0.0 for _ in range(len(self.ready_env_ids))])
            for steps_this_epoch in range(self.num_env_steps_per_epoch // self.env_num):
                actions = self._get_action_and_info(observations)

                if type(actions) is tuple:
                    actions = actions[0]

                if self.render:
                    self.training_env.render()

                next_obs, raw_rewards, terminals, env_infos = self.training_env.step(
                    actions, self.ready_env_ids
                )
                if self.no_terminal:
                    terminals = [False for _ in range(len(self.ready_env_ids))]
                # self._n_env_steps_total += 1
                self._n_env_steps_total += len(self.ready_env_ids)

                rewards = raw_rewards
                total_rews += raw_rewards

                self._handle_vec_step(
                    observations,
                    actions,
                    rewards,
                    next_obs,
                    np.array([False for _ in range(len(self.ready_env_ids))])
                    if self.no_terminal
                    else terminals,
                    absorbings=[
                        np.array([0.0, 0.0]) for _ in range(len(self.ready_env_ids))
                    ],
                    env_infos=env_infos,
                )
                if np.any(terminals):
                    env_ind_local = np.where(terminals)[0]
                    total_rews[env_ind_local] = 0.0
                    if self.wrap_absorbing:
                        # raise NotImplementedError()
                        """
                        If we wrap absorbing states, two additional
                        transitions must be added: (s_T, s_abs) and