data/psltl/learner/learning_param.py

from typing import List, Dict
import torch as th
from stable_baselines3.common.utils import get_linear_fn


class GridWorldLearningParams:
    def __init__(
        self,
        # algorithm related
        algo_name: str = "dqn", 
        policy_kwargs: Dict[str, List[int]] = {"net_arch": [], "with_bias": False, "optimizer_class": th.optim.SGD}, # first 4 is embedding layer
        learning_starts: int = 1,
        train_freq: int = 1,
        gradient_steps: int = 1,
        target_update_interval: int = 1,
        buffer_size: int = 50000,
        batch_size: int = 32,
        max_grad_norm: float = 1, 
        # exploration related
        exploration_fraction: float = 0.8,
        exploration_initial_eps: float = 0.2,
        exploration_final_eps: float = 0.1,
        # learning related
        learning_rate_start: float = 1e-1,
        learning_rate_end: float = 1e-5,
        learning_fraction: float = 0.4, 
        # reward function related
        use_adrs: List[bool] = [False,],
        reward_types: list = ["progress", "hybrid", "distance"],
        adrs_mu: float = 0.5,
        adrs_update: int = 10000,
        theta = "dist",
        hybrid_eta: float = 0.001,
        version: int = 1, 
        # env related
        episode_step: int = int(1e2),
        env_name: str = "office",
        gamma: float = 0.9,
        vector: bool = False,
        node_embedding: bool = False,
        use_one_hot: bool = False,
        use_noise: bool = False,
        noise_level: float = 0,
        map_size: int = 1,
        map_id: int = 0,
        violation_end: bool = False, 
        missing: bool = False,
        human: bool = False,
        # training related
        total_timesteps: int = int(1e4),
        total_run: int = 6,
        seed: int = 0,
        # evaluation related
        eval_freq: int = 100,
        rolling: int = 20,
        init_qs: dict = {"distance": 2, "hybrid": 2, "progress": 2},
        save: bool = True,
        # counter factual exp
        cf: bool = False,
    ):
        # reward shaping related
        self.reward_types = reward_types
        self.use_adrs = use_adrs
        self.adrs_update = adrs_update
        self.adrs_mu = adrs_mu
        self.hybrid_eta = hybrid_eta

        # evaluation related
        self.eval_freq = eval_freq
        self.rolling = rolling # rolling window size for evaluation

        # environment related
        self.episode_step = episode_step
        self.use_one_hot = use_one_hot
        self.env_name = env_name
        self.gamma = gamma
        self.vector = vector # use vector representation for state space
        self.node_embedding = node_embedding
        self.use_noise = use_noise
        self.noise_level = noise_level
        self.map_size = map_size
        self.map_id = map_id
        self.seed = seed
        self.violation_end = violation_end
        self.missing = missing
        self.human = human
        self.theta = theta
        self.version = version
        
        # exploration related
        self.exploration_initial_eps = exploration_initial_eps
        self.exploration_fraction = exploration_fraction
        self.exploration_final_eps = exploration_final_eps

        # learning related
        self.gamma = gamma
        self.learning_rate_start = learning_rate_start
        self.learning_rate_end = learning_rate_end
        self.learning_fraction = learning_fraction

        # total run and timesteps
        self.total_run = total_run
        self.total_timesteps = total_timesteps

        # algorithm setup related
        self.algo_name = algo_name
        self.policy_kwargs = policy_kwargs
        self.buffer_size = buffer_size
        self.batch_size = batch_size

        # algorithm learning related
        self.max_grad_norm = max_grad_norm
        self.train_freq = train_freq
        self.learning_starts = learning_starts
        self.gradient_steps = gradient_steps
        self.target_update_interval = target_update_interval
        self.init_qs = init_qs
        self.cf = cf
        self.save = save

        self.set_learning_rate()

    def set_learning_rate(self):
        self.learning_rate = get_linear_fn(self.learning_rate_start, self.learning_rate_end, self.learning_fraction)

    def print_infos(self):
        print("=" * 75)

        print("Env: ", self.env_name)
        print("Learning rate: ", self.learning_rate)
        print("Exploration final eps: ", self.exploration_final_eps)
        print("Gamma: ", self.gamma)
        print("Total Timesteps: ", self.total_timesteps)
        print("Total Runs: ", self.total_run)
        print("Reward Types: ", self.reward_types)
        print("Usage of Adaptive Reward Shaping: ", self.use_adrs)
        if True in self.use_adrs:
            print("Adaptive Reward Shaping Gamma: ", self.hybrid_eta)
        print("Epsiode End Step: ", self.episode_step)
        print("Buffer Size: ", self.buffer_size)
        print("Train Frequency: ", self.train_freq)
        print("Batch Size: ", self.batch_size)

        print("=" * 75)

    def model_params(self, algo_name):
        assert algo_name in ["dqn", "ddqn"]
        # for grid world example, we use linear dqn structure as default
        if algo_name == "dqn" or algo_name == "ddqn":
            params = {
                "policy_kwargs": self.policy_kwargs,
                "tensorboard_log": None,
                "gamma": self.gamma,
                "learning_rate": self.learning_rate,
                "train_freq": self.train_freq,
                "batch_size": self.batch_size,
                "buffer_size": self.buffer_size,
                "learning_starts": self.learning_starts,
                "gradient_steps": self.gradient_steps,
                "target_update_interval": self.target_update_interval,
                "exploration_initial_eps": self.exploration_initial_eps,
                "exploration_fraction": self.exploration_fraction,
                "exploration_final_eps": self.exploration_final_eps,
                "max_grad_norm": self.max_grad_norm,
            }
            
        return params


class ContiWorldLearningParams(GridWorldLearningParams):
    def __init__(
        self,
        algo_name: str = "dqn", 
        policy_kwargs: Dict[str, List[int]] = {"net_arch": [256, 256]}, # first 4 is embedding layer
        learning_starts: int = 1,
        train_freq: int = 1,
        gradient_steps: int = 1,
        target_update_interval: int = 1,
        buffer_size: int = 50000,
        batch_size: int = 32,
        max_grad_norm: float = 1, 
        # exploration related
        exploration_fraction: float = 0.8,
        exploration_initial_eps: float = 0.2,
        exploration_final_eps: float = 0.1,
        # learning related
        learning_rate_start: float = 1e-1,
        learning_rate_end: float = 1e-5,
        learning_fraction: float = 0.4, 
        # reward function related
        theta = "dist", 
        use_adrs: List[bool] = [False,],
        reward_types: list = ["progress", "hybrid", "distance"],
        adrs_update: int = 1000,
        adrs_mu: float = 0.5, 
        hybrid_eta: float = 0.001,
        version: int = 1, 
        # env related
        episode_step: int = int(1e3),
        env_name: str = "water",
        gamma: float = 0.9,
        vector: bool = False,
        node_embedding: bool = False,
        use_one_hot: bool = False,
        use_noise: bool = False,
        noise_level: float = 0,
        map_size: int = 1,
        map_id: int = 1,
        violation_end: bool = False,
        missing: bool = False,
        human: bool = False,
        # training related
        total_timesteps: int = int(1e4),
        total_run: int = 6,
        seed: int = 0,
        # evaluation related
        eval_freq: int = 100,
        rolling: int = 20,
        init_qs: dict = {"distance": 2, "hybrid": 2, "progress": 2},
        save: bool = True,
        cf: bool = False,
        # on-policy method
        n_steps: int = 2048,
        ent_coef: float = 1e-3,
        tau: float = 5e-3, 
    ):
        super().__init__(
            algo_name=algo_name, 
            policy_kwargs=policy_kwargs,
            learning_starts=learning_starts,
            train_freq=train_freq,
            gradient_steps=gradient_steps,
            target_update_interval=target_update_interval,
            buffer_size=buffer_size,
            batch_size=batch_size,
            max_grad_norm=max_grad_norm, 
            # exploration related
            exploration_fraction=exploration_fraction,
            exploration_initial_eps=exploration_initial_eps,
            exploration_final_eps=exploration_final_eps,
            # learning related
            learning_rate_start=learning_rate_start,
            learning_rate_end=learning_rate_end,
            learning_fraction=learning_fraction, 
            # reward function related
            use_adrs=use_adrs,
            reward_types=reward_types,
            adrs_update=adrs_update,
            adrs_mu=adrs_mu,
            hybrid_eta=hybrid_eta,
            theta=theta, 
            version=version, 
            # env related
            episode_step=episode_step,
            env_name=env_name,
            gamma=gamma,
            vector=vector,
            node_embedding=node_embedding,
            use_one_hot=use_one_hot,
            use_noise=use_noise,
            noise_level=noise_level,
            map_size=map_size,
            map_id=map_id,
            violation_end=violation_end,
            missing=missing,
            human=human,
            # training related
            total_timesteps=total_timesteps,
            total_run=total_run,
            seed=seed,
            # evaluation related
            eval_freq=eval_freq,
            rolling=rolling,
            init_qs=init_qs,
            save=save,
            cf=cf
        )
        # map related
        self.water_world_map_path = "./psltl/envs/common/cont/water/maps/world.pkl"
        self.n_steps = n_steps
        self.tau = tau
        self.ent_coef = ent_coef
    
    def print_infos(self):
        print("=" * 75)
        print("Env: ", self.env_name)
        if self.env_name == "water":
            print("Map id:", self.map_id)
        print("Learning rate: ", self.learning_rate)
        print("Exploration Final Rate: ", self.exploration_final_eps)
        print("Gamma: ", self.gamma)
        print("Total Timesteps: ", self.total_timesteps)
        print("Total Runs: ", self.total_run)
        print("Reward Types: ", self.reward_types)
        print("Usage of Adaptive Reward Shaping: ", self.use_adrs)
        if True in self.use_adrs:
            print("Adaptive Reward Shaping Delta: ", self.hybrid_eta)
            print("Adaptive Reward Shaping Update Freqeuncy: ", self.adrs_update)
        print("Epsiode End Step: ", self.episode_step)

        print("-"*32 + "Model Params" + '-'*32)
        print("Buffer Size: ", self.buffer_size)
        print("Train Frequency: ", self.train_freq)
        print("Batch Size: ", self.batch_size)
        print("Final Exploration Rate: ", self.exploration_final_eps)
        print("Policy Net Architecture: ", self.policy_kwargs)

        print("=" * 75)

    def model_params(self, algo_name):
        assert algo_name in ["ddqn", "ddpg", "ppo", "td3", "sac", "a2c", "dqn"]
        common_params = {
            "policy_kwargs": self.policy_kwargs,
            "tensorboard_log": None,
            "gamma": self.gamma,
            "learning_rate": self.learning_rate,
            }
        params = common_params.copy()
        if algo_name in ["ddqn", "dqn"]:
            params.update(
            {
                "double_dqn": False,
                "train_freq": self.train_freq,
                "batch_size": self.batch_size,
                "buffer_size": self.buffer_size,
                "learning_starts": self.learning_starts,
                "gradient_steps": self.gradient_steps,
                "target_update_interval": self.target_update_interval,
                "exploration_initial_eps": self.exploration_initial_eps,
                "exploration_fraction": self.exploration_fraction,
                "exploration_final_eps": self.exploration_final_eps,
                "max_grad_norm": self.max_grad_norm,
            }
            )
            if algo_name == "ddqn":
                params.update({"double_dqn": True})
        elif algo_name in ["td3", "sac", "ddpg"]:
            params.update({"tau": self.tau,
                           "batch_size": self.batch_size,
                           "buffer_size": self.buffer_size
                           })
        # On-Policy Algorithms
        elif algo_name in ["ppo"]:
            params.update({"batch_size": self.batch_size, "n_steps": self.n_steps, "ent_coef": self.ent_coef, "max_grad_norm": self.max_grad_norm,})
        elif algo_name in ["a2c"]:
            params.update({"n_steps": self.n_steps, "ent_coef": self.ent_coef, "max_grad_norm": self.max_grad_norm,})
        else:
            NotImplementedError(
                "model name is not implemented, we only support ddqn, ddpg, ppo, td3, sac, a2c currently.")
        return params