Add files using upload-large-folder tool

.gitattributes

@@ -34,3 +34,11 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 short_paper_submission_icml_2026_workshop_CombiLatent.pdf filter=lfs diff=lfs merge=lfs -text
+src/xp0/.xdp-metrics_final.jpg filter=lfs diff=lfs merge=lfs -text
+src/xp0/.xdp-metropolized_filling.jpg filter=lfs diff=lfs merge=lfs -text
+src/xp0/datasets/flowshop_transformer_heatmaps.png filter=lfs diff=lfs merge=lfs -text
+src/xp0/datasets/no_sinkhorn_flowshop_transformer_heatmaps.png filter=lfs diff=lfs merge=lfs -text
+src/xp0/datasets/abla_1_flowshop_transformer_heatmaps.png filter=lfs diff=lfs merge=lfs -text
+src/xp0/datasets/abla_2_no_sinkhorn_flowshop_transformer_heatmaps.png filter=lfs diff=lfs merge=lfs -text
+src/xp0/datasets/abla_3_no_langevin_flowshop_transformer_heatmaps.png filter=lfs diff=lfs merge=lfs -text
+src/xp0/datasets/no_langevin_flowshop_transformer_heatmaps.png filter=lfs diff=lfs merge=lfs -text

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "python-envs.defaultEnvManager": "ms-python.python:conda",
+    "python-envs.defaultPackageManager": "ms-python.python:conda"
+}

miscellaneous/kool/attention-learn-to-route/.gitignore

@@ -0,0 +1,11 @@
+data/
+outputs/
+logs/
+results/
+__pycache__/
+.idea
+*/.ipynb_checkpoints
+*.tc.*
+*.tc_backward.*
+*.log
+*.bak

miscellaneous/kool/attention-learn-to-route/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Wouter Kool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

miscellaneous/kool/attention-learn-to-route/README.md

@@ -0,0 +1,117 @@
+> Note: I am currently not able to actively maintain this repository. Please also checkout more recent implementations, e.g. https://github.com/ai4co/rl4co and https://github.com/cpwan/RLOR.
+
+# Attention, Learn to Solve Routing Problems!
+
+Attention based model for learning to solve the Travelling Salesman Problem (TSP) and the Vehicle Routing Problem (VRP), Orienteering Problem (OP) and (Stochastic) Prize Collecting TSP (PCTSP). Training with REINFORCE with greedy rollout baseline.
+
+![TSP100](images/tsp.gif)
+
+## Paper
+For more details, please see our paper [Attention, Learn to Solve Routing Problems!](https://openreview.net/forum?id=ByxBFsRqYm) which has been accepted at [ICLR 2019](https://iclr.cc/Conferences/2019). If this code is useful for your work, please cite our paper:
+
+```
+@inproceedings{
+    kool2018attention,
+    title={Attention, Learn to Solve Routing Problems!},
+    author={Wouter Kool and Herke van Hoof and Max Welling},
+    booktitle={International Conference on Learning Representations},
+    year={2019},
+    url={https://openreview.net/forum?id=ByxBFsRqYm},
+}
+``` 
+
+## Dependencies
+
+* Python>=3.8
+* NumPy
+* SciPy
+* [PyTorch](http://pytorch.org/)>=1.7
+* tqdm
+* [tensorboard_logger](https://github.com/TeamHG-Memex/tensorboard_logger)
+* Matplotlib (optional, only for plotting)
+
+## Quick start
+
+For training TSP instances with 20 nodes and using rollout as REINFORCE baseline:
+```bash
+python run.py --graph_size 20 --baseline rollout --run_name 'tsp20_rollout'
+```
+
+## Usage
+
+### Generating data
+
+Training data is generated on the fly. To generate validation and test data (same as used in the paper) for all problems:
+```bash
+python generate_data.py --problem all --name validation --seed 4321
+python generate_data.py --problem all --name test --seed 1234
+```
+
+### Training
+
+For training TSP instances with 20 nodes and using rollout as REINFORCE baseline and using the generated validation set:
+```bash
+python run.py --graph_size 20 --baseline rollout --run_name 'tsp20_rollout' --val_dataset data/tsp/tsp20_validation_seed4321.pkl
+```
+
+#### Multiple GPUs
+By default, training will happen *on all available GPUs*. To disable CUDA at all, add the flag `--no_cuda`. 
+Set the environment variable `CUDA_VISIBLE_DEVICES` to only use specific GPUs:
+```bash
+CUDA_VISIBLE_DEVICES=2,3 python run.py 
+```
+Note that using multiple GPUs has limited efficiency for small problem sizes (up to 50 nodes).
+
+#### Warm start
+You can initialize a run using a pretrained model by using the `--load_path` option:
+```bash
+python run.py --graph_size 100 --load_path pretrained/tsp_100/epoch-99.pt
+```
+
+The `--load_path` option can also be used to load an earlier run, in which case also the optimizer state will be loaded:
+```bash
+python run.py --graph_size 20 --load_path 'outputs/tsp_20/tsp20_rollout_{datetime}/epoch-0.pt'
+```
+
+The `--resume` option can be used instead of the `--load_path` option, which will try to resume the run, e.g. load additionally the baseline state, set the current epoch/step counter and set the random number generator state.
+
+### Evaluation
+To evaluate a model, you can add the `--eval-only` flag to `run.py`, or use `eval.py`, which will additionally measure timing and save the results:
+```bash
+python eval.py data/tsp/tsp20_test_seed1234.pkl --model pretrained/tsp_20 --decode_strategy greedy
+```
+If the epoch is not specified, by default the last one in the folder will be used.
+
+#### Sampling
+To report the best of 1280 sampled solutions, use
+```bash
+python eval.py data/tsp/tsp20_test_seed1234.pkl --model pretrained/tsp_20 --decode_strategy sample --width 1280 --eval_batch_size 1
+```
+Beam Search (not in the paper) is also recently added and can be used using `--decode_strategy bs --width {beam_size}`.
+
+#### To run baselines
+Baselines for different problems are within the corresponding folders and can be ran (on multiple datasets at once) as follows
+```bash
+python -m problems.tsp.tsp_baseline farthest_insertion data/tsp/tsp20_test_seed1234.pkl data/tsp/tsp50_test_seed1234.pkl data/tsp/tsp100_test_seed1234.pkl
+```
+To run baselines, you need to install [Compass](https://github.com/bcamath-ds/compass) by running the `install_compass.sh` script from within the `problems/op` directory and [Concorde](http://www.math.uwaterloo.ca/tsp/concorde.html) using the `install_concorde.sh` script from within `problems/tsp`. [LKH3](http://akira.ruc.dk/~keld/research/LKH-3/) should be automatically downloaded and installed when required. To use [Gurobi](http://www.gurobi.com), obtain a ([free academic](http://www.gurobi.com/registration/academic-license-reg)) license and follow the [installation instructions](https://www.gurobi.com/documentation/8.1/quickstart_windows/installing_the_anaconda_py.html).
+
+### Other options and help
+```bash
+python run.py -h
+python eval.py -h
+```
+
+### Example CVRP solution
+See `plot_vrp.ipynb` for an example of loading a pretrained model and plotting the result for Capacitated VRP with 100 nodes.
+
+![CVRP100](images/cvrp_0.png)
+
+## Acknowledgements
+Thanks to [pemami4911/neural-combinatorial-rl-pytorch](https://github.com/pemami4911/neural-combinatorial-rl-pytorch) for getting me started with the code for the Pointer Network.
+
+This repository includes adaptions of the following repositories as baselines:
+* https://github.com/MichelDeudon/encode-attend-navigate
+* https://github.com/mc-ride/orienteering
+* https://github.com/jordanamecler/PCTSP
+* https://github.com/rafael2reis/salesman

miscellaneous/kool/attention-learn-to-route/data/tsp/.ipynb

@@ -0,0 +1,110 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "05cb491c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(10000, 100, 2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "import pickle\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "nb_spots = 100\n",
+    "\n",
+    "with open(f\"tsp{nb_spots}_test_seed1234.pkl\", \"rb\") as f:\n",
+    "    tsp_instances = pickle.load(f)\n",
+    "\n",
+    "tsp_instances = np.array(tsp_instances)\n",
+    "print(tsp_instances.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "40577ec0",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(100, 100)\n",
+      "55.11399205595661\n"
+     ]
+    }
+   ],
+   "source": [
+    "# compute the pairwise distances between the spots\n",
+    "distances = np.linalg.norm(tsp_instances[0][:, None, :] - tsp_instances[0][None, :, :], axis=-1)\n",
+    "print(distances.shape)\n",
+    "\n",
+    "# compute the tour length of the tour that visits the spots in the order they are given\n",
+    "# tour_schedule = np.arange(nb_spots)\n",
+    "tour_length = np.sum(distances[np.arange(nb_spots), np.arange(1, nb_spots + 1) % nb_spots])\n",
+    "print(tour_length)\n",
+    "\n",
+    "# plt.scatter(tsp_instances[0][:, 0], tsp_instances[0][:, 1])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a32e82e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.collections.PathCollection at 0x764d6b3549d0>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ai",
+   "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

miscellaneous/kool/attention-learn-to-route/environment.yml

@@ -0,0 +1,14 @@
+# run: conda env create --file environment.yml
+name: attention_tsp
+channels:
+- pytorch
+dependencies:
+- python>=3.8
+- anaconda
+- tqdm
+- pytorch
+- torchvision
+- cuda91
+- pip
+- pip:
+  - tensorboard_logger

miscellaneous/kool/attention-learn-to-route/eval.py

@@ -0,0 +1,216 @@
+import math
+import torch
+import os
+import argparse
+import numpy as np
+import itertools
+from tqdm import tqdm
+from utils import load_model, move_to
+from utils.data_utils import save_dataset
+from torch.utils.data import DataLoader
+import time
+from datetime import timedelta
+from utils.functions import parse_softmax_temperature
+mp = torch.multiprocessing.get_context('spawn')
+
+
+def get_best(sequences, cost, ids=None, batch_size=None):
+    """
+    Ids contains [0, 0, 0, 1, 1, 2, ..., n, n, n] if 3 solutions found for 0th instance, 2 for 1st, etc
+    :param sequences:
+    :param lengths:
+    :param ids:
+    :return: list with n sequences and list with n lengths of solutions
+    """
+    if ids is None:
+        idx = cost.argmin()
+        return sequences[idx:idx+1, ...], cost[idx:idx+1, ...]
+
+    splits = np.hstack([0, np.where(ids[:-1] != ids[1:])[0] + 1])
+    mincosts = np.minimum.reduceat(cost, splits)
+
+    group_lengths = np.diff(np.hstack([splits, len(ids)]))
+    all_argmin = np.flatnonzero(np.repeat(mincosts, group_lengths) == cost)
+    result = np.full(len(group_lengths) if batch_size is None else batch_size, -1, dtype=int)
+
+    result[ids[all_argmin[::-1]]] = all_argmin[::-1]
+
+    return [sequences[i] if i >= 0 else None for i in result], [cost[i] if i >= 0 else math.inf for i in result]
+
+
+def eval_dataset_mp(args):
+    (dataset_path, width, softmax_temp, opts, i, num_processes) = args
+
+    model, _ = load_model(opts.model)
+    val_size = opts.val_size // num_processes
+    dataset = model.problem.make_dataset(filename=dataset_path, num_samples=val_size, offset=opts.offset + val_size * i)
+    device = torch.device("cuda:{}".format(i))
+
+    return _eval_dataset(model, dataset, width, softmax_temp, opts, device)
+
+
+def eval_dataset(dataset_path, width, softmax_temp, opts):
+    # Even with multiprocessing, we load the model here since it contains the name where to write results
+    model, _ = load_model(opts.model)
+    use_cuda = torch.cuda.is_available() and not opts.no_cuda
+    if opts.multiprocessing:
+        assert use_cuda, "Can only do multiprocessing with cuda"
+        num_processes = torch.cuda.device_count()
+        assert opts.val_size % num_processes == 0
+
+        with mp.Pool(num_processes) as pool:
+            results = list(itertools.chain.from_iterable(pool.map(
+                eval_dataset_mp,
+                [(dataset_path, width, softmax_temp, opts, i, num_processes) for i in range(num_processes)]
+            )))
+
+    else:
+        device = torch.device("cuda:0" if use_cuda else "cpu")
+        dataset = model.problem.make_dataset(filename=dataset_path, num_samples=opts.val_size, offset=opts.offset)
+        results = _eval_dataset(model, dataset, width, softmax_temp, opts, device)
+
+    # This is parallelism, even if we use multiprocessing (we report as if we did not use multiprocessing, e.g. 1 GPU)
+    parallelism = opts.eval_batch_size
+
+    costs, tours, durations = zip(*results)  # Not really costs since they should be negative
+
+    print("Average cost: {} +- {}".format(np.mean(costs), 2 * np.std(costs) / np.sqrt(len(costs))))
+    print("Average serial duration: {} +- {}".format(
+        np.mean(durations), 2 * np.std(durations) / np.sqrt(len(durations))))
+    print("Average parallel duration: {}".format(np.mean(durations) / parallelism))
+    print("Calculated total duration: {}".format(timedelta(seconds=int(np.sum(durations) / parallelism))))
+
+    dataset_basename, ext = os.path.splitext(os.path.split(dataset_path)[-1])
+    model_name = "_".join(os.path.normpath(os.path.splitext(opts.model)[0]).split(os.sep)[-2:])
+    if opts.o is None:
+        results_dir = os.path.join(opts.results_dir, model.problem.NAME, dataset_basename)
+        os.makedirs(results_dir, exist_ok=True)
+
+        out_file = os.path.join(results_dir, "{}-{}-{}{}-t{}-{}-{}{}".format(
+            dataset_basename, model_name,
+            opts.decode_strategy,
+            width if opts.decode_strategy != 'greedy' else '',
+            softmax_temp, opts.offset, opts.offset + len(costs), ext
+        ))
+    else:
+        out_file = opts.o
+
+    assert opts.f or not os.path.isfile(
+        out_file), "File already exists! Try running with -f option to overwrite."
+
+    save_dataset((results, parallelism), out_file)
+
+    return costs, tours, durations
+
+
+def _eval_dataset(model, dataset, width, softmax_temp, opts, device):
+
+    model.to(device)
+    model.eval()
+
+    model.set_decode_type(
+        "greedy" if opts.decode_strategy in ('bs', 'greedy') else "sampling",
+        temp=softmax_temp)
+
+    dataloader = DataLoader(dataset, batch_size=opts.eval_batch_size)
+
+    results = []
+    for batch in tqdm(dataloader, disable=opts.no_progress_bar):
+        batch = move_to(batch, device)
+
+        start = time.time()
+        with torch.no_grad():
+            if opts.decode_strategy in ('sample', 'greedy'):
+                if opts.decode_strategy == 'greedy':
+                    assert width == 0, "Do not set width when using greedy"
+                    assert opts.eval_batch_size <= opts.max_calc_batch_size, \
+                        "eval_batch_size should be smaller than calc batch size"
+                    batch_rep = 1
+                    iter_rep = 1
+                elif width * opts.eval_batch_size > opts.max_calc_batch_size:
+                    assert opts.eval_batch_size == 1
+                    assert width % opts.max_calc_batch_size == 0
+                    batch_rep = opts.max_calc_batch_size
+                    iter_rep = width // opts.max_calc_batch_size
+                else:
+                    batch_rep = width
+                    iter_rep = 1
+                assert batch_rep > 0
+                # This returns (batch_size, iter_rep shape)
+                sequences, costs = model.sample_many(batch, batch_rep=batch_rep, iter_rep=iter_rep)
+                batch_size = len(costs)
+                ids = torch.arange(batch_size, dtype=torch.int64, device=costs.device)
+            else:
+                assert opts.decode_strategy == 'bs'
+
+                cum_log_p, sequences, costs, ids, batch_size = model.beam_search(
+                    batch, beam_size=width,
+                    compress_mask=opts.compress_mask,
+                    max_calc_batch_size=opts.max_calc_batch_size
+                )
+
+        if sequences is None:
+            sequences = [None] * batch_size
+            costs = [math.inf] * batch_size
+        else:
+            sequences, costs = get_best(
+                sequences.cpu().numpy(), costs.cpu().numpy(),
+                ids.cpu().numpy() if ids is not None else None,
+                batch_size
+            )
+        duration = time.time() - start
+        for seq, cost in zip(sequences, costs):
+            if model.problem.NAME == "tsp":
+                seq = seq.tolist()  # No need to trim as all are same length
+            elif model.problem.NAME in ("cvrp", "sdvrp"):
+                seq = np.trim_zeros(seq).tolist() + [0]  # Add depot
+            elif model.problem.NAME in ("op", "pctsp"):
+                seq = np.trim_zeros(seq)  # We have the convention to exclude the depot
+            else:
+                assert False, "Unkown problem: {}".format(model.problem.NAME)
+            # Note VRP only
+            results.append((cost, seq, duration))
+
+    return results
+
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("datasets", nargs='+', help="Filename of the dataset(s) to evaluate")
+    parser.add_argument("-f", action='store_true', help="Set true to overwrite")
+    parser.add_argument("-o", default=None, help="Name of the results file to write")
+    parser.add_argument('--val_size', type=int, default=10000,
+                        help='Number of instances used for reporting validation performance')
+    parser.add_argument('--offset', type=int, default=0,
+                        help='Offset where to start in dataset (default 0)')
+    parser.add_argument('--eval_batch_size', type=int, default=1024,
+                        help="Batch size to use during (baseline) evaluation")
+    # parser.add_argument('--decode_type', type=str, default='greedy',
+    #                     help='Decode type, greedy or sampling')
+    parser.add_argument('--width', type=int, nargs='+',
+                        help='Sizes of beam to use for beam search (or number of samples for sampling), '
+                             '0 to disable (default), -1 for infinite')
+    parser.add_argument('--decode_strategy', type=str,
+                        help='Beam search (bs), Sampling (sample) or Greedy (greedy)')
+    parser.add_argument('--softmax_temperature', type=parse_softmax_temperature, default=1,
+                        help="Softmax temperature (sampling or bs)")
+    parser.add_argument('--model', type=str)
+    parser.add_argument('--no_cuda', action='store_true', help='Disable CUDA')
+    parser.add_argument('--no_progress_bar', action='store_true', help='Disable progress bar')
+    parser.add_argument('--compress_mask', action='store_true', help='Compress mask into long')
+    parser.add_argument('--max_calc_batch_size', type=int, default=10000, help='Size for subbatches')
+    parser.add_argument('--results_dir', default='results', help="Name of results directory")
+    parser.add_argument('--multiprocessing', action='store_true',
+                        help='Use multiprocessing to parallelize over multiple GPUs')
+
+    opts = parser.parse_args()
+
+    assert opts.o is None or (len(opts.datasets) == 1 and len(opts.width) <= 1), \
+        "Cannot specify result filename with more than one dataset or more than one width"
+
+    widths = opts.width if opts.width is not None else [0]
+
+    for width in widths:
+        for dataset_path in opts.datasets:
+            eval_dataset(dataset_path, width, opts.softmax_temperature, opts)

miscellaneous/kool/attention-learn-to-route/generate_data.py

@@ -0,0 +1,167 @@
+import argparse
+import os
+import numpy as np
+from utils.data_utils import check_extension, save_dataset
+
+
+def generate_tsp_data(dataset_size, tsp_size):
+    return np.random.uniform(size=(dataset_size, tsp_size, 2)).tolist()
+
+
+def generate_vrp_data(dataset_size, vrp_size):
+    CAPACITIES = {
+        10: 20.,
+        20: 30.,
+        50: 40.,
+        100: 50.
+    }
+    return list(zip(
+        np.random.uniform(size=(dataset_size, 2)).tolist(),  # Depot location
+        np.random.uniform(size=(dataset_size, vrp_size, 2)).tolist(),  # Node locations
+        np.random.randint(1, 10, size=(dataset_size, vrp_size)).tolist(),  # Demand, uniform integer 1 ... 9
+        np.full(dataset_size, CAPACITIES[vrp_size]).tolist()  # Capacity, same for whole dataset
+    ))
+
+
+def generate_op_data(dataset_size, op_size, prize_type='const'):
+    depot = np.random.uniform(size=(dataset_size, 2))
+    loc = np.random.uniform(size=(dataset_size, op_size, 2))
+
+    # Methods taken from Fischetti et al. 1998
+    if prize_type == 'const':
+        prize = np.ones((dataset_size, op_size))
+    elif prize_type == 'unif':
+        prize = (1 + np.random.randint(0, 100, size=(dataset_size, op_size))) / 100.
+    else:  # Based on distance to depot
+        assert prize_type == 'dist'
+        prize_ = np.linalg.norm(depot[:, None, :] - loc, axis=-1)
+        prize = (1 + (prize_ / prize_.max(axis=-1, keepdims=True) * 99).astype(int)) / 100.
+
+    # Max length is approximately half of optimal TSP tour, such that half (a bit more) of the nodes can be visited
+    # which is maximally difficult as this has the largest number of possibilities
+    MAX_LENGTHS = {
+        20: 2.,
+        50: 3.,
+        100: 4.
+    }
+
+    return list(zip(
+        depot.tolist(),
+        loc.tolist(),
+        prize.tolist(),
+        np.full(dataset_size, MAX_LENGTHS[op_size]).tolist()  # Capacity, same for whole dataset
+    ))
+
+
+def generate_pctsp_data(dataset_size, pctsp_size, penalty_factor=3):
+    depot = np.random.uniform(size=(dataset_size, 2))
+    loc = np.random.uniform(size=(dataset_size, pctsp_size, 2))
+
+    # For the penalty to make sense it should be not too large (in which case all nodes will be visited) nor too small
+    # so we want the objective term to be approximately equal to the length of the tour, which we estimate with half
+    # of the nodes by half of the tour length (which is very rough but similar to op)
+    # This means that the sum of penalties for all nodes will be approximately equal to the tour length (on average)
+    # The expected total (uniform) penalty of half of the nodes (since approx half will be visited by the constraint)
+    # is (n / 2) / 2 = n / 4 so divide by this means multiply by 4 / n,
+    # However instead of 4 we use penalty_factor (3 works well) so we can make them larger or smaller
+    MAX_LENGTHS = {
+        20: 2.,
+        50: 3.,
+        100: 4.
+    }
+    penalty_max = MAX_LENGTHS[pctsp_size] * (penalty_factor) / float(pctsp_size)
+    penalty = np.random.uniform(size=(dataset_size, pctsp_size)) * penalty_max
+
+    # Take uniform prizes
+    # Now expectation is 0.5 so expected total prize is n / 2, we want to force to visit approximately half of the nodes
+    # so the constraint will be that total prize >= (n / 2) / 2 = n / 4
+    # equivalently, we divide all prizes by n / 4 and the total prize should be >= 1
+    deterministic_prize = np.random.uniform(size=(dataset_size, pctsp_size)) * 4 / float(pctsp_size)
+
+    # In the deterministic setting, the stochastic_prize is not used and the deterministic prize is known
+    # In the stochastic setting, the deterministic prize is the expected prize and is known up front but the
+    # stochastic prize is only revealed once the node is visited
+    # Stochastic prize is between (0, 2 * expected_prize) such that E(stochastic prize) = E(deterministic_prize)
+    stochastic_prize = np.random.uniform(size=(dataset_size, pctsp_size)) * deterministic_prize * 2
+
+    return list(zip(
+        depot.tolist(),
+        loc.tolist(),
+        penalty.tolist(),
+        deterministic_prize.tolist(),
+        stochastic_prize.tolist()
+    ))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--filename", help="Filename of the dataset to create (ignores datadir)")
+    parser.add_argument("--data_dir", default='data', help="Create datasets in data_dir/problem (default 'data')")
+    parser.add_argument("--name", type=str, required=True, help="Name to identify dataset")
+    parser.add_argument("--problem", type=str, default='all',
+                        help="Problem, 'tsp', 'vrp', 'pctsp' or 'op_const', 'op_unif' or 'op_dist'"
+                             " or 'all' to generate all")
+    parser.add_argument('--data_distribution', type=str, default='all',
+                        help="Distributions to generate for problem, default 'all'.")
+
+    parser.add_argument("--dataset_size", type=int, default=10000, help="Size of the dataset")
+    parser.add_argument('--graph_sizes', type=int, nargs='+', default=[20, 50, 100],
+                        help="Sizes of problem instances (default 20, 50, 100)")
+    parser.add_argument("-f", action='store_true', help="Set true to overwrite")
+    parser.add_argument('--seed', type=int, default=1234, help="Random seed")
+
+    opts = parser.parse_args()
+
+    assert opts.filename is None or (len(opts.problems) == 1 and len(opts.graph_sizes) == 1), \
+        "Can only specify filename when generating a single dataset"
+
+    distributions_per_problem = {
+        'tsp': [None],
+        'vrp': [None],
+        'pctsp': [None],
+        'op': ['const', 'unif', 'dist']
+    }
+    if opts.problem == 'all':
+        problems = distributions_per_problem
+    else:
+        problems = {
+            opts.problem:
+                distributions_per_problem[opts.problem]
+                if opts.data_distribution == 'all'
+                else [opts.data_distribution]
+        }
+
+    for problem, distributions in problems.items():
+        for distribution in distributions or [None]:
+            for graph_size in opts.graph_sizes:
+
+                datadir = os.path.join(opts.data_dir, problem)
+                os.makedirs(datadir, exist_ok=True)
+
+                if opts.filename is None:
+                    filename = os.path.join(datadir, "{}{}{}_{}_seed{}.pkl".format(
+                        problem,
+                        "_{}".format(distribution) if distribution is not None else "",
+                        graph_size, opts.name, opts.seed))
+                else:
+                    filename = check_extension(opts.filename)
+
+                assert opts.f or not os.path.isfile(check_extension(filename)), \
+                    "File already exists! Try running with -f option to overwrite."
+
+                np.random.seed(opts.seed)
+                if problem == 'tsp':
+                    dataset = generate_tsp_data(opts.dataset_size, graph_size)
+                elif problem == 'vrp':
+                    dataset = generate_vrp_data(
+                        opts.dataset_size, graph_size)
+                elif problem == 'pctsp':
+                    dataset = generate_pctsp_data(opts.dataset_size, graph_size)
+                elif problem == "op":
+                    dataset = generate_op_data(opts.dataset_size, graph_size, prize_type=distribution)
+                else:
+                    assert False, "Unknown problem: {}".format(problem)
+
+                print(dataset[0])
+
+                save_dataset(dataset, filename)

miscellaneous/kool/attention-learn-to-route/nets/attention_model.py

@@ -0,0 +1,513 @@
+import torch
+from torch import nn
+from torch.utils.checkpoint import checkpoint
+import math
+from typing import NamedTuple
+from utils.tensor_functions import compute_in_batches
+
+from nets.graph_encoder import GraphAttentionEncoder
+from torch.nn import DataParallel
+from utils.beam_search import CachedLookup
+from utils.functions import sample_many
+
+
+def set_decode_type(model, decode_type):
+    if isinstance(model, DataParallel):
+        model = model.module
+    model.set_decode_type(decode_type)
+
+
+class AttentionModelFixed(NamedTuple):
+    """
+    Context for AttentionModel decoder that is fixed during decoding so can be precomputed/cached
+    This class allows for efficient indexing of multiple Tensors at once
+    """
+    node_embeddings: torch.Tensor
+    context_node_projected: torch.Tensor
+    glimpse_key: torch.Tensor
+    glimpse_val: torch.Tensor
+    logit_key: torch.Tensor
+
+    def __getitem__(self, key):
+        assert torch.is_tensor(key) or isinstance(key, slice)
+        return AttentionModelFixed(
+            node_embeddings=self.node_embeddings[key],
+            context_node_projected=self.context_node_projected[key],
+            glimpse_key=self.glimpse_key[:, key],  # dim 0 are the heads
+            glimpse_val=self.glimpse_val[:, key],  # dim 0 are the heads
+            logit_key=self.logit_key[key]
+        )
+
+
+class AttentionModel(nn.Module):
+
+    def __init__(self,
+                 embedding_dim,
+                 hidden_dim,
+                 problem,
+                 n_encode_layers=2,
+                 tanh_clipping=10.,
+                 mask_inner=True,
+                 mask_logits=True,
+                 normalization='batch',
+                 n_heads=8,
+                 checkpoint_encoder=False,
+                 shrink_size=None):
+        super(AttentionModel, self).__init__()
+
+        self.embedding_dim = embedding_dim
+        self.hidden_dim = hidden_dim
+        self.n_encode_layers = n_encode_layers
+        self.decode_type = None
+        self.temp = 1.0
+        self.allow_partial = problem.NAME == 'sdvrp'
+        self.is_vrp = problem.NAME == 'cvrp' or problem.NAME == 'sdvrp'
+        self.is_orienteering = problem.NAME == 'op'
+        self.is_pctsp = problem.NAME == 'pctsp'
+
+        self.tanh_clipping = tanh_clipping
+
+        self.mask_inner = mask_inner
+        self.mask_logits = mask_logits
+
+        self.problem = problem
+        self.n_heads = n_heads
+        self.checkpoint_encoder = checkpoint_encoder
+        self.shrink_size = shrink_size
+
+        # Problem specific context parameters (placeholder and step context dimension)
+        if self.is_vrp or self.is_orienteering or self.is_pctsp:
+            # Embedding of last node + remaining_capacity / remaining length / remaining prize to collect
+            step_context_dim = embedding_dim + 1
+
+            if self.is_pctsp:
+                node_dim = 4  # x, y, expected_prize, penalty
+            else:
+                node_dim = 3  # x, y, demand / prize
+
+            # Special embedding projection for depot node
+            self.init_embed_depot = nn.Linear(2, embedding_dim)
+            
+            if self.is_vrp and self.allow_partial:  # Need to include the demand if split delivery allowed
+                self.project_node_step = nn.Linear(1, 3 * embedding_dim, bias=False)
+        else:  # TSP
+            assert problem.NAME == "tsp", "Unsupported problem: {}".format(problem.NAME)
+            step_context_dim = 2 * embedding_dim  # Embedding of first and last node
+            node_dim = 2  # x, y
+            
+            # Learned input symbols for first action
+            self.W_placeholder = nn.Parameter(torch.Tensor(2 * embedding_dim))
+            self.W_placeholder.data.uniform_(-1, 1)  # Placeholder should be in range of activations
+
+        self.init_embed = nn.Linear(node_dim, embedding_dim)
+
+        self.embedder = GraphAttentionEncoder(
+            n_heads=n_heads,
+            embed_dim=embedding_dim,
+            n_layers=self.n_encode_layers,
+            normalization=normalization
+        )
+
+        # For each node we compute (glimpse key, glimpse value, logit key) so 3 * embedding_dim
+        self.project_node_embeddings = nn.Linear(embedding_dim, 3 * embedding_dim, bias=False)
+        self.project_fixed_context = nn.Linear(embedding_dim, embedding_dim, bias=False)
+        self.project_step_context = nn.Linear(step_context_dim, embedding_dim, bias=False)
+        assert embedding_dim % n_heads == 0
+        # Note n_heads * val_dim == embedding_dim so input to project_out is embedding_dim
+        self.project_out = nn.Linear(embedding_dim, embedding_dim, bias=False)
+
+    def set_decode_type(self, decode_type, temp=None):
+        self.decode_type = decode_type
+        if temp is not None:  # Do not change temperature if not provided
+            self.temp = temp
+
+    def forward(self, input, return_pi=False):
+        """
+        :param input: (batch_size, graph_size, node_dim) input node features or dictionary with multiple tensors
+        :param return_pi: whether to return the output sequences, this is optional as it is not compatible with
+        using DataParallel as the results may be of different lengths on different GPUs
+        :return:
+        """
+
+        if self.checkpoint_encoder and self.training:  # Only checkpoint if we need gradients
+            embeddings, _ = checkpoint(self.embedder, self._init_embed(input))
+        else:
+            embeddings, _ = self.embedder(self._init_embed(input))
+
+        _log_p, pi = self._inner(input, embeddings)
+
+        cost, mask = self.problem.get_costs(input, pi)
+        # Log likelyhood is calculated within the model since returning it per action does not work well with
+        # DataParallel since sequences can be of different lengths
+        ll = self._calc_log_likelihood(_log_p, pi, mask)
+        if return_pi:
+            return cost, ll, pi
+
+        return cost, ll
+
+    def beam_search(self, *args, **kwargs):
+        return self.problem.beam_search(*args, **kwargs, model=self)
+
+    def precompute_fixed(self, input):
+        embeddings, _ = self.embedder(self._init_embed(input))
+        # Use a CachedLookup such that if we repeatedly index this object with the same index we only need to do
+        # the lookup once... this is the case if all elements in the batch have maximum batch size
+        return CachedLookup(self._precompute(embeddings))
+
+    def propose_expansions(self, beam, fixed, expand_size=None, normalize=False, max_calc_batch_size=4096):
+        # First dim = batch_size * cur_beam_size
+        log_p_topk, ind_topk = compute_in_batches(
+            lambda b: self._get_log_p_topk(fixed[b.ids], b.state, k=expand_size, normalize=normalize),
+            max_calc_batch_size, beam, n=beam.size()
+        )
+
+        assert log_p_topk.size(1) == 1, "Can only have single step"
+        # This will broadcast, calculate log_p (score) of expansions
+        score_expand = beam.score[:, None] + log_p_topk[:, 0, :]
+
+        # We flatten the action as we need to filter and this cannot be done in 2d
+        flat_action = ind_topk.view(-1)
+        flat_score = score_expand.view(-1)
+        flat_feas = flat_score > -1e10  # != -math.inf triggers
+
+        # Parent is row idx of ind_topk, can be found by enumerating elements and dividing by number of columns
+        flat_parent = torch.arange(flat_action.size(-1), out=flat_action.new()) // ind_topk.size(-1)
+
+        # Filter infeasible
+        feas_ind_2d = torch.nonzero(flat_feas)
+
+        if len(feas_ind_2d) == 0:
+            # Too bad, no feasible expansions at all :(
+            return None, None, None
+
+        feas_ind = feas_ind_2d[:, 0]
+
+        return flat_parent[feas_ind], flat_action[feas_ind], flat_score[feas_ind]
+
+    def _calc_log_likelihood(self, _log_p, a, mask):
+
+        # Get log_p corresponding to selected actions
+        log_p = _log_p.gather(2, a.unsqueeze(-1)).squeeze(-1)
+
+        # Optional: mask out actions irrelevant to objective so they do not get reinforced
+        if mask is not None:
+            log_p[mask] = 0
+
+        assert (log_p > -1000).data.all(), "Logprobs should not be -inf, check sampling procedure!"
+
+        # Calculate log_likelihood
+        return log_p.sum(1)
+
+    def _init_embed(self, input):
+
+        if self.is_vrp or self.is_orienteering or self.is_pctsp:
+            if self.is_vrp:
+                features = ('demand', )
+            elif self.is_orienteering:
+                features = ('prize', )
+            else:
+                assert self.is_pctsp
+                features = ('deterministic_prize', 'penalty')
+            return torch.cat(
+                (
+                    self.init_embed_depot(input['depot'])[:, None, :],
+                    self.init_embed(torch.cat((
+                        input['loc'],
+                        *(input[feat][:, :, None] for feat in features)
+                    ), -1))
+                ),
+                1
+            )
+        # TSP
+        return self.init_embed(input)
+
+    def _inner(self, input, embeddings):
+
+        outputs = []
+        sequences = []
+
+        state = self.problem.make_state(input)
+
+        # Compute keys, values for the glimpse and keys for the logits once as they can be reused in every step
+        fixed = self._precompute(embeddings)
+
+        batch_size = state.ids.size(0)
+
+        # Perform decoding steps
+        i = 0
+        while not (self.shrink_size is None and state.all_finished()):
+
+            if self.shrink_size is not None:
+                unfinished = torch.nonzero(state.get_finished() == 0)
+                if len(unfinished) == 0:
+                    break
+                unfinished = unfinished[:, 0]
+                # Check if we can shrink by at least shrink_size and if this leaves at least 16
+                # (otherwise batch norm will not work well and it is inefficient anyway)
+                if 16 <= len(unfinished) <= state.ids.size(0) - self.shrink_size:
+                    # Filter states
+                    state = state[unfinished]
+                    fixed = fixed[unfinished]
+
+            log_p, mask = self._get_log_p(fixed, state)
+
+            # Select the indices of the next nodes in the sequences, result (batch_size) long
+            selected = self._select_node(log_p.exp()[:, 0, :], mask[:, 0, :])  # Squeeze out steps dimension
+
+            state = state.update(selected)
+
+            # Now make log_p, selected desired output size by 'unshrinking'
+            if self.shrink_size is not None and state.ids.size(0) < batch_size:
+                log_p_, selected_ = log_p, selected
+                log_p = log_p_.new_zeros(batch_size, *log_p_.size()[1:])
+                selected = selected_.new_zeros(batch_size)
+
+                log_p[state.ids[:, 0]] = log_p_
+                selected[state.ids[:, 0]] = selected_
+
+            # Collect output of step
+            outputs.append(log_p[:, 0, :])
+            sequences.append(selected)
+
+            i += 1
+
+        # Collected lists, return Tensor
+        return torch.stack(outputs, 1), torch.stack(sequences, 1)
+
+    def sample_many(self, input, batch_rep=1, iter_rep=1):
+        """
+        :param input: (batch_size, graph_size, node_dim) input node features
+        :return:
+        """
+        # Bit ugly but we need to pass the embeddings as well.
+        # Making a tuple will not work with the problem.get_cost function
+        return sample_many(
+            lambda input: self._inner(*input),  # Need to unpack tuple into arguments
+            lambda input, pi: self.problem.get_costs(input[0], pi),  # Don't need embeddings as input to get_costs
+            (input, self.embedder(self._init_embed(input))[0]),  # Pack input with embeddings (additional input)
+            batch_rep, iter_rep
+        )
+
+    def _select_node(self, probs, mask):
+
+        assert (probs == probs).all(), "Probs should not contain any nans"
+
+        if self.decode_type == "greedy":
+            _, selected = probs.max(1)
+            assert not mask.gather(1, selected.unsqueeze(
+                -1)).data.any(), "Decode greedy: infeasible action has maximum probability"
+
+        elif self.decode_type == "sampling":
+            selected = probs.multinomial(1).squeeze(1)
+
+            # Check if sampling went OK, can go wrong due to bug on GPU
+            # See https://discuss.pytorch.org/t/bad-behavior-of-multinomial-function/10232
+            while mask.gather(1, selected.unsqueeze(-1)).data.any():
+                print('Sampled bad values, resampling!')
+                selected = probs.multinomial(1).squeeze(1)
+
+        else:
+            assert False, "Unknown decode type"
+        return selected
+
+    def _precompute(self, embeddings, num_steps=1):
+
+        # The fixed context projection of the graph embedding is calculated only once for efficiency
+        graph_embed = embeddings.mean(1)
+        # fixed context = (batch_size, 1, embed_dim) to make broadcastable with parallel timesteps
+        fixed_context = self.project_fixed_context(graph_embed)[:, None, :]
+
+        # The projection of the node embeddings for the attention is calculated once up front
+        glimpse_key_fixed, glimpse_val_fixed, logit_key_fixed = \
+            self.project_node_embeddings(embeddings[:, None, :, :]).chunk(3, dim=-1)
+
+        # No need to rearrange key for logit as there is a single head
+        fixed_attention_node_data = (
+            self._make_heads(glimpse_key_fixed, num_steps),
+            self._make_heads(glimpse_val_fixed, num_steps),
+            logit_key_fixed.contiguous()
+        )
+        return AttentionModelFixed(embeddings, fixed_context, *fixed_attention_node_data)
+
+    def _get_log_p_topk(self, fixed, state, k=None, normalize=True):
+        log_p, _ = self._get_log_p(fixed, state, normalize=normalize)
+
+        # Return topk
+        if k is not None and k < log_p.size(-1):
+            return log_p.topk(k, -1)
+
+        # Return all, note different from torch.topk this does not give error if less than k elements along dim
+        return (
+            log_p,
+            torch.arange(log_p.size(-1), device=log_p.device, dtype=torch.int64).repeat(log_p.size(0), 1)[:, None, :]
+        )
+
+    def _get_log_p(self, fixed, state, normalize=True):
+
+        # Compute query = context node embedding
+        query = fixed.context_node_projected + \
+                self.project_step_context(self._get_parallel_step_context(fixed.node_embeddings, state))
+
+        # Compute keys and values for the nodes
+        glimpse_K, glimpse_V, logit_K = self._get_attention_node_data(fixed, state)
+
+        # Compute the mask
+        mask = state.get_mask()
+
+        # Compute logits (unnormalized log_p)
+        log_p, glimpse = self._one_to_many_logits(query, glimpse_K, glimpse_V, logit_K, mask)
+
+        if normalize:
+            log_p = torch.log_softmax(log_p / self.temp, dim=-1)
+
+        assert not torch.isnan(log_p).any()
+
+        return log_p, mask
+
+    def _get_parallel_step_context(self, embeddings, state, from_depot=False):
+        """
+        Returns the context per step, optionally for multiple steps at once (for efficient evaluation of the model)
+        
+        :param embeddings: (batch_size, graph_size, embed_dim)
+        :param prev_a: (batch_size, num_steps)
+        :param first_a: Only used when num_steps = 1, action of first step or None if first step
+        :return: (batch_size, num_steps, context_dim)
+        """
+
+        current_node = state.get_current_node()
+        batch_size, num_steps = current_node.size()
+
+        if self.is_vrp:
+            # Embedding of previous node + remaining capacity
+            if from_depot:
+                # 1st dimension is node idx, but we do not squeeze it since we want to insert step dimension
+                # i.e. we actually want embeddings[:, 0, :][:, None, :] which is equivalent
+                return torch.cat(
+                    (
+                        embeddings[:, 0:1, :].expand(batch_size, num_steps, embeddings.size(-1)),
+                        # used capacity is 0 after visiting depot
+                        self.problem.VEHICLE_CAPACITY - torch.zeros_like(state.used_capacity[:, :, None])
+                    ),
+                    -1
+                )
+            else:
+                return torch.cat(
+                    (
+                        torch.gather(
+                            embeddings,
+                            1,
+                            current_node.contiguous()
+                                .view(batch_size, num_steps, 1)
+                                .expand(batch_size, num_steps, embeddings.size(-1))
+                        ).view(batch_size, num_steps, embeddings.size(-1)),
+                        self.problem.VEHICLE_CAPACITY - state.used_capacity[:, :, None]
+                    ),
+                    -1
+                )
+        elif self.is_orienteering or self.is_pctsp:
+            return torch.cat(
+                (
+                    torch.gather(
+                        embeddings,
+                        1,
+                        current_node.contiguous()
+                            .view(batch_size, num_steps, 1)
+                            .expand(batch_size, num_steps, embeddings.size(-1))
+                    ).view(batch_size, num_steps, embeddings.size(-1)),
+                    (
+                        state.get_remaining_length()[:, :, None]
+                        if self.is_orienteering
+                        else state.get_remaining_prize_to_collect()[:, :, None]
+                    )
+                ),
+                -1
+            )
+        else:  # TSP
+        
+            if num_steps == 1:  # We need to special case if we have only 1 step, may be the first or not
+                if state.i.item() == 0:
+                    # First and only step, ignore prev_a (this is a placeholder)
+                    return self.W_placeholder[None, None, :].expand(batch_size, 1, self.W_placeholder.size(-1))
+                else:
+                    return embeddings.gather(
+                        1,
+                        torch.cat((state.first_a, current_node), 1)[:, :, None].expand(batch_size, 2, embeddings.size(-1))
+                    ).view(batch_size, 1, -1)
+            # More than one step, assume always starting with first
+            embeddings_per_step = embeddings.gather(
+                1,
+                current_node[:, 1:, None].expand(batch_size, num_steps - 1, embeddings.size(-1))
+            )
+            return torch.cat((
+                # First step placeholder, cat in dim 1 (time steps)
+                self.W_placeholder[None, None, :].expand(batch_size, 1, self.W_placeholder.size(-1)),
+                # Second step, concatenate embedding of first with embedding of current/previous (in dim 2, context dim)
+                torch.cat((
+                    embeddings_per_step[:, 0:1, :].expand(batch_size, num_steps - 1, embeddings.size(-1)),
+                    embeddings_per_step
+                ), 2)
+            ), 1)
+
+    def _one_to_many_logits(self, query, glimpse_K, glimpse_V, logit_K, mask):
+
+        batch_size, num_steps, embed_dim = query.size()
+        key_size = val_size = embed_dim // self.n_heads
+
+        # Compute the glimpse, rearrange dimensions so the dimensions are (n_heads, batch_size, num_steps, 1, key_size)
+        glimpse_Q = query.view(batch_size, num_steps, self.n_heads, 1, key_size).permute(2, 0, 1, 3, 4)
+
+        # Batch matrix multiplication to compute compatibilities (n_heads, batch_size, num_steps, graph_size)
+        compatibility = torch.matmul(glimpse_Q, glimpse_K.transpose(-2, -1)) / math.sqrt(glimpse_Q.size(-1))
+        if self.mask_inner:
+            assert self.mask_logits, "Cannot mask inner without masking logits"
+            compatibility[mask[None, :, :, None, :].expand_as(compatibility)] = -math.inf
+
+        # Batch matrix multiplication to compute heads (n_heads, batch_size, num_steps, val_size)
+        heads = torch.matmul(torch.softmax(compatibility, dim=-1), glimpse_V)
+
+        # Project to get glimpse/updated context node embedding (batch_size, num_steps, embedding_dim)
+        glimpse = self.project_out(
+            heads.permute(1, 2, 3, 0, 4).contiguous().view(-1, num_steps, 1, self.n_heads * val_size))
+
+        # Now projecting the glimpse is not needed since this can be absorbed into project_out
+        # final_Q = self.project_glimpse(glimpse)
+        final_Q = glimpse
+        # Batch matrix multiplication to compute logits (batch_size, num_steps, graph_size)
+        # logits = 'compatibility'
+        logits = torch.matmul(final_Q, logit_K.transpose(-2, -1)).squeeze(-2) / math.sqrt(final_Q.size(-1))
+
+        # From the logits compute the probabilities by clipping, masking and softmax
+        if self.tanh_clipping > 0:
+            logits = torch.tanh(logits) * self.tanh_clipping
+        if self.mask_logits:
+            logits[mask] = -math.inf
+
+        return logits, glimpse.squeeze(-2)
+
+    def _get_attention_node_data(self, fixed, state):
+
+        if self.is_vrp and self.allow_partial:
+
+            # Need to provide information of how much each node has already been served
+            # Clone demands as they are needed by the backprop whereas they are updated later
+            glimpse_key_step, glimpse_val_step, logit_key_step = \
+                self.project_node_step(state.demands_with_depot[:, :, :, None].clone()).chunk(3, dim=-1)
+
+            # Projection of concatenation is equivalent to addition of projections but this is more efficient
+            return (
+                fixed.glimpse_key + self._make_heads(glimpse_key_step),
+                fixed.glimpse_val + self._make_heads(glimpse_val_step),
+                fixed.logit_key + logit_key_step,
+            )
+
+        # TSP or VRP without split delivery
+        return fixed.glimpse_key, fixed.glimpse_val, fixed.logit_key
+
+    def _make_heads(self, v, num_steps=None):
+        assert num_steps is None or v.size(1) == 1 or v.size(1) == num_steps
+
+        return (
+            v.contiguous().view(v.size(0), v.size(1), v.size(2), self.n_heads, -1)
+            .expand(v.size(0), v.size(1) if num_steps is None else num_steps, v.size(2), self.n_heads, -1)
+            .permute(3, 0, 1, 2, 4)  # (n_heads, batch_size, num_steps, graph_size, head_dim)
+        )

miscellaneous/kool/attention-learn-to-route/nets/critic_network.py

@@ -0,0 +1,40 @@
+from torch import nn
+from nets.graph_encoder import GraphAttentionEncoder
+
+
+class CriticNetwork(nn.Module):
+
+    def __init__(
+        self,
+        input_dim,
+        embedding_dim,
+        hidden_dim,
+        n_layers,
+        encoder_normalization
+    ):
+        super(CriticNetwork, self).__init__()
+
+        self.hidden_dim = hidden_dim
+
+        self.encoder = GraphAttentionEncoder(
+            node_dim=input_dim,
+            n_heads=8,
+            embed_dim=embedding_dim,
+            n_layers=n_layers,
+            normalization=encoder_normalization
+        )
+
+        self.value_head = nn.Sequential(
+            nn.Linear(embedding_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, 1)
+        )
+
+    def forward(self, inputs):
+        """
+
+        :param inputs: (batch_size, graph_size, input_dim)
+        :return:
+        """
+        _, graph_embeddings = self.encoder(inputs)
+        return self.value_head(graph_embeddings)

miscellaneous/kool/attention-learn-to-route/nets/graph_encoder.py

@@ -0,0 +1,215 @@
+import torch
+import numpy as np
+from torch import nn
+import math
+
+
+class SkipConnection(nn.Module):
+
+    def __init__(self, module):
+        super(SkipConnection, self).__init__()
+        self.module = module
+
+    def forward(self, input):
+        return input + self.module(input)
+
+
+class MultiHeadAttention(nn.Module):
+    def __init__(
+            self,
+            n_heads,
+            input_dim,
+            embed_dim,
+            val_dim=None,
+            key_dim=None
+    ):
+        super(MultiHeadAttention, self).__init__()
+
+        if val_dim is None:
+            val_dim = embed_dim // n_heads
+        if key_dim is None:
+            key_dim = val_dim
+
+        self.n_heads = n_heads
+        self.input_dim = input_dim
+        self.embed_dim = embed_dim
+        self.val_dim = val_dim
+        self.key_dim = key_dim
+
+        self.norm_factor = 1 / math.sqrt(key_dim)  # See Attention is all you need
+
+        self.W_query = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim))
+        self.W_key = nn.Parameter(torch.Tensor(n_heads, input_dim, key_dim))
+        self.W_val = nn.Parameter(torch.Tensor(n_heads, input_dim, val_dim))
+
+        self.W_out = nn.Parameter(torch.Tensor(n_heads, val_dim, embed_dim))
+
+        self.init_parameters()
+
+    def init_parameters(self):
+
+        for param in self.parameters():
+            stdv = 1. / math.sqrt(param.size(-1))
+            param.data.uniform_(-stdv, stdv)
+
+    def forward(self, q, h=None, mask=None):
+        """
+
+        :param q: queries (batch_size, n_query, input_dim)
+        :param h: data (batch_size, graph_size, input_dim)
+        :param mask: mask (batch_size, n_query, graph_size) or viewable as that (i.e. can be 2 dim if n_query == 1)
+        Mask should contain 1 if attention is not possible (i.e. mask is negative adjacency)
+        :return:
+        """
+        if h is None:
+            h = q  # compute self-attention
+
+        # h should be (batch_size, graph_size, input_dim)
+        batch_size, graph_size, input_dim = h.size()
+        n_query = q.size(1)
+        assert q.size(0) == batch_size
+        assert q.size(2) == input_dim
+        assert input_dim == self.input_dim, "Wrong embedding dimension of input"
+
+        hflat = h.contiguous().view(-1, input_dim)
+        qflat = q.contiguous().view(-1, input_dim)
+
+        # last dimension can be different for keys and values
+        shp = (self.n_heads, batch_size, graph_size, -1)
+        shp_q = (self.n_heads, batch_size, n_query, -1)
+
+        # Calculate queries, (n_heads, n_query, graph_size, key/val_size)
+        Q = torch.matmul(qflat, self.W_query).view(shp_q)
+        # Calculate keys and values (n_heads, batch_size, graph_size, key/val_size)
+        K = torch.matmul(hflat, self.W_key).view(shp)
+        V = torch.matmul(hflat, self.W_val).view(shp)
+
+        # Calculate compatibility (n_heads, batch_size, n_query, graph_size)
+        compatibility = self.norm_factor * torch.matmul(Q, K.transpose(2, 3))
+
+        # Optionally apply mask to prevent attention
+        if mask is not None:
+            mask = mask.view(1, batch_size, n_query, graph_size).expand_as(compatibility)
+            compatibility[mask] = -np.inf
+
+        attn = torch.softmax(compatibility, dim=-1)
+
+        # If there are nodes with no neighbours then softmax returns nan so we fix them to 0
+        if mask is not None:
+            attnc = attn.clone()
+            attnc[mask] = 0
+            attn = attnc
+
+        heads = torch.matmul(attn, V)
+
+        out = torch.mm(
+            heads.permute(1, 2, 0, 3).contiguous().view(-1, self.n_heads * self.val_dim),
+            self.W_out.view(-1, self.embed_dim)
+        ).view(batch_size, n_query, self.embed_dim)
+
+        # Alternative:
+        # headst = heads.transpose(0, 1)  # swap the dimensions for batch and heads to align it for the matmul
+        # # proj_h = torch.einsum('bhni,hij->bhnj', headst, self.W_out)
+        # projected_heads = torch.matmul(headst, self.W_out)
+        # out = torch.sum(projected_heads, dim=1)  # sum across heads
+
+        # Or:
+        # out = torch.einsum('hbni,hij->bnj', heads, self.W_out)
+
+        return out
+
+
+class Normalization(nn.Module):
+
+    def __init__(self, embed_dim, normalization='batch'):
+        super(Normalization, self).__init__()
+
+        normalizer_class = {
+            'batch': nn.BatchNorm1d,
+            'instance': nn.InstanceNorm1d
+        }.get(normalization, None)
+
+        self.normalizer = normalizer_class(embed_dim, affine=True)
+
+        # Normalization by default initializes affine parameters with bias 0 and weight unif(0,1) which is too large!
+        # self.init_parameters()
+
+    def init_parameters(self):
+
+        for name, param in self.named_parameters():
+            stdv = 1. / math.sqrt(param.size(-1))
+            param.data.uniform_(-stdv, stdv)
+
+    def forward(self, input):
+
+        if isinstance(self.normalizer, nn.BatchNorm1d):
+            return self.normalizer(input.view(-1, input.size(-1))).view(*input.size())
+        elif isinstance(self.normalizer, nn.InstanceNorm1d):
+            return self.normalizer(input.permute(0, 2, 1)).permute(0, 2, 1)
+        else:
+            assert self.normalizer is None, "Unknown normalizer type"
+            return input
+
+
+class MultiHeadAttentionLayer(nn.Sequential):
+
+    def __init__(
+            self,
+            n_heads,
+            embed_dim,
+            feed_forward_hidden=512,
+            normalization='batch',
+    ):
+        super(MultiHeadAttentionLayer, self).__init__(
+            SkipConnection(
+                MultiHeadAttention(
+                    n_heads,
+                    input_dim=embed_dim,
+                    embed_dim=embed_dim
+                )
+            ),
+            Normalization(embed_dim, normalization),
+            SkipConnection(
+                nn.Sequential(
+                    nn.Linear(embed_dim, feed_forward_hidden),
+                    nn.ReLU(),
+                    nn.Linear(feed_forward_hidden, embed_dim)
+                ) if feed_forward_hidden > 0 else nn.Linear(embed_dim, embed_dim)
+            ),
+            Normalization(embed_dim, normalization)
+        )
+
+
+class GraphAttentionEncoder(nn.Module):
+    def __init__(
+            self,
+            n_heads,
+            embed_dim,
+            n_layers,
+            node_dim=None,
+            normalization='batch',
+            feed_forward_hidden=512
+    ):
+        super(GraphAttentionEncoder, self).__init__()
+
+        # To map input to embedding space
+        self.init_embed = nn.Linear(node_dim, embed_dim) if node_dim is not None else None
+
+        self.layers = nn.Sequential(*(
+            MultiHeadAttentionLayer(n_heads, embed_dim, feed_forward_hidden, normalization)
+            for _ in range(n_layers)
+        ))
+
+    def forward(self, x, mask=None):
+
+        assert mask is None, "TODO mask not yet supported!"
+
+        # Batch multiply to get initial embeddings of nodes
+        h = self.init_embed(x.view(-1, x.size(-1))).view(*x.size()[:2], -1) if self.init_embed is not None else x
+
+        h = self.layers(h)
+
+        return (
+            h,  # (batch_size, graph_size, embed_dim)
+            h.mean(dim=1),  # average to get embedding of graph, (batch_size, embed_dim)
+        )

miscellaneous/kool/attention-learn-to-route/nets/pointer_network.py

@@ -0,0 +1,353 @@
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import math
+import numpy as np
+
+
+class Encoder(nn.Module):
+    """Maps a graph represented as an input sequence
+    to a hidden vector"""
+    def __init__(self, input_dim, hidden_dim):
+        super(Encoder, self).__init__()
+        self.hidden_dim = hidden_dim
+        self.lstm = nn.LSTM(input_dim, hidden_dim)
+        self.init_hx, self.init_cx = self.init_hidden(hidden_dim)
+
+    def forward(self, x, hidden):
+        output, hidden = self.lstm(x, hidden)
+        return output, hidden
+    
+    def init_hidden(self, hidden_dim):
+        """Trainable initial hidden state"""
+        std = 1. / math.sqrt(hidden_dim)
+        enc_init_hx = nn.Parameter(torch.FloatTensor(hidden_dim))
+        enc_init_hx.data.uniform_(-std, std)
+
+        enc_init_cx = nn.Parameter(torch.FloatTensor(hidden_dim))
+        enc_init_cx.data.uniform_(-std, std)
+        return enc_init_hx, enc_init_cx
+
+
+class Attention(nn.Module):
+    """A generic attention module for a decoder in seq2seq"""
+    def __init__(self, dim, use_tanh=False, C=10):
+        super(Attention, self).__init__()
+        self.use_tanh = use_tanh
+        self.project_query = nn.Linear(dim, dim)
+        self.project_ref = nn.Conv1d(dim, dim, 1, 1)
+        self.C = C  # tanh exploration
+        self.tanh = nn.Tanh()
+
+        self.v = nn.Parameter(torch.FloatTensor(dim))
+        self.v.data.uniform_(-(1. / math.sqrt(dim)), 1. / math.sqrt(dim))
+        
+    def forward(self, query, ref):
+        """
+        Args: 
+            query: is the hidden state of the decoder at the current
+                time step. batch x dim
+            ref: the set of hidden states from the encoder. 
+                sourceL x batch x hidden_dim
+        """
+        # ref is now [batch_size x hidden_dim x sourceL]
+        ref = ref.permute(1, 2, 0)
+        q = self.project_query(query).unsqueeze(2)  # batch x dim x 1
+        e = self.project_ref(ref)  # batch_size x hidden_dim x sourceL 
+        # expand the query by sourceL
+        # batch x dim x sourceL
+        expanded_q = q.repeat(1, 1, e.size(2)) 
+        # batch x 1 x hidden_dim
+        v_view = self.v.unsqueeze(0).expand(
+                expanded_q.size(0), len(self.v)).unsqueeze(1)
+        # [batch_size x 1 x hidden_dim] * [batch_size x hidden_dim x sourceL]
+        u = torch.bmm(v_view, self.tanh(expanded_q + e)).squeeze(1)
+        if self.use_tanh:
+            logits = self.C * self.tanh(u)
+        else:
+            logits = u  
+        return e, logits
+
+
+class Decoder(nn.Module):
+    def __init__(self, 
+            embedding_dim,
+            hidden_dim,
+            tanh_exploration,
+            use_tanh,
+            n_glimpses=1,
+            mask_glimpses=True,
+            mask_logits=True):
+        super(Decoder, self).__init__()
+
+        self.embedding_dim = embedding_dim
+        self.hidden_dim = hidden_dim
+        self.n_glimpses = n_glimpses
+        self.mask_glimpses = mask_glimpses
+        self.mask_logits = mask_logits
+        self.use_tanh = use_tanh
+        self.tanh_exploration = tanh_exploration
+        self.decode_type = None  # Needs to be set explicitly before use
+
+        self.lstm = nn.LSTMCell(embedding_dim, hidden_dim)
+        self.pointer = Attention(hidden_dim, use_tanh=use_tanh, C=tanh_exploration)
+        self.glimpse = Attention(hidden_dim, use_tanh=False)
+        self.sm = nn.Softmax(dim=1)
+
+    def update_mask(self, mask, selected):
+        return mask.clone().scatter_(1, selected.unsqueeze(-1), True)
+
+    def recurrence(self, x, h_in, prev_mask, prev_idxs, step, context):
+
+        logit_mask = self.update_mask(prev_mask, prev_idxs) if prev_idxs is not None else prev_mask
+
+        logits, h_out = self.calc_logits(x, h_in, logit_mask, context, self.mask_glimpses, self.mask_logits)
+
+        # Calculate log_softmax for better numerical stability
+        log_p = torch.log_softmax(logits, dim=1)
+        probs = log_p.exp()
+
+        if not self.mask_logits:
+            # If self.mask_logits, this would be redundant, otherwise we must mask to make sure we don't resample
+            # Note that as a result the vector of probs may not sum to one (this is OK for .multinomial sampling)
+            # But practically by not masking the logits, a model is learned over all sequences (also infeasible)
+            # while only during sampling feasibility is enforced (a.k.a. by setting to 0. here)
+            probs[logit_mask] = 0.
+            # For consistency we should also mask out in log_p, but the values set to 0 will not be sampled and
+            # Therefore not be used by the reinforce estimator
+
+        return h_out, log_p, probs, logit_mask
+
+    def calc_logits(self, x, h_in, logit_mask, context, mask_glimpses=None, mask_logits=None):
+
+        if mask_glimpses is None:
+            mask_glimpses = self.mask_glimpses
+
+        if mask_logits is None:
+            mask_logits = self.mask_logits
+
+        hy, cy = self.lstm(x, h_in)
+        g_l, h_out = hy, (hy, cy)
+
+        for i in range(self.n_glimpses):
+            ref, logits = self.glimpse(g_l, context)
+            # For the glimpses, only mask before softmax so we have always an L1 norm 1 readout vector
+            if mask_glimpses:
+                logits[logit_mask] = -np.inf
+            # [batch_size x h_dim x sourceL] * [batch_size x sourceL x 1] =
+            # [batch_size x h_dim x 1]
+            g_l = torch.bmm(ref, self.sm(logits).unsqueeze(2)).squeeze(2)
+        _, logits = self.pointer(g_l, context)
+
+        # Masking before softmax makes probs sum to one
+        if mask_logits:
+            logits[logit_mask] = -np.inf
+
+        return logits, h_out
+
+    def forward(self, decoder_input, embedded_inputs, hidden, context, eval_tours=None):
+        """
+        Args:
+            decoder_input: The initial input to the decoder
+                size is [batch_size x embedding_dim]. Trainable parameter.
+            embedded_inputs: [sourceL x batch_size x embedding_dim]
+            hidden: the prev hidden state, size is [batch_size x hidden_dim]. 
+                Initially this is set to (enc_h[-1], enc_c[-1])
+            context: encoder outputs, [sourceL x batch_size x hidden_dim] 
+        """
+
+        batch_size = context.size(1)
+        outputs = []
+        selections = []
+        steps = range(embedded_inputs.size(0))
+        idxs = None
+        mask = Variable(
+            embedded_inputs.data.new().byte().new(embedded_inputs.size(1), embedded_inputs.size(0)).zero_(),
+            requires_grad=False
+        )
+
+        for i in steps:
+            hidden, log_p, probs, mask = self.recurrence(decoder_input, hidden, mask, idxs, i, context)
+            # select the next inputs for the decoder [batch_size x hidden_dim]
+            idxs = self.decode(
+                probs,
+                mask
+            ) if eval_tours is None else eval_tours[:, i]
+
+            idxs = idxs.detach()  # Otherwise pytorch complains it want's a reward, todo implement this more properly?
+
+            # Gather input embedding of selected
+            decoder_input = torch.gather(
+                embedded_inputs,
+                0,
+                idxs.contiguous().view(1, batch_size, 1).expand(1, batch_size, *embedded_inputs.size()[2:])
+            ).squeeze(0)
+
+            # use outs to point to next object
+            outputs.append(log_p)
+            selections.append(idxs)
+        return (torch.stack(outputs, 1), torch.stack(selections, 1)), hidden
+
+    def decode(self, probs, mask):
+        if self.decode_type == "greedy":
+            _, idxs = probs.max(1)
+            assert not mask.gather(1, idxs.unsqueeze(-1)).data.any(), \
+                "Decode greedy: infeasible action has maximum probability"
+        elif self.decode_type == "sampling":
+            idxs = probs.multinomial(1).squeeze(1)
+            # Check if sampling went OK, can go wrong due to bug on GPU
+            while mask.gather(1, idxs.unsqueeze(-1)).data.any():
+                print(' [!] resampling due to race condition')
+                idxs = probs.multinomial().squeeze(1)
+        else:
+            assert False, "Unknown decode type"
+
+        return idxs
+
+
+class CriticNetworkLSTM(nn.Module):
+    """Useful as a baseline in REINFORCE updates"""
+    def __init__(self,
+            embedding_dim,
+            hidden_dim,
+            n_process_block_iters,
+            tanh_exploration,
+            use_tanh):
+        super(CriticNetworkLSTM, self).__init__()
+        
+        self.hidden_dim = hidden_dim
+        self.n_process_block_iters = n_process_block_iters
+
+        self.encoder = Encoder(embedding_dim, hidden_dim)
+        
+        self.process_block = Attention(hidden_dim, use_tanh=use_tanh, C=tanh_exploration)
+        self.sm = nn.Softmax(dim=1)
+        self.decoder = nn.Sequential(
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, 1)
+        )
+
+    def forward(self, inputs):
+        """
+        Args:
+            inputs: [embedding_dim x batch_size x sourceL] of embedded inputs
+        """
+        inputs = inputs.transpose(0, 1).contiguous()
+
+        encoder_hx = self.encoder.init_hx.unsqueeze(0).repeat(inputs.size(1), 1).unsqueeze(0)
+        encoder_cx = self.encoder.init_cx.unsqueeze(0).repeat(inputs.size(1), 1).unsqueeze(0)
+        
+        # encoder forward pass
+        enc_outputs, (enc_h_t, enc_c_t) = self.encoder(inputs, (encoder_hx, encoder_cx))
+        
+        # grab the hidden state and process it via the process block 
+        process_block_state = enc_h_t[-1]
+        for i in range(self.n_process_block_iters):
+            ref, logits = self.process_block(process_block_state, enc_outputs)
+            process_block_state = torch.bmm(ref, self.sm(logits).unsqueeze(2)).squeeze(2)
+        # produce the final scalar output
+        out = self.decoder(process_block_state)
+        return out
+
+
+class PointerNetwork(nn.Module):
+
+    def __init__(self,
+                 embedding_dim,
+                 hidden_dim,
+                 problem,
+                 n_encode_layers=None,
+                 tanh_clipping=10.,
+                 mask_inner=True,
+                 mask_logits=True,
+                 normalization=None,
+                 **kwargs):
+        super(PointerNetwork, self).__init__()
+
+        self.problem = problem
+        assert problem.NAME == "tsp", "Pointer Network only supported for TSP"
+        self.input_dim = 2
+
+        self.encoder = Encoder(
+            embedding_dim,
+            hidden_dim)
+
+        self.decoder = Decoder(
+            embedding_dim,
+            hidden_dim,
+            tanh_exploration=tanh_clipping,
+            use_tanh=tanh_clipping > 0,
+            n_glimpses=1,
+            mask_glimpses=mask_inner,
+            mask_logits=mask_logits
+        )
+
+        # Trainable initial hidden states
+        std = 1. / math.sqrt(embedding_dim)
+        self.decoder_in_0 = nn.Parameter(torch.FloatTensor(embedding_dim))
+        self.decoder_in_0.data.uniform_(-std, std)
+
+        self.embedding = nn.Parameter(torch.FloatTensor(self.input_dim, embedding_dim))
+        self.embedding.data.uniform_(-std, std)
+
+    def set_decode_type(self, decode_type):
+        self.decoder.decode_type = decode_type
+
+    def forward(self, inputs, eval_tours=None, return_pi=False):
+        batch_size, graph_size, input_dim = inputs.size()
+
+        embedded_inputs = torch.mm(
+            inputs.transpose(0, 1).contiguous().view(-1, input_dim),
+            self.embedding
+        ).view(graph_size, batch_size, -1)
+
+        # query the actor net for the input indices 
+        # making up the output, and the pointer attn 
+        _log_p, pi = self._inner(embedded_inputs, eval_tours)
+
+        cost, mask = self.problem.get_costs(inputs, pi)
+        # Log likelyhood is calculated within the model since returning it per action does not work well with
+        # DataParallel since sequences can be of different lengths
+        ll = self._calc_log_likelihood(_log_p, pi, mask)
+        if return_pi:
+            return cost, ll, pi
+
+        return cost, ll
+
+    def _calc_log_likelihood(self, _log_p, a, mask):
+
+        # Get log_p corresponding to selected actions
+        log_p = _log_p.gather(2, a.unsqueeze(-1)).squeeze(-1)
+
+        # Optional: mask out actions irrelevant to objective so they do not get reinforced
+        if mask is not None:
+            log_p[mask] = 0
+
+        assert (log_p > -1000).data.all(), "Logprobs should not be -inf, check sampling procedure!"
+
+        # Calculate log_likelihood
+        return log_p.sum(1)
+
+    def _inner(self, inputs, eval_tours=None):
+
+        encoder_hx = encoder_cx = Variable(
+            torch.zeros(1, inputs.size(1), self.encoder.hidden_dim, out=inputs.data.new()),
+            requires_grad=False
+        )
+
+        # encoder forward pass
+        enc_h, (enc_h_t, enc_c_t) = self.encoder(inputs, (encoder_hx, encoder_cx))
+
+        dec_init_state = (enc_h_t[-1], enc_c_t[-1])
+
+        # repeat decoder_in_0 across batch
+        decoder_input = self.decoder_in_0.unsqueeze(0).repeat(inputs.size(1), 1)
+
+        (pointer_probs, input_idxs), dec_hidden_t = self.decoder(decoder_input,
+                                                                 inputs,
+                                                                 dec_init_state,
+                                                                 enc_h,
+                                                                 eval_tours)
+
+        return pointer_probs, input_idxs

miscellaneous/kool/attention-learn-to-route/options.py

@@ -0,0 +1,87 @@
+import os
+import time
+import argparse
+import torch
+
+
+def get_options(args=None):
+    parser = argparse.ArgumentParser(
+        description="Attention based model for solving the Travelling Salesman Problem with Reinforcement Learning")
+
+    # Data
+    parser.add_argument('--problem', default='tsp', help="The problem to solve, default 'tsp'")
+    parser.add_argument('--graph_size', type=int, default=20, help="The size of the problem graph")
+    parser.add_argument('--batch_size', type=int, default=512, help='Number of instances per batch during training')
+    parser.add_argument('--epoch_size', type=int, default=1280000, help='Number of instances per epoch during training')
+    parser.add_argument('--val_size', type=int, default=10000,
+                        help='Number of instances used for reporting validation performance')
+    parser.add_argument('--val_dataset', type=str, default=None, help='Dataset file to use for validation')
+
+    # Model
+    parser.add_argument('--model', default='attention', help="Model, 'attention' (default) or 'pointer'")
+    parser.add_argument('--embedding_dim', type=int, default=128, help='Dimension of input embedding')
+    parser.add_argument('--hidden_dim', type=int, default=128, help='Dimension of hidden layers in Enc/Dec')
+    parser.add_argument('--n_encode_layers', type=int, default=3,
+                        help='Number of layers in the encoder/critic network')
+    parser.add_argument('--tanh_clipping', type=float, default=10.,
+                        help='Clip the parameters to within +- this value using tanh. '
+                             'Set to 0 to not perform any clipping.')
+    parser.add_argument('--normalization', default='batch', help="Normalization type, 'batch' (default) or 'instance'")
+
+    # Training
+    parser.add_argument('--lr_model', type=float, default=1e-4, help="Set the learning rate for the actor network")
+    parser.add_argument('--lr_critic', type=float, default=1e-4, help="Set the learning rate for the critic network")
+    parser.add_argument('--lr_decay', type=float, default=1.0, help='Learning rate decay per epoch')
+    parser.add_argument('--eval_only', action='store_true', help='Set this value to only evaluate model')
+    parser.add_argument('--n_epochs', type=int, default=100, help='The number of epochs to train')
+    parser.add_argument('--seed', type=int, default=1234, help='Random seed to use')
+    parser.add_argument('--max_grad_norm', type=float, default=1.0,
+                        help='Maximum L2 norm for gradient clipping, default 1.0 (0 to disable clipping)')
+    parser.add_argument('--no_cuda', action='store_true', help='Disable CUDA')
+    parser.add_argument('--exp_beta', type=float, default=0.8,
+                        help='Exponential moving average baseline decay (default 0.8)')
+    parser.add_argument('--baseline', default=None,
+                        help="Baseline to use: 'rollout', 'critic' or 'exponential'. Defaults to no baseline.")
+    parser.add_argument('--bl_alpha', type=float, default=0.05,
+                        help='Significance in the t-test for updating rollout baseline')
+    parser.add_argument('--bl_warmup_epochs', type=int, default=None,
+                        help='Number of epochs to warmup the baseline, default None means 1 for rollout (exponential '
+                             'used for warmup phase), 0 otherwise. Can only be used with rollout baseline.')
+    parser.add_argument('--eval_batch_size', type=int, default=1024,
+                        help="Batch size to use during (baseline) evaluation")
+    parser.add_argument('--checkpoint_encoder', action='store_true',
+                        help='Set to decrease memory usage by checkpointing encoder')
+    parser.add_argument('--shrink_size', type=int, default=None,
+                        help='Shrink the batch size if at least this many instances in the batch are finished'
+                             ' to save memory (default None means no shrinking)')
+    parser.add_argument('--data_distribution', type=str, default=None,
+                        help='Data distribution to use during training, defaults and options depend on problem.')
+
+    # Misc
+    parser.add_argument('--log_step', type=int, default=50, help='Log info every log_step steps')
+    parser.add_argument('--log_dir', default='logs', help='Directory to write TensorBoard information to')
+    parser.add_argument('--run_name', default='run', help='Name to identify the run')
+    parser.add_argument('--output_dir', default='outputs', help='Directory to write output models to')
+    parser.add_argument('--epoch_start', type=int, default=0,
+                        help='Start at epoch # (relevant for learning rate decay)')
+    parser.add_argument('--checkpoint_epochs', type=int, default=1,
+                        help='Save checkpoint every n epochs (default 1), 0 to save no checkpoints')
+    parser.add_argument('--load_path', help='Path to load model parameters and optimizer state from')
+    parser.add_argument('--resume', help='Resume from previous checkpoint file')
+    parser.add_argument('--no_tensorboard', action='store_true', help='Disable logging TensorBoard files')
+    parser.add_argument('--no_progress_bar', action='store_true', help='Disable progress bar')
+
+    opts = parser.parse_args(args)
+
+    opts.use_cuda = torch.cuda.is_available() and not opts.no_cuda
+    opts.run_name = "{}_{}".format(opts.run_name, time.strftime("%Y%m%dT%H%M%S"))
+    opts.save_dir = os.path.join(
+        opts.output_dir,
+        "{}_{}".format(opts.problem, opts.graph_size),
+        opts.run_name
+    )
+    if opts.bl_warmup_epochs is None:
+        opts.bl_warmup_epochs = 1 if opts.baseline == 'rollout' else 0
+    assert (opts.bl_warmup_epochs == 0) or (opts.baseline == 'rollout')
+    assert opts.epoch_size % opts.batch_size == 0, "Epoch size must be integer multiple of batch size!"
+    return opts

miscellaneous/kool/attention-learn-to-route/pretrained/cvrp_10/args.json

@@ -0,0 +1,39 @@
+{
+ "log_dir": "logs",
+ "eval_only": false,
+ "tanh_clipping": 10.0,
+ "lr_model": 0.0001,
+ "val_size": 10000,
+ "epoch_size": 1280000,
+ "graph_size": 10,
+ "batch_size": 512,
+ "val_dataset": "",
+ "checkpoint_epochs": 50,
+ "output_dir": "outputs",
+ "save_dir": "",
+ "n_epochs": 100,
+ "resume": null,
+ "exp_beta": 0.8,
+ "seed": 1234,
+ "embedding_dim": 128,
+ "no_cuda": false,
+ "eval_batch_size": 2048,
+ "use_cuda": true,
+ "lr_critic": 0.0001,
+ "n_encode_layers": 3,
+ "baseline": "rollout",
+ "epoch_start": 0,
+ "no_progress_bar": true,
+ "bl_alpha": 0.05,
+ "run_name": "cvrp_10",
+ "log_step": 500,
+ "normalization": "batch",
+ "max_grad_norm": 1.0,
+ "model": "attention",
+ "no_tensorboard": false,
+ "bl_warmup_epochs": 1,
+ "lr_decay": 1.0,
+ "load_path": null,
+ "hidden_dim": 128,
+ "problem": "cvrp"
+}

miscellaneous/kool/attention-learn-to-route/pretrained/cvrp_100/args.json

@@ -0,0 +1,39 @@
+{
+ "val_size": 10000,
+ "log_step": 500,
+ "exp_beta": 0.8,
+ "tanh_clipping": 10.0,
+ "run_name": "cvrp_100",
+ "no_tensorboard": false,
+ "resume": null,
+ "use_cuda": true,
+ "log_dir": "logs",
+ "bl_warmup_epochs": 1,
+ "no_cuda": false,
+ "eval_only": false,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "graph_size": 100,
+ "problem": "cvrp",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "normalization": "batch",
+ "no_progress_bar": true,
+ "save_dir": "",
+ "n_epochs": 100,
+ "bl_alpha": 0.05,
+ "baseline": "rollout",
+ "batch_size": 256,
+ "output_dir": "outputs",
+ "n_encode_layers": 3,
+ "val_dataset": "",
+ "epoch_start": 0,
+ "model": "attention",
+ "eval_batch_size": 2048,
+ "embedding_dim": 128,
+ "lr_decay": 1.0,
+ "hidden_dim": 128,
+ "load_path": null,
+ "checkpoint_epochs": 50,
+ "epoch_size": 640000
+}

miscellaneous/kool/attention-learn-to-route/pretrained/cvrp_20/args.json

@@ -0,0 +1,39 @@
+{
+ "no_cuda": false,
+ "val_size": 10000,
+ "bl_alpha": 0.05,
+ "seed": 1234,
+ "batch_size": 512,
+ "no_tensorboard": false,
+ "log_step": 500,
+ "resume": null,
+ "lr_decay": 1.0,
+ "run_name": "cvrp_20",
+ "load_path": null,
+ "no_progress_bar": true,
+ "epoch_start": 0,
+ "problem": "cvrp",
+ "n_encode_layers": 3,
+ "bl_warmup_epochs": 1,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "epoch_size": 1280000,
+ "max_grad_norm": 1.0,
+ "val_dataset": "",
+ "eval_only": false,
+ "graph_size": 20,
+ "use_cuda": true,
+ "n_epochs": 100,
+ "tanh_clipping": 10.0,
+ "output_dir": "outputs",
+ "eval_batch_size": 2048,
+ "normalization": "batch",
+ "hidden_dim": 128,
+ "checkpoint_epochs": 50,
+ "embedding_dim": 128,
+ "model": "attention",
+ "lr_critic": 0.0001,
+ "log_dir": "logs",
+ "save_dir": "",
+ "lr_model": 0.0001
+}

miscellaneous/kool/attention-learn-to-route/pretrained/cvrp_50/args.json

@@ -0,0 +1,39 @@
+{
+ "graph_size": 50,
+ "lr_decay": 1.0,
+ "problem": "cvrp",
+ "no_progress_bar": true,
+ "run_name": "cvrp_50",
+ "embedding_dim": 128,
+ "use_cuda": true,
+ "save_dir": "",
+ "bl_alpha": 0.05,
+ "eval_only": false,
+ "output_dir": "outputs",
+ "no_cuda": false,
+ "max_grad_norm": 1.0,
+ "checkpoint_epochs": 50,
+ "n_epochs": 100,
+ "no_tensorboard": false,
+ "log_step": 500,
+ "baseline": "rollout",
+ "load_path": null,
+ "epoch_start": 0,
+ "tanh_clipping": 10.0,
+ "hidden_dim": 128,
+ "lr_critic": 0.0001,
+ "bl_warmup_epochs": 1,
+ "lr_model": 0.0001,
+ "val_size": 10000,
+ "epoch_size": 1280000,
+ "eval_batch_size": 2048,
+ "normalization": "batch",
+ "model": "attention",
+ "resume": null,
+ "log_dir": "logs",
+ "exp_beta": 0.8,
+ "n_encode_layers": 3,
+ "seed": 1235,
+ "batch_size": 512,
+ "val_dataset": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_const_100/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_const",
+ "graph_size": 100,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 39,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": true,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_const_100",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": "outputs/op_const_100/op_const_100_rollout_20180910T180544/epoch-60.pt",
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_const_20/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_const",
+ "graph_size": 20,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_const_20",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_const_50/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_const",
+ "graph_size": 50,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_const_50",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_dist_100/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_dist",
+ "graph_size": 100,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": true,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_dist_100",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_dist_20/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_dist",
+ "graph_size": 20,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_dist_20",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_dist_50/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_dist",
+ "graph_size": 50,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_dist_50",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_unif_100/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_unif",
+ "graph_size": 100,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 35,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": true,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_unif_100",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": "outputs/op_unif_100/op_unif_100_rollout_20180910T180547/epoch-64.pt",
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_unif_20/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_unif",
+ "graph_size": 20,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_unif_20",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/op_unif_50/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "op_unif",
+ "graph_size": 50,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "op_unif_50",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/pctsp_det_100/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "pctsp_det",
+ "graph_size": 100,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "pctsp_det_100",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/pctsp_det_20/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "pctsp_det",
+ "graph_size": 20,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1235,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "pctsp_det_20",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/pctsp_det_50/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "pctsp_det",
+ "graph_size": 50,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "pctsp_det_50",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/pctsp_stoch_100/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "pctsp_stoch",
+ "graph_size": 100,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "pctsp_stoch_100",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/pctsp_stoch_20/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "pctsp_stoch",
+ "graph_size": 20,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "pctsp_stoch_20",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/pctsp_stoch_50/args.json

@@ -0,0 +1,40 @@
+{
+ "problem": "pctsp_stoch",
+ "graph_size": 50,
+ "batch_size": 512,
+ "epoch_size": 1280000,
+ "val_size": 10000,
+ "val_dataset": "",
+ "model": "attention",
+ "embedding_dim": 128,
+ "hidden_dim": 128,
+ "n_encode_layers": 3,
+ "tanh_clipping": 10.0,
+ "normalization": "batch",
+ "lr_model": 0.0001,
+ "lr_critic": 0.0001,
+ "lr_decay": 1.0,
+ "eval_only": false,
+ "n_epochs": 100,
+ "seed": 1234,
+ "max_grad_norm": 1.0,
+ "no_cuda": false,
+ "exp_beta": 0.8,
+ "baseline": "rollout",
+ "bl_alpha": 0.05,
+ "bl_warmup_epochs": 1,
+ "eval_batch_size": 2048,
+ "checkpoint_encoder": false,
+ "log_step": 50,
+ "log_dir": "logs",
+ "run_name": "pctsp_stoch_50",
+ "output_dir": "outputs",
+ "epoch_start": 0,
+ "checkpoint_epochs": 1,
+ "load_path": null,
+ "resume": null,
+ "no_tensorboard": false,
+ "no_progress_bar": false,
+ "use_cuda": true,
+ "save_dir": ""
+}

miscellaneous/kool/attention-learn-to-route/pretrained/sdvrp_10/args.json

@@ -0,0 +1,39 @@
+{
+ "no_tensorboard": false,
+ "exp_beta": 0.8,
+ "model": "attention",
+ "max_grad_norm": 1.0,
+ "no_progress_bar": true,
+ "resume": null,
+ "eval_batch_size": 2048,
+ "epoch_size": 1280000,
+ "n_encode_layers": 3,
+ "log_dir": "logs",
+ "hidden_dim": 128,
+ "val_dataset": "",
+ "seed": 1235,
+ "normalization": "batch",
+ "log_step": 500,
+ "no_cuda": false,
+ "batch_size": 512,
+ "bl_warmup_epochs": 1,
+ "problem": "sdvrp",
+ "val_size": 10000,
+ "lr_critic": 0.0001,
+ "epoch_start": 0,
+ "checkpoint_epochs": 50,
+ "load_path": null,
+ "embedding_dim": 128,
+ "baseline": "rollout",
+ "graph_size": 10,
+ "eval_only": false,
+ "lr_model": 0.0001,
+ "save_dir": "",
+ "use_cuda": true,
+ "lr_decay": 1.0,
+ "output_dir": "outputs",
+ "run_name": "sdvrp_10",
+ "tanh_clipping": 10.0,
+ "bl_alpha": 0.05,
+ "n_epochs": 100
+}

miscellaneous/kool/attention-learn-to-route/pretrained/sdvrp_100/args.json

@@ -0,0 +1,39 @@
+{
+ "hidden_dim": 128,
+ "val_dataset": "",
+ "model": "attention",
+ "baseline": "rollout",
+ "checkpoint_epochs": 50,
+ "bl_warmup_epochs": 1,
+ "log_dir": "logs",
+ "run_name": "sdvrp_100",
+ "n_epochs": 100,
+ "output_dir": "outputs",
+ "val_size": 10000,
+ "bl_alpha": 0.05,
+ "graph_size": 100,
+ "normalization": "batch",
+ "load_path": null,
+ "batch_size": 256,
+ "lr_decay": 1.0,
+ "max_grad_norm": 1.0,
+ "epoch_start": 0,
+ "no_tensorboard": false,
+ "epoch_size": 640000,
+ "exp_beta": 0.8,
+ "tanh_clipping": 10.0,
+ "eval_only": false,
+ "resume": null,
+ "n_encode_layers": 3,
+ "log_step": 500,
+ "lr_model": 0.0001,
+ "embedding_dim": 128,
+ "seed": 1235,
+ "use_cuda": true,
+ "no_progress_bar": true,
+ "lr_critic": 0.0001,
+ "save_dir": "",
+ "no_cuda": false,
+ "problem": "sdvrp",
+ "eval_batch_size": 2048
+}

miscellaneous/kool/attention-learn-to-route/pretrained/sdvrp_20/args.json

@@ -0,0 +1,39 @@
+{
+ "baseline": "rollout",
+ "checkpoint_epochs": 50,
+ "n_epochs": 100,
+ "no_tensorboard": false,
+ "eval_batch_size": 2048,
+ "no_progress_bar": true,
+ "normalization": "batch",
+ "output_dir": "outputs",
+ "epoch_size": 1280000,
+ "model": "attention",
+ "tanh_clipping": 10.0,
+ "log_step": 500,
+ "n_encode_layers": 3,
+ "save_dir": "",
+ "max_grad_norm": 1.0,
+ "hidden_dim": 128,
+ "log_dir": "logs",
+ "lr_model": 0.0001,
+ "bl_warmup_epochs": 1,
+ "no_cuda": false,
+ "graph_size": 20,
+ "epoch_start": 0,
+ "problem": "sdvrp",
+ "eval_only": false,
+ "exp_beta": 0.8,
+ "embedding_dim": 128,
+ "run_name": "sdvrp_20",
+ "lr_critic": 0.0001,
+ "load_path": null,
+ "val_dataset": "",
+ "use_cuda": true,
+ "batch_size": 512,
+ "lr_decay": 1.0,
+ "bl_alpha": 0.05,
+ "seed": 1234,
+ "resume": null,
+ "val_size": 10000
+}

miscellaneous/kool/attention-learn-to-route/pretrained/sdvrp_50/args.json

@@ -0,0 +1,39 @@
+{
+ "lr_critic": 0.0001,
+ "val_dataset": "",
+ "n_encode_layers": 3,
+ "no_tensorboard": false,
+ "output_dir": "outputs",
+ "no_progress_bar": true,
+ "max_grad_norm": 1.0,
+ "epoch_size": 1280000,
+ "embedding_dim": 128,
+ "lr_decay": 1.0,
+ "tanh_clipping": 10.0,
+ "baseline": "rollout",
+ "lr_model": 0.0001,
+ "run_name": "sdvrp_50",
+ "load_path": null,
+ "bl_warmup_epochs": 1,
+ "save_dir": "",
+ "hidden_dim": 128,
+ "problem": "sdvrp",
+ "log_dir": "logs",
+ "no_cuda": false,
+ "bl_alpha": 0.05,
+ "use_cuda": true,
+ "normalization": "batch",
+ "checkpoint_epochs": 50,
+ "graph_size": 50,
+ "exp_beta": 0.8,
+ "epoch_start": 0,
+ "batch_size": 512,
+ "seed": 1234,
+ "eval_only": false,
+ "n_epochs": 100,
+ "model": "attention",
+ "log_step": 500,
+ "resume": null,
+ "eval_batch_size": 2048,
+ "val_size": 10000
+}

miscellaneous/kool/attention-learn-to-route/pretrained/tsp_100/args.json

@@ -0,0 +1,39 @@
+{
+ "eval_batch_size": 2048,
+ "val_dataset": "",
+ "val_size": 10000,
+ "load_path": null,
+ "n_encode_layers": 3,
+ "lr_critic": 0.0001,
+ "output_dir": "outputs",
+ "epoch_size": 1280000,
+ "tanh_clipping": 10.0,
+ "hidden_dim": 128,
+ "log_dir": "logs",
+ "seed": 1235,
+ "n_epochs": 100,
+ "no_tensorboard": false,
+ "eval_only": false,
+ "embedding_dim": 128,
+ "lr_model": 0.0001,
+ "baseline": "rollout",
+ "resume": null,
+ "bl_warmup_epochs": 1,
+ "no_progress_bar": true,
+ "run_name": "tsp_100",
+ "problem": "tsp",
+ "use_cuda": true,
+ "max_grad_norm": 1.0,
+ "epoch_start": 0,
+ "batch_size": 512,
+ "log_step": 500,
+ "save_dir": "",
+ "no_cuda": false,
+ "graph_size": 100,
+ "normalization": "batch",
+ "model": "attention",
+ "bl_alpha": 0.05,
+ "exp_beta": 0.8,
+ "lr_decay": 1.0,
+ "checkpoint_epochs": 50
+}

miscellaneous/kool/attention-learn-to-route/pretrained/tsp_20/args.json

@@ -0,0 +1,39 @@
+{
+ "save_dir": "",
+ "resume": null,
+ "baseline": "rollout",
+ "batch_size": 512,
+ "log_step": 500,
+ "exp_beta": 0.8,
+ "val_size": 10000,
+ "n_encode_layers": 3,
+ "load_path": null,
+ "embedding_dim": 128,
+ "eval_batch_size": 2048,
+ "seed": 1235,
+ "max_grad_norm": 1.0,
+ "output_dir": "outputs",
+ "graph_size": 20,
+ "no_progress_bar": true,
+ "lr_decay": 1.0,
+ "checkpoint_epochs": 50,
+ "run_name": "tsp_20",
+ "bl_alpha": 0.05,
+ "epoch_start": 0,
+ "log_dir": "logs",
+ "no_tensorboard": false,
+ "normalization": "batch",
+ "no_cuda": false,
+ "model": "attention",
+ "eval_only": false,
+ "use_cuda": true,
+ "problem": "tsp",
+ "lr_critic": 0.0001,
+ "hidden_dim": 128,
+ "val_dataset": "",
+ "n_epochs": 100,
+ "epoch_size": 1280000,
+ "lr_model": 0.0001,
+ "bl_warmup_epochs": 1,
+ "tanh_clipping": 10.0
+}

miscellaneous/kool/attention-learn-to-route/pretrained/tsp_50/args.json

@@ -0,0 +1,39 @@
+{
+ "resume": null,
+ "use_cuda": true,
+ "lr_critic": 0.0001,
+ "output_dir": "outputs",
+ "log_step": 500,
+ "epoch_start": 0,
+ "run_name": "tsp_50",
+ "hidden_dim": 128,
+ "log_dir": "logs",
+ "model": "attention",
+ "n_encode_layers": 3,
+ "checkpoint_epochs": 50,
+ "epoch_size": 1280000,
+ "baseline": "rollout",
+ "problem": "tsp",
+ "graph_size": 50,
+ "n_epochs": 100,
+ "lr_decay": 1.0,
+ "no_cuda": false,
+ "eval_batch_size": 2048,
+ "eval_only": false,
+ "exp_beta": 0.8,
+ "seed": 1235,
+ "no_tensorboard": false,
+ "no_progress_bar": true,
+ "max_grad_norm": 1.0,
+ "batch_size": 512,
+ "val_dataset": "",
+ "load_path": null,
+ "bl_alpha": 0.05,
+ "val_size": 10000,
+ "save_dir": "",
+ "normalization": "batch",
+ "embedding_dim": 128,
+ "tanh_clipping": 10.0,
+ "lr_model": 0.0001,
+ "bl_warmup_epochs": 1
+}

miscellaneous/kool/attention-learn-to-route/problems/__init__.py

@@ -0,0 +1,4 @@
+from problems.tsp.problem_tsp import TSP
+from problems.vrp.problem_vrp import CVRP, SDVRP
+from problems.op.problem_op import OP
+from problems.pctsp.problem_pctsp import PCTSPDet, PCTSPStoch

miscellaneous/kool/attention-learn-to-route/problems/op/.gitignore

@@ -0,0 +1 @@
+compass/