diff --git a/notebooks/tutorials/7-decoding-strategies.ipynb b/notebooks/tutorials/7-decoding-strategies.ipynb
index 47c9f305..95e4937f 100644
--- a/notebooks/tutorials/7-decoding-strategies.ipynb
+++ b/notebooks/tutorials/7-decoding-strategies.ipynb
@@ -7,7 +7,7 @@
"source": [
"# RL4CO Decoding Strategies Notebook\n",
"\n",
- "This notebook demonstrates how to utilize the different decoding strategies available in rl4co/models/nn/dec_strategies.py during the different phases of model development. We will also demonstrate how to evaluate the model for different decoding strategies on the test dataset. \n",
+ "This notebook demonstrates how to utilize the different decoding strategies available in [rl4co/models/nn/dec_strategies.py](../../rl4co/models/nn/dec_strategies.py) during the different phases of model development. We will also demonstrate how to evaluate the model for different decoding strategies on the test dataset. \n",
"\n",
"\n"
]
@@ -22,7 +22,7 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 1,
"id": "7538da3e-67df-4c72-9acb-345a3bc9fba1",
"metadata": {},
"outputs": [],
@@ -36,7 +36,7 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 2,
"id": "4380f62f-bde8-4fc5-aa1a-072d5be58a32",
"metadata": {},
"outputs": [],
@@ -58,14 +58,14 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 3,
"id": "40c9a2ac-a2cc-4a90-a810-75a092fa4890",
"metadata": {},
"outputs": [],
"source": [
"%%capture\n",
"# RL4CO env based on TorchRL\n",
- "env = TSPEnv(num_loc=10) \n",
+ "env = TSPEnv(num_loc=20) \n",
"\n",
"# Policy: neural network, in this case with encoder-decoder architecture\n",
"policy = AttentionModelPolicy(env.name, \n",
@@ -80,7 +80,7 @@
" batch_size = 128,\n",
" val_batch_size = 512,\n",
" test_batch_size = 512,\n",
- " train_data_size=1_00,\n",
+ " train_data_size=20_000, # fast training for demo\n",
" val_data_size=1_000,\n",
" test_data_size=1_000,\n",
" optimizer_kwargs={\"lr\": 1e-4},\n",
@@ -102,14 +102,126 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 4,
"id": "38e7840f-c3b7-4f47-b694-f00db7f25896",
"metadata": {},
- "outputs": [],
+ "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",
+ "/datasets/home/botu/mambaforge/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/logger_connector/logger_connector.py:67: 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 | TSPEnv | 0 \n",
+ "1 | policy | AttentionModelPolicy | 710 K \n",
+ "2 | baseline | WarmupBaseline | 710 K \n",
+ "--------------------------------------------------\n",
+ "1.4 M Trainable params\n",
+ "0 Non-trainable params\n",
+ "1.4 M Total params\n",
+ "5.681 Total estimated model params size (MB)\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "16097f1a18e046ee993da874c54263e6",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Sanity Checking: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/datasets/home/botu/mambaforge/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=47` in the `DataLoader` to improve performance.\n",
+ "/datasets/home/botu/mambaforge/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=47` in the `DataLoader` to improve performance.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "db2c392d44f840d5a4c1b6987315a8b3",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Training: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "5996e8f68f7645a889561cdc197256c8",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Validation: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b4f95d1630324b2d90ce1fad6b67f226",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Validation: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "2ebe27fbc2c2445098425b46e77a3516",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Validation: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "`Trainer.fit` stopped: `max_epochs=3` reached.\n"
+ ]
+ }
+ ],
"source": [
"trainer = RL4COTrainer(\n",
- " max_epochs=2,\n",
- " logger=None,\n",
+ " max_epochs=3,\n",
+ " devices=1,\n",
")\n",
"\n",
"trainer.fit(model)"
@@ -125,12 +237,68 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 5,
"id": "ea794e13-5af6-41cc-b3cc-1a6b42520086",
"metadata": {
"scrolled": true
},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "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",
+ "/datasets/home/botu/mambaforge/envs/rl4co/lib/python3.11/site-packages/lightning/pytorch/trainer/connectors/data_connector.py:441: The 'test_dataloader' does not have many workers which may be a bottleneck. Consider increasing the value of the `num_workers` argument` to `num_workers=47` in the `DataLoader` to improve performance.\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "6e3647dbbbb840f7988c5813cd9221b9",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Testing: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃ Test metric ┃ DataLoader 0 ┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│ test/reward │ -4.0203351974487305 │\n",
+ "└───────────────────────────┴───────────────────────────┘\n",
+ "
\n"
+ ],
+ "text/plain": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test/reward \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m -4.0203351974487305 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "└───────────────────────────┴───────────────────────────┘\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "[{'test/reward': -4.0203351974487305}]"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"# here we evaluate the model on the test set using the beam search decoding strategy as declared in the model constructor\n",
"trainer.test(model=model)"
@@ -138,10 +306,65 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 6,
"id": "36ec98df-17d3-4250-9a9f-c1d510175934",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "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"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "2bc29132ff0b4f838994391e4dcacdcf",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Testing: | | 0/? [00:00, ?it/s]"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/html": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃ Test metric ┃ DataLoader 0 ┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│ test/reward │ -4.104068756103516 │\n",
+ "└───────────────────────────┴───────────────────────────┘\n",
+ "
\n"
+ ],
+ "text/plain": [
+ "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
+ "┃\u001b[1m \u001b[0m\u001b[1m Test metric \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m DataLoader 0 \u001b[0m\u001b[1m \u001b[0m┃\n",
+ "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
+ "│\u001b[36m \u001b[0m\u001b[36m test/reward \u001b[0m\u001b[36m \u001b[0m│\u001b[35m \u001b[0m\u001b[35m -4.104068756103516 \u001b[0m\u001b[35m \u001b[0m│\n",
+ "└───────────────────────────┴───────────────────────────┘\n"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "text/plain": [
+ "[{'test/reward': -4.104068756103516}]"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"# we can simply change the decoding type of the current model instance\n",
"model.policy.test_decode_type = \"greedy\"\n",
@@ -153,34 +376,66 @@
"id": "08f2744e-83ea-402a-83ec-94cbf12a0870",
"metadata": {},
"source": [
- "### Manual Test Loop\n",
+ "## Test Loop\n",
"\n",
"Let's compare beam search with a greedy decoding strategy by manually looping over our test dataset:"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "338b12d4",
+ "metadata": {},
+ "source": [
+ "### Greedy decoding"
+ ]
+ },
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 13,
"id": "f2b89503-f416-4b73-a5dc-1f1dfd7369e3",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Average reward is tensor(-4.1084)\n"
+ ]
+ }
+ ],
"source": [
"bs_rewards = []\n",
"for batch in model.test_dataloader():\n",
" td = env.reset(batch)\n",
" with torch.no_grad():\n",
" # in a manual loop we can dynamically specify the decode type\n",
- " out = model(td, decode_type=\"beam_search\", beam_width=10)\n",
+ " out = model(td, decode_type=\"beam_search\", beam_width=20)\n",
" bs_rewards.append(out[\"reward\"])\n",
"print(\"Average reward is %s\" % torch.cat(bs_rewards).mean())"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "a5bab7f4",
+ "metadata": {},
+ "source": [
+ "### Beam search decoding\n"
+ ]
+ },
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 14,
"id": "2103e579-d35f-4496-b401-47e9d3be7caa",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Average reward is tensor(-4.2222)\n"
+ ]
+ }
+ ],
"source": [
"bs_rewards = []\n",
"for batch in model.test_dataloader():\n",
@@ -191,19 +446,37 @@
"print(\"Average reward is %s\" % torch.cat(bs_rewards).mean())"
]
},
+ {
+ "cell_type": "markdown",
+ "id": "e1f1361c",
+ "metadata": {},
+ "source": [
+ "### Greedy multistart decoding\n",
+ "\n",
+ "Start from different nodes as done in POMO"
+ ]
+ },
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 15,
"id": "41b902d8-446a-4d3e-b14e-673560ca7af1",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Average reward is tensor(-4.0608)\n"
+ ]
+ }
+ ],
"source": [
"bs_rewards = []\n",
"for batch in model.test_dataloader():\n",
" td = env.reset(batch)\n",
" bs = batch.batch_size[0]\n",
" with torch.no_grad():\n",
- " out = model(td, decode_type=\"multistart_greedy\", num_starts=10, return_actions=True)\n",
+ " out = model(td, decode_type=\"multistart_greedy\", num_starts=20, return_actions=True)\n",
" rewards = torch.stack(out[\"reward\"].split(bs), 1).max(1).values\n",
" bs_rewards.append(rewards)\n",
"print(\"Average reward is %s\" % torch.cat(bs_rewards).mean())"
@@ -242,37 +515,20 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "id": "9d476c7a-aa23-45bb-b3e9-441992dcdf81",
- "metadata": {},
- "outputs": [],
- "source": [
- "td = env.reset(batch)"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "id": "b9e59a46-8aea-4739-a16d-913e3d3b8d0f",
- "metadata": {},
- "outputs": [],
- "source": [
- "bs = batch.batch_size[0]"
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
+ "execution_count": 10,
"id": "01727816-25ff-4a21-b092-b3a72be19343",
"metadata": {},
"outputs": [],
"source": [
+ "td = env.reset(batch)\n",
+ "bs = batch.batch_size[0]\n",
+ "\n",
"out = model(td, decode_type=\"beam_search\", beam_width=5, select_best=False, return_actions=True)"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 11,
"id": "5366d787-2ac7-4d0c-bffc-926d64c82b63",
"metadata": {},
"outputs": [],
@@ -284,10 +540,61 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 12,
"id": "7ee02330-965b-48f3-8cf8-ed20ed7e1af6",
"metadata": {},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "