From 07a4a3b530f50354c57ea545741a8030deb7d0c9 Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 21:41:00 +0900
Subject: [PATCH 1/8] [Feat] Adding SHPP environment

---
 rl4co/envs/__init__.py               |   2 +
 rl4co/envs/routing/__init__.py       |   3 +-
 rl4co/envs/routing/shpp/env.py       | 187 +++++++++++++++++++++++++++
 rl4co/envs/routing/shpp/generator.py |  55 ++++++++
 rl4co/envs/routing/shpp/render.py    |  66 ++++++++++
 5 files changed, 312 insertions(+), 1 deletion(-)
 create mode 100644 rl4co/envs/routing/shpp/env.py
 create mode 100644 rl4co/envs/routing/shpp/generator.py
 create mode 100644 rl4co/envs/routing/shpp/render.py

diff --git a/rl4co/envs/__init__.py b/rl4co/envs/__init__.py
index ac588739..23b6fccf 100644
--- a/rl4co/envs/__init__.py
+++ b/rl4co/envs/__init__.py
@@ -19,6 +19,7 @@
     SPCTSPEnv,
     SVRPEnv,
     TSPEnv,
+    SHPPEnv,
 )
 
 # Scheduling
@@ -43,6 +44,7 @@
     "tsp": TSPEnv,
     "smtwtp": SMTWTPEnv,
     "mdcpdp": MDCPDPEnv,
+    "shpp": SHPPEnv,
 }
 
 
diff --git a/rl4co/envs/routing/__init__.py b/rl4co/envs/routing/__init__.py
index 9c16f758..7eefce23 100644
--- a/rl4co/envs/routing/__init__.py
+++ b/rl4co/envs/routing/__init__.py
@@ -11,6 +11,7 @@
 from rl4co.envs.routing.spctsp.env import SPCTSPEnv
 from rl4co.envs.routing.svrp.env import SVRPEnv
 from rl4co.envs.routing.tsp.env import TSPEnv
+from rl4co.envs.routing.shpp.env import SHPPEnv
 
 from rl4co.envs.routing.atsp.generator import ATSPGenerator
 from rl4co.envs.routing.cvrp.generator import CVRPGenerator
@@ -23,4 +24,4 @@
 from rl4co.envs.routing.svrp.generator import SVRPGenerator
 from rl4co.envs.routing.tsp.generator import TSPGenerator
 from rl4co.envs.routing.mdcpdp.generator import MDCPDPGenerator
-
+from rl4co.envs.routing.shpp.generator import SHPPGenerator
diff --git a/rl4co/envs/routing/shpp/env.py b/rl4co/envs/routing/shpp/env.py
new file mode 100644
index 00000000..35e5b439
--- /dev/null
+++ b/rl4co/envs/routing/shpp/env.py
@@ -0,0 +1,187 @@
+from typing import Optional
+
+import torch
+
+from rl4co.envs.common.base import RL4COEnvBase
+from rl4co.utils.ops import gather_by_index, get_tour_length
+from rl4co.utils.pylogger import get_pylogger
+from tensordict.tensordict import TensorDict
+from torchrl.data import (
+    BoundedTensorSpec,
+    CompositeSpec,
+    UnboundedContinuousTensorSpec,
+    UnboundedDiscreteTensorSpec,
+)
+
+from .generator import SHPPGenerator
+from .render import render
+
+log = get_pylogger(__name__)
+
+
+class SHPPEnv(RL4COEnvBase):
+    """
+    Shortest Hamiltonian Path Problem (SHPP)
+    SHPP is referred to the open-loop Traveling Salesman Problem (TSP) in the literature.
+    The goal of the SHPP is to find the shortest Hamiltonian path in a given graph with
+    given fixed starting/terminating nodes (they can be different nodes). A Hamiltonian
+    path visits all other nodes exactly once. At each step, the agent chooses a city to visit.
+    The reward is 0 unless the agent visits all the cities. In that case, the reward is
+    (-)length of the path: maximizing the reward is equivalent to minimizing the path length.
+
+    Observation:
+        - locations of each customer
+        - starting node and terminating node
+        - the current location of the vehicle
+
+    Constraints:
+        - the first node is the starting node
+        - the last node is the terminating node
+        - each node is visited exactly once
+
+    Finish condition:
+        - the agent has visited all the customers and reached the terminating node
+
+    Reward:
+        - (minus) the length of the path
+
+    Args:
+        generator: SHPPGenerator instance as the generator
+        generator_params: parameters for the generator
+    """
+
+    name = "shpp"
+
+    def __init__(
+        self,
+        generator: SHPPGenerator = None,
+        generator_params: dict = {},
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        if generator is None:
+            generator = SHPPGenerator(**generator_params)
+        self.generator = generator
+        self._make_spec(self.generator)
+
+    @staticmethod
+    def _step(td: TensorDict) -> TensorDict:
+        current_node = td["action"]
+        first_node = current_node if td["i"].all() == 0 else td["first_node"]
+
+        # Set not visited to 0 (i.e., we visited the node)
+        available = td["available"].scatter(
+            -1, current_node.unsqueeze(-1).expand_as(td["action_mask"]), 0
+        )
+
+        # If all other nodes are visited, the terminating node will be available
+        action_mask = available.clone()
+        action_mask[..., -1] = ~available[..., :-1].any(dim=-1)
+
+        # We are done there are no unvisited locations
+        done = torch.sum(available, dim=-1) == 0
+
+        # The reward is calculated outside via get_reward for efficiency, so we set it to 0 here
+        reward = torch.zeros_like(done)
+
+        td.update(
+            {
+                "first_node": first_node,
+                "current_node": current_node,
+                "i": td["i"] + 1,
+                "available": available,
+                "action_mask": action_mask,
+                "reward": reward,
+                "done": done,
+            },
+        )
+        return td
+
+    def _reset(self, td: Optional[TensorDict] = None, batch_size=None) -> TensorDict:
+        """Note: the first node is the starting node; the last node is the terminating node"""
+        device = td.device
+        locs = td["locs"]
+
+        # We do not enforce loading from self for flexibility
+        num_loc = locs.shape[-2]
+
+        # Other variables
+        current_node = torch.zeros((batch_size), dtype=torch.int64, device=device)
+        last_node = torch.full(
+            (batch_size), num_loc - 1, dtype=torch.int64, device=device
+        )
+        available = torch.ones(
+            (*batch_size, num_loc), dtype=torch.bool, device=device
+        )  # 1 means not visited, i.e. action is allowed
+        action_mask = torch.zeros((*batch_size, num_loc), dtype=torch.bool, device=device)
+        action_mask[..., 0] = 1  # Only the start point is availabe at the beginning
+        i = torch.zeros((*batch_size, 1), dtype=torch.int64, device=device)
+
+        return TensorDict(
+            {
+                "locs": locs,
+                "first_node": current_node,
+                "last_node": last_node,
+                "current_node": current_node,
+                "i": i,
+                "available": available,
+                "action_mask": action_mask,
+                "reward": torch.zeros((*batch_size, 1), dtype=torch.float32),
+            },
+            batch_size=batch_size,
+        )
+
+    def _get_reward(self, td, actions) -> TensorDict:
+        # Gather locations in order of tour and return distance between them (i.e., -reward)
+        locs_ordered = gather_by_index(td["locs"], actions)
+        return -get_tour_length(locs_ordered)
+
+    @staticmethod
+    def check_solution_validity(td: TensorDict, actions: torch.Tensor):
+        """Check that solution is valid: nodes are visited exactly once"""
+        assert (
+            torch.arange(actions.size(1), out=actions.data.new())
+            .view(1, -1)
+            .expand_as(actions)
+            == actions.data.sort(1)[0]
+        ).all(), "Invalid tour"
+
+    @staticmethod
+    def render(td: TensorDict, actions: torch.Tensor=None, ax = None):
+        return render(td, actions, ax)
+
+    def _make_spec(self, generator):
+        """Make the observation and action specs from the parameters"""
+        self.observation_spec = CompositeSpec(
+            locs=BoundedTensorSpec(
+                low=generator.min_loc,
+                high=generator.max_loc,
+                shape=(generator.num_loc, 2),
+                dtype=torch.float32,
+            ),
+            first_node=UnboundedDiscreteTensorSpec(
+                shape=(1),
+                dtype=torch.int64,
+            ),
+            current_node=UnboundedDiscreteTensorSpec(
+                shape=(1),
+                dtype=torch.int64,
+            ),
+            i=UnboundedDiscreteTensorSpec(
+                shape=(1),
+                dtype=torch.int64,
+            ),
+            action_mask=UnboundedDiscreteTensorSpec(
+                shape=(generator.num_loc),
+                dtype=torch.bool,
+            ),
+            shape=(),
+        )
+        self.action_spec = BoundedTensorSpec(
+            shape=(1,),
+            dtype=torch.int64,
+            low=0,
+            high=generator.num_loc,
+        )
+        self.reward_spec = UnboundedContinuousTensorSpec(shape=(1,))
+        self.done_spec = UnboundedDiscreteTensorSpec(shape=(1,), dtype=torch.bool)
diff --git a/rl4co/envs/routing/shpp/generator.py b/rl4co/envs/routing/shpp/generator.py
new file mode 100644
index 00000000..7bbe7c88
--- /dev/null
+++ b/rl4co/envs/routing/shpp/generator.py
@@ -0,0 +1,55 @@
+from typing import Union, Callable
+
+import torch
+
+from torch.distributions import Uniform
+from tensordict.tensordict import TensorDict
+
+from rl4co.utils.pylogger import get_pylogger
+from rl4co.envs.common.utils import get_sampler, Generator
+
+log = get_pylogger(__name__)
+
+
+class SHPPGenerator(Generator):
+    """Data generator for the Shortest Hamiltonian Path Problem (SHPP).
+    Args:
+        num_loc: number of locations (customers) in the TSP
+        min_loc: minimum value for the location coordinates
+        max_loc: maximum value for the location coordinates
+        loc_distribution: distribution for the location coordinates
+
+    Returns:
+        A TensorDict with the following keys:
+            locs [batch_size, num_loc, 2]: locations of each customer
+    """
+    def __init__(
+        self,
+        num_loc: int = 20,
+        min_loc: float = 0.0,
+        max_loc: float = 1.0,
+        loc_distribution: Union[
+            int, float, str, type, Callable
+        ] = Uniform,
+        **kwargs
+    ):
+        self.num_loc = num_loc
+        self.min_loc = min_loc
+        self.max_loc = max_loc
+
+        # Location distribution
+        if kwargs.get("loc_sampler", None) is not None:
+            self.loc_sampler = kwargs["loc_sampler"]
+        else:
+            self.loc_sampler = get_sampler("loc", loc_distribution, min_loc, max_loc, **kwargs)
+
+    def _generate(self, batch_size) -> TensorDict:
+        # Sample locations
+        locs = self.loc_sampler.sample((*batch_size, self.num_loc, 2))
+        
+        return TensorDict(
+            {
+                "locs": locs,
+            },
+            batch_size=batch_size,
+        )
diff --git a/rl4co/envs/routing/shpp/render.py b/rl4co/envs/routing/shpp/render.py
new file mode 100644
index 00000000..c39b2392
--- /dev/null
+++ b/rl4co/envs/routing/shpp/render.py
@@ -0,0 +1,66 @@
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+
+from rl4co.utils.ops import gather_by_index
+from rl4co.utils.pylogger import get_pylogger
+
+log = get_pylogger(__name__)
+
+
+def render(td, actions=None, ax=None):
+    import matplotlib.pyplot as plt
+    import numpy as np
+
+    if ax is None:
+        # Create a plot of the nodes
+        _, ax = plt.subplots(figsize=(3, 3))
+
+    td = td.detach().cpu()
+
+    if actions is None:
+        actions = td.get("action", None)
+    # if batch_size greater than 0 , we need to select the first batch element
+    if td.batch_size != torch.Size([]):
+        td = td[0]
+        actions = actions[0]
+
+    locs = td["locs"]
+
+    # gather locs in order of action if available
+    if actions is None:
+        log.warning("No action in TensorDict, rendering unsorted locs")
+    else:
+        actions = actions.detach().cpu()
+        locs = gather_by_index(locs, actions, dim=0)
+
+    start_x, start_y = locs[0, 0], locs[0, 1]
+    end_x, end_y = locs[-1, 0], locs[-1, 1]
+    city_x, city_y = locs[1:-1, 0], locs[1:-1, 1]
+    x, y = locs[:, 0], locs[:, 1]
+
+    # Plot the start and end nodes
+    ax.scatter(start_x, start_y, color="tab:green", marker="s")
+    ax.scatter(end_x, end_y, color="tab:red", marker="x")
+
+    # Plot the visited nodes
+    ax.scatter(city_x, city_y, color="tab:blue")
+
+    # Add arrows between visited nodes as a quiver plot
+    dx, dy = np.diff(x), np.diff(y)
+    ax.quiver(
+        x[:-1],
+        y[:-1],
+        dx,
+        dy,
+        scale_units="xy",
+        angles="xy",
+        scale=1,
+        color="gray",
+        width=0.003,
+        headwidth=8,
+    )
+
+    # Setup limits and show
+    ax.set_xlim(-0.05, 1.05)
+    ax.set_ylim(-0.05, 1.05)

From 42b6a8f512e7929183e28cf206c585148378b37c Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 21:41:27 +0900
Subject: [PATCH 2/8] [Feat] Adding SHPP embedding

---
 rl4co/models/nn/env_embeddings/context.py | 35 +++++++++++++++++++++++
 rl4co/models/nn/env_embeddings/dynamic.py |  1 +
 rl4co/models/nn/env_embeddings/init.py    | 22 ++++++++++++++
 3 files changed, 58 insertions(+)

diff --git a/rl4co/models/nn/env_embeddings/context.py b/rl4co/models/nn/env_embeddings/context.py
index 79f236e0..ab2d701d 100644
--- a/rl4co/models/nn/env_embeddings/context.py
+++ b/rl4co/models/nn/env_embeddings/context.py
@@ -32,6 +32,7 @@ def env_context_embedding(env_name: str, config: dict) -> nn.Module:
         "mtsp": MTSPContext,
         "smtwtp": SMTWTPContext,
         "mdcpdp": MDCPDPContext,
+        "shpp": SHPPContext,
     }
 
     if env_name not in embedding_registry:
@@ -313,3 +314,37 @@ def __init__(self, embed_dim):
     def forward(self, embeddings, td):
         cur_node_embedding = self._cur_node_embedding(embeddings, td).squeeze()
         return self.project_context(cur_node_embedding)
+
+
+class SHPPContext(EnvContext):
+    """Context embedding for the Shortest Hamiltonian Path Problem (SHPP)
+    Project the following to the embedding space:
+        - first node embedding
+        - current node embedding
+        - terminating node embedding
+    """
+
+    def __init__(self, embed_dim):
+        super().__init__(embed_dim, 3 * embed_dim)
+        self.W_placeholder = nn.Parameter(
+            torch.Tensor(3 * self.embed_dim).uniform_(-1, 1)
+        )
+
+    def forward(self, embeds, td):
+        batch_size = embeds.size(0)
+        # By default, node_dim = -1 (we only have one node embedding per node)
+        node_dim = (
+            (-1,) if td["first_node"].dim() == 1 else (td["first_node"].size(-1), -1)
+        )
+        if td["i"][(0,) * td["i"].dim()].item() < 1:  # get first item fast
+            context_embed = self.W_placeholder[None, :].expand(
+                batch_size, self.W_placeholder.size(-1)
+            )
+        else:
+            context_embed = gather_by_index(
+                embeds,
+                torch.stack(
+                    [td["first_node"], td["current_node"], td["last_node"]], -1
+                ).view(batch_size, -1),
+            ).view(batch_size, *node_dim)
+        return self.project_context(context_embed)
diff --git a/rl4co/models/nn/env_embeddings/dynamic.py b/rl4co/models/nn/env_embeddings/dynamic.py
index b75fe7b2..0ecb6175 100644
--- a/rl4co/models/nn/env_embeddings/dynamic.py
+++ b/rl4co/models/nn/env_embeddings/dynamic.py
@@ -30,6 +30,7 @@ def env_dynamic_embedding(env_name: str, config: dict) -> nn.Module:
         "pdp": StaticEmbedding,
         "mtsp": StaticEmbedding,
         "smtwtp": StaticEmbedding,
+        "shpp": StaticEmbedding,
     }
 
     if env_name not in embedding_registry:
diff --git a/rl4co/models/nn/env_embeddings/init.py b/rl4co/models/nn/env_embeddings/init.py
index 5b056f80..900848c1 100644
--- a/rl4co/models/nn/env_embeddings/init.py
+++ b/rl4co/models/nn/env_embeddings/init.py
@@ -33,6 +33,7 @@ def env_init_embedding(env_name: str, config: dict) -> nn.Module:
         "smtwtp": SMTWTPInitEmbedding,
         "mdcpdp": MDCPDPInitEmbedding,
         "fjsp": FJSPFeatureEmbedding,
+        "shpp": SHPPInitEmbedding,
     }
 
     if env_name not in embedding_registry:
@@ -444,3 +445,24 @@ def _stepwise_operations_embed(self, td: TensorDict):
 
     def _stepwise_machine_embed(self, td: TensorDict):
         raise NotImplementedError("Stepwise encoding not yet implemented")
+
+
+class SHPPInitEmbedding(nn.Module):
+    """Initial embedding for the Traveling Salesman Problems (TSP).
+    Embed the following node features to the embedding space:
+        - locs: x, y coordinates of the cities
+    """
+
+    def __init__(self, embed_dim, linear_bias=True):
+        super(SHPPInitEmbedding, self).__init__()
+        node_dim = 2  # x, y
+        self.init_embed = nn.Linear(node_dim, embed_dim, linear_bias)
+        self.init_embed_start = nn.Linear(node_dim, embed_dim, linear_bias)
+        self.init_embed_end = nn.Linear(node_dim, embed_dim, linear_bias)
+
+    def forward(self, td):
+        start_embed = self.init_embed_start(td["locs"][:, :1])
+        node_embed = self.init_embed(td["locs"][:, 1:-1])
+        end_embed = self.init_embed_end(td["locs"][:, -1:])
+        out = torch.cat([start_embed, node_embed, end_embed], dim=-2)
+        return out

From 721545deea9bb7d8611c320fc978ed22f0d0b55a Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 21:41:57 +0900
Subject: [PATCH 3/8] [Feat] Init GLOP model

---
 rl4co/models/__init__.py          |   1 +
 rl4co/models/zoo/__init__.py      |   1 +
 rl4co/models/zoo/glop/__init__.py |   2 +
 rl4co/models/zoo/glop/model.py    |  88 +++++++++++++
 rl4co/models/zoo/glop/policy.py   | 203 ++++++++++++++++++++++++++++++
 5 files changed, 295 insertions(+)
 create mode 100644 rl4co/models/zoo/glop/__init__.py
 create mode 100644 rl4co/models/zoo/glop/model.py
 create mode 100644 rl4co/models/zoo/glop/policy.py

diff --git a/rl4co/models/__init__.py b/rl4co/models/__init__.py
index 0ebec158..6da1fada 100644
--- a/rl4co/models/__init__.py
+++ b/rl4co/models/__init__.py
@@ -35,3 +35,4 @@
 from rl4co.models.zoo.pomo import POMO
 from rl4co.models.zoo.ptrnet import PointerNetwork, PointerNetworkPolicy
 from rl4co.models.zoo.symnco import SymNCO, SymNCOPolicy
+from rl4co.models.zoo.glop import GLOP, GLOPPolicy
diff --git a/rl4co/models/zoo/__init__.py b/rl4co/models/zoo/__init__.py
index c16bbe9b..9a474fed 100644
--- a/rl4co/models/zoo/__init__.py
+++ b/rl4co/models/zoo/__init__.py
@@ -17,3 +17,4 @@
 from rl4co.models.zoo.pomo import POMO
 from rl4co.models.zoo.ptrnet import PointerNetwork, PointerNetworkPolicy
 from rl4co.models.zoo.symnco import SymNCO, SymNCOPolicy
+from rl4co.models.zoo.glop import GLOP, GLOPPolicy
diff --git a/rl4co/models/zoo/glop/__init__.py b/rl4co/models/zoo/glop/__init__.py
new file mode 100644
index 00000000..3634a552
--- /dev/null
+++ b/rl4co/models/zoo/glop/__init__.py
@@ -0,0 +1,2 @@
+from .model import GLOP
+from .policy import GLOPPolicy
diff --git a/rl4co/models/zoo/glop/model.py b/rl4co/models/zoo/glop/model.py
new file mode 100644
index 00000000..8c020094
--- /dev/null
+++ b/rl4co/models/zoo/glop/model.py
@@ -0,0 +1,88 @@
+from typing import Any, Union, Optional
+
+from rl4co.envs.common.base import RL4COEnvBase
+from rl4co.models.rl import REINFORCE
+from rl4co.models.rl.reinforce.baselines import REINFORCEBaseline
+from rl4co.utils.ops import gather_by_index, unbatchify
+
+from .policy import GLOPPolicy
+
+
+class GLOP(REINFORCE):
+    """Global and Local Optimization Policies (GLOP) REINFORCE: https://arxiv.org/abs/2312.08224
+
+    Args:
+        env: Environment to use for the algorithm
+        policy: Policy to use for the algorithm
+        baseline: REINFORCE baseline. Defaults to rollout (1 epoch of exponential, then greedy rollout baseline)
+        revisers: List of revisers to use for the GLOP revision phase, the reviser could be a neural network model
+            or a heuristic function. Defaults to None, but this is required.
+        n_samples: Number of samples to use for the GLOP policy. Defaults to 10.
+        policy_kwargs: Keyword arguments for policy
+        baseline_kwargs: Keyword arguments for baseline
+        **kwargs: Keyword arguments passed to the superclass
+    """
+
+    def __init__(
+        self,
+        env: RL4COEnvBase,
+        policy: GLOPPolicy = None,
+        baseline: Union[REINFORCEBaseline, str] = "shared",
+        revisers: list[Union[callable]] = None,
+        n_samples: int = 10,
+        policy_kwargs={},
+        baseline_kwargs={},
+        **kwargs,
+    ):
+        if policy is None:
+            policy = GLOPPolicy(
+                env_name=env.name,
+                n_samples=n_samples,
+                revisers=revisers,
+                **policy_kwargs,
+            )
+
+        super().__init__(env, policy, baseline, baseline_kwargs, **kwargs)
+
+    def shared_step(
+        self, batch: Any, batch_idx: int, phase: str, dataloader_idx: int = None
+    ):
+        td = self.env.reset(batch)
+        n_samples = self.policy.n_samples
+
+        # Evaluate policy
+        out = self.policy(
+            td=td,
+            env=self.env,
+            phase=phase,
+            return_actions=True,
+        )
+
+        # Unbatchify reward to [batch_size, num_augment, num_starts].
+        reward = unbatchify(out["reward"], (n_samples))
+
+        # Training phase
+        if phase == "train":
+            assert n_samples > 1, "num_starts must be > 1 during training"
+            log_likelihood = unbatchify(out["log_likelihood"], (n_samples))
+            out = self.calculate_loss(td, batch, out, reward, log_likelihood)
+            max_reward, max_idxs = reward.max(dim=-1)
+            out.update({"max_reward": max_reward})
+        # Get multi-start (=POMO) rewards and best actions only during validation and test
+        else:
+            if n_samples > 1:
+                # max multi-start reward
+                max_reward, max_idxs = reward.max(dim=-1)
+                out.update({"max_reward": max_reward})
+
+                if out.get("actions", None) is not None:
+                    # Reshape batch to [batch_size, num_augment, num_starts, ...]
+                    actions = unbatchify(out["actions"], (n_samples))
+                    out.update(
+                        {"best_multistart_actions": gather_by_index(actions, max_idxs, dim=max_idxs.dim())}
+                    )
+                    out["actions"] = actions
+
+        metrics = self.log_metrics(out, phase, dataloader_idx=dataloader_idx)
+        return {"loss": out.get("loss", None), **metrics}
+   
\ No newline at end of file
diff --git a/rl4co/models/zoo/glop/policy.py b/rl4co/models/zoo/glop/policy.py
new file mode 100644
index 00000000..6f5ffd9b
--- /dev/null
+++ b/rl4co/models/zoo/glop/policy.py
@@ -0,0 +1,203 @@
+from typing import Optional, Union
+from uu import decode
+
+from einops import rearrange
+import torch
+import torch.nn as nn
+
+from rl4co.envs import RL4COEnvBase, get_env
+from rl4co.utils.decoding import (
+    DecodingStrategy,
+    get_decoding_strategy,
+    get_log_likelihood,
+)
+from rl4co.models.common.constructive.nonautoregressive import (
+    NonAutoregressiveEncoder,
+    NonAutoregressiveDecoder,
+    NonAutoregressivePolicy,
+)
+from rl4co.models.zoo.nargnn.encoder import NARGNNEncoder
+from rl4co.utils.ops import batchify, gather_by_index, unbatchify
+from rl4co.utils.pylogger import get_pylogger
+from tensordict import TensorDict
+
+log = get_pylogger(__name__)
+
+
+class GLOPPolicy(NonAutoregressivePolicy):
+    """Global and Local Optimization Policies (GLOP) Policy: https://arxiv.org/abs/2312.08224
+
+    Args:
+        env_name: Name of the environment used to initialize embeddings
+        embedding_dim: Dimension of the node embeddings
+        num_encoder_layers: Number of layers in the encoder
+        num_heads: Number of heads in the attention layers
+        normalization: Normalization type in the attention layers
+        revisers: List of revisers to use for the GLOP revision phase, the reviser could be a neural network model
+            or a heuristic function. Defaults to None, but this is required.
+        n_samples: Number of samples to use for the GLOP policy. Defaults to 10.
+        **kwargs: keyword arguments passed to the `AutoregressivePolicy`
+    """
+
+    def __init__(
+        self,
+        encoder: NonAutoregressiveEncoder = None,
+        decoder: NonAutoregressiveDecoder = None,
+        env_name: Union[str, RL4COEnvBase] = "tsp",
+        n_samples: int = 10,
+        revisers: list[Union[callable]] = None,
+        **encoder_kwargs,
+    ):
+        if encoder is None:
+            encoder = NARGNNEncoder(**encoder_kwargs)
+        if decoder is None:
+            decoder = NonAutoregressiveDecoder()
+
+        super().__init__(
+            encoder=encoder,
+            decoder=decoder,
+            env_name=env_name,
+            train_decode_type="multistart_sampling",
+            val_decode_type="multistart_sampling",
+            test_decode_type="multistart_sampling",
+        )
+
+        self.n_samples = n_samples
+        self.revisers = revisers
+
+    def forward(
+        self,
+        td: TensorDict,
+        env: Union[str, RL4COEnvBase, None] = None,
+        phase: str = "train",
+        calc_reward: bool = True,
+        return_actions: bool = False,
+        return_entropy: bool = False,
+        return_init_embeds: bool = False,
+        return_sum_log_likelihood: bool = True,
+        return_partitions: bool = True,
+        return_partitions_actions: bool = True,
+        actions=None,
+        **decoding_kwargs,
+    ) -> dict:
+        device = td.device
+        
+        par_out = super().forward(
+            td = td,
+            env = env,
+            phase = phase,
+            calc_reward = False, # We don't need the partition reward
+            return_actions = True, # Used for partition
+            return_entropy = return_entropy,
+            return_init_embeds = return_init_embeds,
+            return_sum_log_likelihood = return_sum_log_likelihood,
+            num_starts = self.n_samples,
+            actions = actions,
+            decode_type="multistart_sampling",
+            **decoding_kwargs,
+        )
+
+        td_sample = batchify(td, self.n_samples)
+        par_actions = par_out["actions"]
+        par_log_likelihood = par_out["log_likelihood"]
+
+        # Based on partition actions to get partitions
+        shpp_locs, par = self.partition(td_sample, par_actions)
+
+        # Batchify the shpp_td along the partitions
+        batch_size = shpp_locs.size(0)
+        n_partitions = shpp_locs.size(1)
+        n_nodes = shpp_locs.size(2)
+        shpp_locs = rearrange(shpp_locs, "b p n d -> (b p) n d", b=batch_size, p=n_partitions, n=n_nodes, d=2)
+
+        # Set the SHPP environments
+        shpp_env = get_env("shpp")
+        shpp_env.generator.num_loc = n_nodes
+        shpp_td = shpp_env.reset(batch_size=batch_size*n_partitions).to(device)
+        shpp_td.set("locs", shpp_locs)
+
+        # Call revisers to solve the sub-routes and record the best
+        best_revised_reward = torch.full(shpp_td.shape[:1], float("-inf")).to(device)
+        best_revised_actions = torch.zeros(shpp_td["locs"].shape[:-1], dtype=torch.int64).to(device)
+        for reviser in self.revisers:
+            reviser = reviser.to(device)
+            reviser_out = reviser(shpp_td.clone(), phase="test", decode_type="greedy", return_actions=True)
+
+            # Record the best
+            improve_flag = reviser_out["reward"] > best_revised_reward
+            best_revised_reward = torch.where(improve_flag, reviser_out["reward"], best_revised_reward)
+            best_revised_actions = torch.where(improve_flag.unsqueeze(1), reviser_out["actions"], best_revised_actions)
+
+        # Construct final output
+        out = {"log_likelihood": par_log_likelihood}
+
+        if calc_reward:
+            best_revised_reward = unbatchify(best_revised_reward, (n_partitions))
+            best_revised_reward = best_revised_reward.sum(dim=-1)
+            out["reward"] = best_revised_reward
+        if return_actions:
+            final_actions = unbatchify(best_revised_actions, (n_partitions))
+            final_actions = final_actions.flatten(start_dim=1)
+            out["actions"] = final_actions
+        if return_entropy:
+            out["entropy"] = par_out["entropy"]
+        if return_init_embeds:
+            out["init_embeds"] = par_out["init_embeds"]
+        if return_partitions:
+            out["partition"] = par
+        if return_partitions_actions:
+            out["par_actions"] = par_actions
+            out["revised_actions"] = best_revised_actions
+
+        return out
+
+    @staticmethod
+    def partition(td: TensorDict, actions: torch.Tensor):
+        """
+        Args:
+            td [bs*n_samples]
+            actions [bs*n_samples, seq_len]
+        Returns:
+            <TensorDict>
+                locs [bs*n_samples, n_partitions, n_nodes, 2]
+                partition [bs*n_samples, n_partitions, seq_len]
+        """
+        max_num_partitions = 0
+        max_len_sequence = 0
+        partition = torch.zeros([*actions.size(), actions.size(-1)]).to(
+            td.device, torch.int64
+        )  # [bs*n_samples, seq_len, seq_len]
+        for batch_idx in range(td.size(0)):
+            partition_idx = 0
+            partition_start_idx = 0
+            for action_idx, action in enumerate(actions[batch_idx]):
+                if (action == 0) & (action_idx != 0):
+                    partition_idx += 1
+                    # Update the max length of the sequence
+                    if action_idx - partition_start_idx > max_len_sequence:
+                        max_len_sequence = action_idx - partition_start_idx
+                    partition_start_idx = action_idx + 1
+                else:
+                    partition[
+                        batch_idx, partition_idx, action_idx - partition_start_idx
+                    ] = action
+            # Update the max number of partitions
+            if partition_idx + 1 > max_num_partitions:
+                max_num_partitions = partition_idx + 1
+        # Squeese the partition
+        partition = partition[:, :max_num_partitions, :max_len_sequence]
+        # Adding depot to the beginning and the end
+        partition = torch.cat(
+            [
+                torch.zeros_like(partition[:, :, :1]),
+                partition,
+                torch.zeros_like(partition[:, :, :1]),
+            ],
+            dim=-1,
+        )
+        # Expand the locs
+        locs = td["locs"].unsqueeze(1).expand(-1, max_num_partitions, -1, -1)
+        # Get the locations of the partitions
+        locs = gather_by_index(locs, partition, dim=-2)
+
+        return locs, partition

From 39d87b46ef6f4210396d24cf8319dd206c97d3dd Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 21:42:15 +0900
Subject: [PATCH 4/8] [Notebook] Adding GLOP test notebook

---
 examples/other/3-glop.ipynb | 791 ++++++++++++++++++++++++++++++++++++
 1 file changed, 791 insertions(+)
 create mode 100644 examples/other/3-glop.ipynb

diff --git a/examples/other/3-glop.ipynb b/examples/other/3-glop.ipynb
new file mode 100644
index 00000000..58815b4d
--- /dev/null
+++ b/examples/other/3-glop.ipynb
@@ -0,0 +1,791 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Global and Local Optimization Policies (GLOP)\n",
+    "\n",
+    "This notebook is a simple introduction to the Global and Local Optimization Policies (GLOP) from Haoran et al. (2023). Read the paper [here](https://arxiv.org/abs/2312.08224)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Shortest Hamiltonian Path Problem (SHPP)\n",
+    "\n",
+    "This section will introduce the Shortest Hamiltonian Path Problem (SHPP) which is used as solver for partitions in the GLOP algorithm."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import sys; sys.path.append(2*'../')\n",
+    "\n",
+    "import torch\n",
+    "\n",
+    "from rl4co.models.zoo import AttentionModel, AttentionModelPolicy\n",
+    "from rl4co.utils.trainer import RL4COTrainer\n",
+    "from rl4co.envs.routing import SHPPEnv, SHPPGenerator"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'env' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['env'])`.\n",
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'policy' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['policy'])`.\n"
+     ]
+    }
+   ],
+   "source": [
+    "generator = SHPPGenerator(num_loc=20)\n",
+    "env = SHPPEnv(generator) \n",
+    "\n",
+    "embed_dim = 128\n",
+    "\n",
+    "policy = AttentionModelPolicy(\n",
+    "    embed_dim=embed_dim,\n",
+    "    env_name=env.name,\n",
+    ")\n",
+    "\n",
+    "model = AttentionModel(\n",
+    "    env, \n",
+    "    policy,\n",
+    "    baseline=\"rollout\",\n",
+    "    train_data_size=100_000,\n",
+    "    val_data_size=10_000,\n",
+    "    optimizer_kwargs={\"lr\": 1e-4},\n",
+    ") "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Problem 1 | Cost: 6.879\n",
+      "Problem 2 | Cost: 6.445\n",
+      "Problem 3 | Cost: 7.478\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 300x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Greedy rollouts over untrained model\n",
+    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+    "td_init = env.reset(batch_size=[3]).to(device)\n",
+    "model = model.to(device)\n",
+    "out = model(td_init.clone(), phase=\"test\", decode_type=\"greedy\", return_actions=True)\n",
+    "actions_untrained = out['actions'].cpu().detach()\n",
+    "rewards_untrained = out['reward'].cpu().detach()\n",
+    "\n",
+    "for i in range(3):\n",
+    "    print(f\"Problem {i+1} | Cost: {-rewards_untrained[i]:.3f}\")\n",
+    "    env.render(td_init[i], actions_untrained[i])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using 16bit Automatic Mixed Precision (AMP)\n",
+      "GPU available: True (cuda), used: True\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "IPU available: False, using: 0 IPUs\n",
+      "HPU available: False, using: 0 HPUs\n",
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n"
+     ]
+    }
+   ],
+   "source": [
+    "trainer = RL4COTrainer(\n",
+    "    max_epochs=3,\n",
+    "    accelerator=\"gpu\",\n",
+    "    devices=1,\n",
+    "    logger=None,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Missing logger folder: /home/cbhua/github/rl4co/examples/other/lightning_logs\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n",
+      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n",
+      "\n",
+      "  | Name     | Type                 | Params\n",
+      "--------------------------------------------------\n",
+      "0 | env      | SHPPEnv              | 0     \n",
+      "1 | policy   | AttentionModelPolicy | 727 K \n",
+      "2 | baseline | WarmupBaseline       | 727 K \n",
+      "--------------------------------------------------\n",
+      "1.5 M     Trainable params\n",
+      "0         Non-trainable params\n",
+      "1.5 M     Total params\n",
+      "5.819     Total estimated model params size (MB)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                                           "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=31` in the `DataLoader` to improve performance.\n",
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=31` in the `DataLoader` to improve performance.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2: 100%|██████████| 196/196 [00:05<00:00, 36.68it/s, v_num=0, train/reward=-4.74, train/loss=-.474, val/reward=-4.63]  "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "`Trainer.fit` stopped: `max_epochs=3` reached.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2: 100%|██████████| 196/196 [00:06<00:00, 32.46it/s, v_num=0, train/reward=-4.74, train/loss=-.474, val/reward=-4.63]\n"
+     ]
+    }
+   ],
+   "source": [
+    "trainer.fit(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 700x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Greedy rollouts over trained model (same states as previous plot)\n",
+    "model = model.to(device)\n",
+    "out = model(td_init.clone(), phase=\"test\", decode_type=\"greedy\", return_actions=True)\n",
+    "actions_trained = out['actions'].cpu().detach()\n",
+    "\n",
+    "# Plotting\n",
+    "import matplotlib.pyplot as plt\n",
+    "for i, td in enumerate(td_init):\n",
+    "    fig, axs = plt.subplots(1,2, figsize=(7, 3))\n",
+    "    env.render(td, actions_untrained[i], ax=axs[0]) \n",
+    "    env.render(td, actions_trained[i], ax=axs[1])\n",
+    "    axs[0].set_title(f\"Untrained | Cost = {-rewards_untrained[i].item():.3f}\")\n",
+    "    axs[1].set_title(r\"Trained $\\pi_\\theta$\" + f\"| Cost = {-out['reward'][i].item():.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing GLOP\n",
+    "\n",
+    "This section will test the GLOP algorithm on a simple example.\n",
+    "\n",
+    "**NOTE**: The current implementation of the GLOP algorithm is not training with some hidden bugs. We need to fix it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n"
+     ]
+    }
+   ],
+   "source": [
+    "from rich.traceback import install; install()\n",
+    "%load_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "import sys; sys.path.append(2*'../')\n",
+    "\n",
+    "import torch\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from matplotlib import cm\n",
+    "\n",
+    "from rl4co.envs import TSPEnv, CVRPEnv, SHPPEnv\n",
+    "from rl4co.models.zoo import (\n",
+    "    AttentionModel,\n",
+    "    AttentionModelPolicy,\n",
+    "    GLOP,\n",
+    "    GLOPPolicy,\n",
+    ")\n",
+    "from rl4co.utils.trainer import RL4COTrainer\n",
+    "from rl4co.utils.ops import batchify, gather_by_index"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Train SHPP revisers from scratch\n",
+    "\n",
+    "Follow the previous SHPP training pipeline."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# reviser_size_list = [10, 20, 50]\n",
+    "\n",
+    "# reviser_list = []\n",
+    "# for reviser_idx, reviser_size in enumerate(reviser_size_list):\n",
+    "#     env = SHPPEnv(generator_params={\"num_loc\": reviser_size}) \n",
+    "\n",
+    "#     embed_dim = 128\n",
+    "\n",
+    "#     policy = AttentionModelPolicy(\n",
+    "#         embed_dim=embed_dim,\n",
+    "#         env_name=env.name,\n",
+    "#     )\n",
+    "\n",
+    "#     reviser = AttentionModel(\n",
+    "#         env, \n",
+    "#         policy,\n",
+    "#         baseline=\"rollout\",\n",
+    "#         train_data_size=100_000,\n",
+    "#         val_data_size=10_000,\n",
+    "#         optimizer_kwargs={\"lr\": 1e-4},\n",
+    "#     )\n",
+    "\n",
+    "#     trainer = RL4COTrainer(\n",
+    "#         max_epochs=3,\n",
+    "#         accelerator=\"gpu\",\n",
+    "#         devices=1,\n",
+    "#         logger=None,\n",
+    "#     )\n",
+    "\n",
+    "#     trainer.fit(reviser)\n",
+    "#     reviser_list.append(reviser)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Load SHPP revisers from checkpoints\n",
+    "\n",
+    "Load pretrained SHPP revisers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'env' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['env'])`.\n",
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:199: Attribute 'policy' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['policy'])`.\n",
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/core/saving.py:188: Found keys that are not in the model state dict but in the checkpoint: ['baseline.baseline.policy.encoder.init_embedding.init_embed.weight', 'baseline.baseline.policy.encoder.init_embedding.init_embed.bias', 'baseline.baseline.policy.encoder.init_embedding.init_embed_start.weight', 'baseline.baseline.policy.encoder.init_embedding.init_embed_start.bias', 'baseline.baseline.policy.encoder.init_embedding.init_embed_end.weight', 'baseline.baseline.policy.encoder.init_embedding.init_embed_end.bias', 'baseline.baseline.policy.encoder.net.layers.0.0.module.Wqkv.weight', 'baseline.baseline.policy.encoder.net.layers.0.0.module.Wqkv.bias', 'baseline.baseline.policy.encoder.net.layers.0.0.module.out_proj.weight', 'baseline.baseline.policy.encoder.net.layers.0.0.module.out_proj.bias', 'baseline.baseline.policy.encoder.net.layers.0.1.normalizer.weight', 'baseline.baseline.policy.encoder.net.layers.0.1.normalizer.bias', 'baseline.baseline.policy.encoder.net.layers.0.1.normalizer.running_mean', 'baseline.baseline.policy.encoder.net.layers.0.1.normalizer.running_var', 'baseline.baseline.policy.encoder.net.layers.0.1.normalizer.num_batches_tracked', 'baseline.baseline.policy.encoder.net.layers.0.2.module.0.weight', 'baseline.baseline.policy.encoder.net.layers.0.2.module.0.bias', 'baseline.baseline.policy.encoder.net.layers.0.2.module.2.weight', 'baseline.baseline.policy.encoder.net.layers.0.2.module.2.bias', 'baseline.baseline.policy.encoder.net.layers.0.3.normalizer.weight', 'baseline.baseline.policy.encoder.net.layers.0.3.normalizer.bias', 'baseline.baseline.policy.encoder.net.layers.0.3.normalizer.running_mean', 'baseline.baseline.policy.encoder.net.layers.0.3.normalizer.running_var', 'baseline.baseline.policy.encoder.net.layers.0.3.normalizer.num_batches_tracked', 'baseline.baseline.policy.encoder.net.layers.1.0.module.Wqkv.weight', 'baseline.baseline.policy.encoder.net.layers.1.0.module.Wqkv.bias', 'baseline.baseline.policy.encoder.net.layers.1.0.module.out_proj.weight', 'baseline.baseline.policy.encoder.net.layers.1.0.module.out_proj.bias', 'baseline.baseline.policy.encoder.net.layers.1.1.normalizer.weight', 'baseline.baseline.policy.encoder.net.layers.1.1.normalizer.bias', 'baseline.baseline.policy.encoder.net.layers.1.1.normalizer.running_mean', 'baseline.baseline.policy.encoder.net.layers.1.1.normalizer.running_var', 'baseline.baseline.policy.encoder.net.layers.1.1.normalizer.num_batches_tracked', 'baseline.baseline.policy.encoder.net.layers.1.2.module.0.weight', 'baseline.baseline.policy.encoder.net.layers.1.2.module.0.bias', 'baseline.baseline.policy.encoder.net.layers.1.2.module.2.weight', 'baseline.baseline.policy.encoder.net.layers.1.2.module.2.bias', 'baseline.baseline.policy.encoder.net.layers.1.3.normalizer.weight', 'baseline.baseline.policy.encoder.net.layers.1.3.normalizer.bias', 'baseline.baseline.policy.encoder.net.layers.1.3.normalizer.running_mean', 'baseline.baseline.policy.encoder.net.layers.1.3.normalizer.running_var', 'baseline.baseline.policy.encoder.net.layers.1.3.normalizer.num_batches_tracked', 'baseline.baseline.policy.encoder.net.layers.2.0.module.Wqkv.weight', 'baseline.baseline.policy.encoder.net.layers.2.0.module.Wqkv.bias', 'baseline.baseline.policy.encoder.net.layers.2.0.module.out_proj.weight', 'baseline.baseline.policy.encoder.net.layers.2.0.module.out_proj.bias', 'baseline.baseline.policy.encoder.net.layers.2.1.normalizer.weight', 'baseline.baseline.policy.encoder.net.layers.2.1.normalizer.bias', 'baseline.baseline.policy.encoder.net.layers.2.1.normalizer.running_mean', 'baseline.baseline.policy.encoder.net.layers.2.1.normalizer.running_var', 'baseline.baseline.policy.encoder.net.layers.2.1.normalizer.num_batches_tracked', 'baseline.baseline.policy.encoder.net.layers.2.2.module.0.weight', 'baseline.baseline.policy.encoder.net.layers.2.2.module.0.bias', 'baseline.baseline.policy.encoder.net.layers.2.2.module.2.weight', 'baseline.baseline.policy.encoder.net.layers.2.2.module.2.bias', 'baseline.baseline.policy.encoder.net.layers.2.3.normalizer.weight', 'baseline.baseline.policy.encoder.net.layers.2.3.normalizer.bias', 'baseline.baseline.policy.encoder.net.layers.2.3.normalizer.running_mean', 'baseline.baseline.policy.encoder.net.layers.2.3.normalizer.running_var', 'baseline.baseline.policy.encoder.net.layers.2.3.normalizer.num_batches_tracked', 'baseline.baseline.policy.decoder.context_embedding.W_placeholder', 'baseline.baseline.policy.decoder.context_embedding.project_context.weight', 'baseline.baseline.policy.decoder.pointer.project_out.weight', 'baseline.baseline.policy.decoder.project_node_embeddings.weight', 'baseline.baseline.policy.decoder.project_fixed_context.weight']\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n"
+     ]
+    }
+   ],
+   "source": [
+    "reviser_root_path = \"../../checkpoints/\" # NOTE: change to your path\n",
+    "reviser_size_list = [10, 20, 30, 40, 50]\n",
+    "\n",
+    "reviser_list = []\n",
+    "for reviser_idx, reviser_size in enumerate(reviser_size_list):\n",
+    "    env = SHPPEnv(generator_params={\"num_loc\": reviser_size}) \n",
+    "\n",
+    "    embed_dim = 128\n",
+    "\n",
+    "    policy = AttentionModelPolicy(\n",
+    "        embed_dim=embed_dim,\n",
+    "        env_name=env.name,\n",
+    "    )\n",
+    "\n",
+    "    reviser = AttentionModel(\n",
+    "        env,\n",
+    "        policy,\n",
+    "        baseline=\"rollout\",\n",
+    "        train_data_size=100_000,\n",
+    "        val_data_size=10_000,\n",
+    "        optimizer_kwargs={\"lr\": 1e-4},\n",
+    "    ) \n",
+    "    reviser.load_from_checkpoint(reviser_root_path + f\"{reviser_size}.ckpt\")\n",
+    "\n",
+    "    reviser_list.append(reviser)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Test GLOP inference logic and visualize middle results\n",
+    "\n",
+    "Before training the GLOP, this section could be useful to understand how the GLOP algorithm works and use it to debug."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Parameters\n",
+    "num_loc = 100\n",
+    "n_samples = 10\n",
+    "\n",
+    "# Create the environment\n",
+    "cvrp_env = CVRPEnv(generator_params={\"num_loc\": num_loc}) \n",
+    "\n",
+    "# Init policy\n",
+    "policy = GLOPPolicy(\n",
+    "    env_name=cvrp_env.name,\n",
+    "    n_samples=n_samples,\n",
+    "    revisers=reviser_list,\n",
+    ")\n",
+    "\n",
+    "# Test policy with greedy rollout with untrained model\n",
+    "device = \"cuda:1\"\n",
+    "policy = policy.to(device)\n",
+    "\n",
+    "td = cvrp_env.reset(batch_size=[3]).to(device)\n",
+    "out = policy(\n",
+    "    td=td.clone(),\n",
+    "    env=cvrp_env,\n",
+    "    phase=\"test\",\n",
+    "    return_actions=True,\n",
+    "    return_partitions=True,\n",
+    "    return_partitions_actions=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "out keys: dict_keys(['log_likelihood', 'reward', 'actions', 'partition', 'par_actions', 'revised_actions'])\n",
+      "Final   Actions Size [B*S, FL]  :\ttorch.Size([30, 288])\n",
+      "Heatmap Actions Size [B*S, HL]  :\ttorch.Size([30, 115])\n",
+      "Reviser Actions Size [B*S*P, PL]:\ttorch.Size([480, 18])\n",
+      "Partition       Size [B*S, P, L]:\ttorch.Size([30, 16, 18])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Print the information of outputs\n",
+    "print(f\"out keys: {out.keys()}\")\n",
+    "\n",
+    "reward = out['reward']\n",
+    "final_actions = out['actions']\n",
+    "heatmap_actions = out['par_actions']\n",
+    "reviser_actions = out['revised_actions']\n",
+    "partition = out['partition']\n",
+    "\n",
+    "print(f'Final   Actions Size [B*S, FL]  :\\t{final_actions.size()}')\n",
+    "print(f'Heatmap Actions Size [B*S, HL]  :\\t{heatmap_actions.size()}')\n",
+    "print(f'Reviser Actions Size [B*S*P, PL]:\\t{reviser_actions.size()}')\n",
+    "print(f'Partition       Size [B*S, P, L]:\\t{partition.size()}')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Choose the sample to visualize\n",
+    "batch_size = 3\n",
+    "batch_idx = 0\n",
+    "sample_idx = 0\n",
+    "case_idx = batch_idx * n_samples + sample_idx\n",
+    "n_partitions = out[\"partition\"].size(1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize the original problem\n",
+    "original_locs = td[\"locs\"][batch_idx].cpu().detach()\n",
+    "\n",
+    "# Plotting\n",
+    "fig, ax = plt.subplots(figsize=(4, 4))\n",
+    "\n",
+    "# Plot the cities\n",
+    "ax.scatter(original_locs[1:, 0], original_locs[1:, 1], c='b', s=10)\n",
+    "\n",
+    "# Plot the depot\n",
+    "ax.plot(original_locs[0, 0], original_locs[0, 1], 'rs', markersize=10)\n",
+    "\n",
+    "# Adding info\n",
+    "ax.set_title(\"Original Problem\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize the partition\n",
+    "nodes = out[\"partition\"][case_idx].cpu().detach() # [n_partitions, n_nodes]\n",
+    "original_locs = td[\"locs\"][batch_idx].cpu().detach() # [n_nodes, 2]\n",
+    "original_locs_expand = torch.repeat_interleave(original_locs.unsqueeze(0), nodes.size(0), dim=0) # [n_partitions, n_nodes, 2]\n",
+    "partition_locs = gather_by_index(original_locs_expand, nodes) # [n_partitions, n_nodes, 2]\n",
+    "\n",
+    "# Plotting\n",
+    "fig, ax = plt.subplots(figsize=(4, 4))\n",
+    "\n",
+    "# Plot the cities\n",
+    "for partition_idx in range(partition_locs.shape[0]):\n",
+    "    color = cm.Set1(partition_idx%8)\n",
+    "    ax.scatter(partition_locs[partition_idx, :, 0], partition_locs[partition_idx, :, 1], color=color, s=10)\n",
+    "\n",
+    "# Plot the depot\n",
+    "ax.plot(original_locs[0, 0], original_locs[0, 1], 'rs', markersize=10)\n",
+    "\n",
+    "# Adding info\n",
+    "ax.set_title(\"Partition of Nodes\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 400x400 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Visualize the reviser result for partitions\n",
+    "reviser_actions = out[\"revised_actions\"].cpu().detach() # [B*S*P, L]\n",
+    "reviser_actions_reshape = reviser_actions.view(batch_size*n_samples, n_partitions, -1) # [B*S, P, L]: should be the same size as out[\"partition\"]\n",
+    "partition_actions = out[\"partition\"].cpu().detach() # [B*S, P, L]\n",
+    "\n",
+    "partition_actions_revised = torch.gather(partition_actions, -1, reviser_actions_reshape) # [B*S, P, L]\n",
+    "partition_actions_revised_sample = partition_actions_revised[case_idx] # [P, L]\n",
+    "\n",
+    "# Adding the depot at the first place of each sequence\n",
+    "partition_actions_revised_sample = torch.cat([torch.zeros(partition_actions_revised_sample.size(0), 1).int(), partition_actions_revised_sample], dim=1)\n",
+    "\n",
+    "original_locs = td[\"locs\"][sample_idx].cpu().detach() # [n_nodes, 2]\n",
+    "original_locs_expand = torch.repeat_interleave(original_locs.unsqueeze(0), partition_actions_revised_sample.size(0), dim=0) # [P, n_nodes, 2]\n",
+    "locs_partition_revised = gather_by_index(original_locs_expand, partition_actions_revised_sample) # [P, L, 2]\n",
+    "\n",
+    "fig, ax = plt.subplots(figsize=(4, 4))\n",
+    "\n",
+    "# Plot the cities\n",
+    "for partition_idx in range(n_partitions):\n",
+    "    color = cm.Set1(partition_idx%8)\n",
+    "    ax.plot(locs_partition_revised[partition_idx, :, 0], locs_partition_revised[partition_idx, :, 1], color=color, marker='o', markersize=3)\n",
+    "\n",
+    "# Plot the depot\n",
+    "ax.plot(original_locs[0, 0], original_locs[0, 1], 'rs', markersize=10)\n",
+    "\n",
+    "# Adding info\n",
+    "ax.set_title(\"Partition of Nodes with Revised Routes\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Train the GLOP\n",
+    "\n",
+    "**NOTE** The current implementation of the GLOP algorithm is not training with some hidden bugs. We need to fix it. By running the following cell, you will find that the reward is not increasing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using 16bit Automatic Mixed Precision (AMP)\n",
+      "GPU available: True (cuda), used: True\n",
+      "TPU available: False, using: 0 TPU cores\n",
+      "IPU available: False, using: 0 IPUs\n",
+      "HPU available: False, using: 0 HPUs\n",
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:75: Starting from v1.9.0, `tensorboardX` has been removed as a dependency of the `lightning.pytorch` package, due to potential conflicts with other packages in the ML ecosystem. For this reason, `logger=True` will use `CSVLogger` as the default logger, unless the `tensorboard` or `tensorboardX` packages are found. Please `pip install lightning[extra]` or one of them to enable TensorBoard support by default\n",
+      "val_file not set. Generating dataset instead\n",
+      "test_file not set. Generating dataset instead\n",
+      "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0,1]\n",
+      "\n",
+      "  | Name     | Type           | Params\n",
+      "--------------------------------------------\n",
+      "0 | env      | CVRPEnv        | 0     \n",
+      "1 | policy   | GLOPPolicy     | 332 K \n",
+      "2 | baseline | SharedBaseline | 0     \n",
+      "--------------------------------------------\n",
+      "332 K     Trainable params\n",
+      "0         Non-trainable params\n",
+      "332 K     Total params\n",
+      "1.331     Total estimated model params size (MB)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Sanity Checking DataLoader 0:   0%|          | 0/2 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:441: The 'val_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=31` in the `DataLoader` to improve performance.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                                                           "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:441: The 'train_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=31` in the `DataLoader` to improve performance.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0:   8%|▊         | 26/313 [00:28<05:18,  0.90it/s, v_num=10, train/reward=-39.2, train/loss=-1.86] "
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/cbhua/miniconda/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/call.py:54: Detected KeyboardInterrupt, attempting graceful shutdown...\n"
+     ]
+    }
+   ],
+   "source": [
+    "num_loc = 100\n",
+    "n_samples = 10\n",
+    "\n",
+    "# Create the environment\n",
+    "cvrp_env = CVRPEnv(generator_params={\"num_loc\": num_loc}) \n",
+    "\n",
+    "# Init the GLOP model with loaded revisers\n",
+    "model = GLOP(\n",
+    "    env=cvrp_env, \n",
+    "    revisers=reviser_list,\n",
+    "    n_samples=n_samples,\n",
+    "    baseline=\"shared\",\n",
+    "    batch_size=32,\n",
+    "    train_data_size=10_000,\n",
+    "    val_data_size=1_000,\n",
+    "    optimizer_kwargs={\"lr\": 1e-4},\n",
+    ") \n",
+    "\n",
+    "trainer = RL4COTrainer(\n",
+    "    max_epochs=3,\n",
+    "    accelerator=\"gpu\",\n",
+    "    devices=[1],\n",
+    "    logger=None,\n",
+    ")\n",
+    "\n",
+    "trainer.fit(model)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "rl4co",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 4a16a9700536f859a2e1c65e32da258041723db2 Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 21:47:25 +0900
Subject: [PATCH 5/8] [Test] Adding SHPP pytest

---
 rl4co/utils/test_utils.py | 3 +++
 tests/test_envs.py        | 2 ++
 tests/test_policy.py      | 1 +
 3 files changed, 6 insertions(+)

diff --git a/rl4co/utils/test_utils.py b/rl4co/utils/test_utils.py
index baa7f31d..be280ebd 100644
--- a/rl4co/utils/test_utils.py
+++ b/rl4co/utils/test_utils.py
@@ -13,6 +13,7 @@
     SMTWTPEnv,
     SPCTSPEnv,
     TSPEnv,
+    SHPPEnv,
 )
 
 
@@ -41,6 +42,8 @@ def get_env(name, size):
         env = MDPPEnv()
     elif name == "smtwtp":
         env = SMTWTPEnv()
+    elif name == "shpp":
+        env = SHPPEnv()
     else:
         raise ValueError(f"Unknown env_name: {name}")
 
diff --git a/tests/test_envs.py b/tests/test_envs.py
index bd8d416b..f4365d7c 100644
--- a/tests/test_envs.py
+++ b/tests/test_envs.py
@@ -23,6 +23,7 @@
     SPCTSPEnv,
     SVRPEnv,
     TSPEnv,
+    SHPPEnv,
 )
 from rl4co.utils.decoding import random_policy, rollout
 
@@ -47,6 +48,7 @@
         ATSPEnv,
         MDCPDPEnv,
         FJSPEnv,
+        SHPPEnv,
     ],
 )
 def test_routing(env_cls, batch_size=2, size=20):
diff --git a/tests/test_policy.py b/tests/test_policy.py
index 05e4ceee..9b667d34 100644
--- a/tests/test_policy.py
+++ b/tests/test_policy.py
@@ -20,6 +20,7 @@
         "dpp",
         "mdpp",
         "smtwtp",
+        "shpp",
     ],
 )
 def test_am_policy(env_name, size=20, batch_size=2):

From 639292bb2fff7d1356b31f562baa494ae5757f45 Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 21:48:46 +0900
Subject: [PATCH 6/8] [Test] Adding GLOP to pytest

---
 tests/test_training.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/test_training.py b/tests/test_training.py
index 1e94a813..0f1cf010 100644
--- a/tests/test_training.py
+++ b/tests/test_training.py
@@ -16,6 +16,7 @@
     MatNet,
     NARGNNPolicy,
     SymNCO,
+    GLOP,
 )
 from rl4co.utils import RL4COTrainer
 

From e557b3d813593663a4688649dd0baa9ebb80050f Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Mon, 27 May 2024 22:34:45 +0900
Subject: [PATCH 7/8] [Debug] Support Python 3.8

---
 rl4co/models/zoo/glop/model.py  | 2 +-
 rl4co/models/zoo/glop/policy.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/rl4co/models/zoo/glop/model.py b/rl4co/models/zoo/glop/model.py
index 8c020094..c4284012 100644
--- a/rl4co/models/zoo/glop/model.py
+++ b/rl4co/models/zoo/glop/model.py
@@ -28,7 +28,7 @@ def __init__(
         env: RL4COEnvBase,
         policy: GLOPPolicy = None,
         baseline: Union[REINFORCEBaseline, str] = "shared",
-        revisers: list[Union[callable]] = None,
+        revisers: list = None,
         n_samples: int = 10,
         policy_kwargs={},
         baseline_kwargs={},
diff --git a/rl4co/models/zoo/glop/policy.py b/rl4co/models/zoo/glop/policy.py
index 6f5ffd9b..4c7a4b5b 100644
--- a/rl4co/models/zoo/glop/policy.py
+++ b/rl4co/models/zoo/glop/policy.py
@@ -45,7 +45,7 @@ def __init__(
         decoder: NonAutoregressiveDecoder = None,
         env_name: Union[str, RL4COEnvBase] = "tsp",
         n_samples: int = 10,
-        revisers: list[Union[callable]] = None,
+        revisers: list = None,
         **encoder_kwargs,
     ):
         if encoder is None:

From e718efb1b62fa9812f886b80bad948017366046a Mon Sep 17 00:00:00 2001
From: Chuanbo Hua <cbhua@kaist.ac.kr>
Date: Tue, 28 May 2024 22:30:01 +0900
Subject: [PATCH 8/8] [BugFix] Fix the unbatchify order reversed problem

Co-authored-by: Furffico <jerrywang0206@gmail.com>
---
 rl4co/models/zoo/glop/policy.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/rl4co/models/zoo/glop/policy.py b/rl4co/models/zoo/glop/policy.py
index 4c7a4b5b..a2156dad 100644
--- a/rl4co/models/zoo/glop/policy.py
+++ b/rl4co/models/zoo/glop/policy.py
@@ -132,11 +132,11 @@ def forward(
         out = {"log_likelihood": par_log_likelihood}
 
         if calc_reward:
-            best_revised_reward = unbatchify(best_revised_reward, (n_partitions))
+            best_revised_reward = rearrange(best_revised_reward, "(b p) -> b p", b=batch_size, p=n_partitions)
             best_revised_reward = best_revised_reward.sum(dim=-1)
             out["reward"] = best_revised_reward
         if return_actions:
-            final_actions = unbatchify(best_revised_actions, (n_partitions))
+            final_actions = rearrange(best_revised_actions, "(b p) l -> b p l", b=batch_size, p=n_partitions)
             final_actions = final_actions.flatten(start_dim=1)
             out["actions"] = final_actions
         if return_entropy: