├── README.md ├── rl-tsp.ipynb └── rl-vrp.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # Neural network/Reinforcement learning solves combinatorial optimization problem 2 | 3 | ## TODO 4 | * [ ] Cooperative MARL in logistic Network 5 | 6 | ## Reference 7 | * [Pointer Network](https://arxiv.org/abs/1506.03134) 8 | * [Neural Combinatorial Optimization with Reinforcement Learning](https://arxiv.org/pdf/1611.09940.pdf) [[Code here]](https://github.com/pemami4911/neural-combinatorial-rl-pytorch) 9 | * [Reinforcement learning for solving vehicle routing problem](https://arxiv.org/pdf/1802.04240.pdf) [[Code here]](https://github.com/mveres01/pytorch-drl4vrp) 10 | * [Learning Combinatorial Optimization Algorithms over Graphs](https://arxiv.org/abs/1704.01665) [[Code here]](https://github.com/Hanjun-Dai/graph_comb_opt) 11 | * [Attention: Learn to solve routing problems!](https://openreview.net/pdf?id=ByxBFsRqYm) [[Code here]](https://github.com/wouterkool/attention-learn-to-route) 12 | * [A Deep Q-Network for the Beer Game: Reinforcement Learning for Inventory Optimization](https://arxiv.org/pdf/1708.05924.pdf) 13 | * [A Cooperative Multi-Agent Reinforcement Learning Framework for Resource Balancing in Complex Logistics Network](https://arxiv.org/pdf/1903.00714.pdf) 14 | -------------------------------------------------------------------------------- /rl-tsp.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Pytorch Implementation of [Neural Combinatorial Optimization with Reinforcement Learning](https://arxiv.org/pdf/1611.09940.pdf)\n", 8 | "\n", 9 | "Thanks for [neural-combinatorial-rl-pytorch](https://github.com/pemami4911/neural-combinatorial-rl-pytorch) and [combinatorial optimization with DL/RL](https://github.com/higgsfield/np-hard-deep-reinforcement-learning). Their work helps me understand the theory in paper and fix debugs in my codes. I also used some of their codes. " 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 1, 15 | "metadata": { 16 | "collapsed": true 17 | }, 18 | "outputs": [], 19 | "source": [ 20 | "import math\n", 21 | "import numpy as np\n", 22 | "import matplotlib.pyplot as plt\n", 23 | "from copy import deepcopy\n", 24 | "import random\n", 25 | "import os\n", 26 | "\n", 27 | "import torch\n", 28 | "import torch.nn as nn\n", 29 | "import torch.nn.functional as F\n", 30 | "from torch.autograd import Variable\n", 31 | "from torch.optim import Adam\n", 32 | "from torch.optim import lr_scheduler\n", 33 | "\n", 34 | "%matplotlib inline" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": 2, 40 | "metadata": { 41 | "collapsed": true 42 | }, 43 | "outputs": [], 44 | "source": [ 45 | "from IPython.display import clear_output\n", 46 | "USE_CUDA = False" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "### Pointer Network" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "#### Encoder\n", 61 | "\n", 62 | "* One layer of LSTM with (embedding_dim, hidden_dim)\n", 63 | "* Initialize h, c with zeros\n", 64 | "* Output\n", 65 | " * a sequence of latent memory states $\\{enc_i\\}_{i=1}^n$, where $\\{enc_i\\} \\in \\mathbb{R}^d$, d is embedding dimension\n", 66 | " * h: last layer hidden states, h\\[-1\\] is the hidden state in the last cell\n", 67 | " * c: last layer cell states, c\\[-1\\] is the cell state in the last cell" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 3, 73 | "metadata": { 74 | "collapsed": true 75 | }, 76 | "outputs": [], 77 | "source": [ 78 | "class Encoder(nn.Module):\n", 79 | " \n", 80 | " def __init__(self, embedding_dim, hidden_dim):\n", 81 | " super().__init__()\n", 82 | " # use default number of layers is 1\n", 83 | " self.lstm = nn.LSTM(embedding_dim, hidden_dim)\n", 84 | " self.hidden_dim = hidden_dim\n", 85 | " \n", 86 | " def forward(self, embedding_x):\n", 87 | " '''\n", 88 | " Args:\n", 89 | " embedding_x (tensor): shape (sequence length, batch, input_dim)\n", 90 | " hidden (tensor): shape (num_layer * num_direction, batch_size, hidden_dim)\n", 91 | " \n", 92 | " Return:\n", 93 | " output (tensor): (sequence length, batch_size, hidden_dim)\n", 94 | " next_hidden (tensor): (num_layer * num_direction, batch_size, hidden_dim)\n", 95 | " '''\n", 96 | " output, next_hidden = self.lstm(embedding_x)\n", 97 | " return output, next_hidden" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "#### Attention and Glimpse (Pointing and Attending Mechanism)\n", 105 | "\n", 106 | "* Input:\n", 107 | " * a query vector from decoder, $q = dec_i \\in \\mathbb{R}^d$\n", 108 | " * a set of reference vector from encoder output, $ref = \\{enc_i, \\dots, enc_k\\}$， k could be the sequence length\n", 109 | "* Pointing mechanism:\n", 110 | " $$u_i = \\begin{cases} v^T \\cdot \\tanh (W_{ref} \\cdot r_t + W_q \\cdot q) \\hspace{0.2cm} \\text{if} \\hspace{0.2cm} i \\neq \\pi(j) \\hspace{0.2cm} \\text{for all} \\hspace{0.2cm} j < i \\\\\n", 111 | " -\\infty\\end{cases} \\hspace{0.2cm} \\text{for} \\hspace{0.2cm} i = 1, 2, \\dots k$$\n", 112 | " where $W_{ref}, W_q \\in \\mathbb{R}^{d \\times d}$ and an attention vector $v \\in \\mathbb{R}^d$. In practice, the $reference$ input is (batch size $\\times$ embedding dimension $\\times$ sequence length), we can use convolution weights with shape (embedding dimensions, embedding dimensions) to address 3D data. $v$ initializes with normal distribution between $\\left[-\\frac{1}{\\sqrt{d}}, \\frac{1}{\\sqrt{d}}\\right]$ In the paper, it is $\\left[-0.08 (-\\frac{1}{\\sqrt{128}}), 0.08\\right]$. \n", 113 | " $$A(ref, q; W_{ref}, W_q, v) = softmax(u)$$\n", 114 | " * Improving exploration\n", 115 | " * Softmax temperature\n", 116 | " $$A(ref, q; W_{ref}, W_q, v) = softmax(u / T)$$\n", 117 | " where $T$ is the temperature hyperparameter set to T = 1 during training. $T>1$, $A$ is more smooth, so that is prevent the model from being overconfident\n", 118 | " * Logit clipping (used here)\n", 119 | " $$A(ref, q; W_{ref}, W_q, v) = softmax(C \\tanh(u))$$\n", 120 | " where $C$ is the hyperparameter that controls the range of the logits. The paper uses $C = 10$\n", 121 | "* Attending mechanism\n", 122 | " $$p = A(ref, q; W_{ref}, W_q, v)$$\n", 123 | " $$G(ref, q; W_{ref}^g, W_q^g, v^g) = \\sum_{i = 1}^k r_i p_i$$\n", 124 | " where $G$ is the glimpse function. It can be applied multiple times on the same reference set $ref$:\n", 125 | " $$g_0 = q$$\n", 126 | " $$g_l = G(ref, g_{l-1}; W_{ref}^q, W_q^g, v^g)$$\n", 127 | " The paper says more than once glimpse lead to barely improve thre results. Thus, we choose $\\textbf{num_glimpse} = 1$. Glimpse function is implemented in the decoder. " 128 | ] 129 | }, 130 | { 131 | "cell_type": "code", 132 | "execution_count": 4, 133 | "metadata": { 134 | "collapsed": true 135 | }, 136 | "outputs": [], 137 | "source": [ 138 | "class Attention(nn.Module):\n", 139 | " def __init__(self, dim, C = 10, use_logit_clip = True, use_cuda = USE_CUDA):\n", 140 | " super().__init__()\n", 141 | " self.w_q = nn.Linear(dim, dim) # for query (batch_size, d)\n", 142 | " self.w_ref = nn.Conv1d(dim, dim, 1, 1) # for reference (batch_size, d, k)\n", 143 | " V = torch.Tensor(dim).float() # to trainable parameters\n", 144 | " if use_cuda:\n", 145 | " V = V.cuda()\n", 146 | " # initialize v by uniform in almost (-0.08, 0.08) from the paper\n", 147 | " self.v = nn.Parameter(V)\n", 148 | " self.v.data.uniform_(- 1. / math.sqrt(dim), 1. / math.sqrt(dim))\n", 149 | " self.tanh = nn.Tanh()\n", 150 | " self.C = C\n", 151 | " self.dim = dim\n", 152 | " self.use_logit_clip = use_logit_clip\n", 153 | " \n", 154 | " def forward(self, encoder_output, query):\n", 155 | " '''\n", 156 | " Args:\n", 157 | " k is sequence length\n", 158 | " encoder_output (tensor): shape is (k, batch_size, dim) from encoder_output\n", 159 | " query (tensor): shape is (batch_size, dim)\n", 160 | " \n", 161 | " Return:\n", 162 | " ref (tensor): shape is (batch_size, dim, k)\n", 163 | " logit (tensor): probability with shape (batch_size, k)\n", 164 | " '''\n", 165 | " batch_size = query.size(0)\n", 166 | " encoder_output = encoder_output.permute(1, 2, 0)\n", 167 | " # make sure ref shape is (batch_size, dim, k)\n", 168 | " \n", 169 | " q = self.w_q(query).unsqueeze(2)\n", 170 | " ref = self.w_ref(encoder_output) # batch_size, hidden_dim, k\n", 171 | " k = ref.size(2)\n", 172 | " expanded_q = q.repeat(1, 1, k)\n", 173 | " expanded_v = self.v.unsqueeze(0).unsqueeze(0).repeat(batch_size, 1, 1)\n", 174 | " # batch matrix multiply (batch_size, sequence_length)\n", 175 | " u = torch.bmm(expanded_v, self.tanh(ref + expanded_q)).squeeze(1)\n", 176 | " \n", 177 | " if self.use_logit_clip:\n", 178 | " logit = self.C * self.tanh(u)\n", 179 | " else:\n", 180 | " logit = u\n", 181 | " \n", 182 | " # return ref for glimpse\n", 183 | " return logit" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 5, 189 | "metadata": { 190 | "collapsed": true 191 | }, 192 | "outputs": [], 193 | "source": [ 194 | "# mask already search index \n", 195 | "def mask_logit(logit, mask, prev_idx):\n", 196 | " '''\n", 197 | " mask logit probability if they are in previous indice\n", 198 | " Args:\n", 199 | " logit (tensor): from attention output with shape (batch_size, sequence length)\n", 200 | " mask (tensor or None): selected mask\n", 201 | " prev_idx (tensor): None or previous retrieved indice (batch_size, )\n", 202 | " \n", 203 | " Return:\n", 204 | " logit (tensor): same shape with input, but mask elements\n", 205 | " '''\n", 206 | " mask_copy = mask.clone()\n", 207 | " \n", 208 | " batch_size = logit.size(0)\n", 209 | " if prev_idx is not None:\n", 210 | " mask_copy[[b for b in range(batch_size)], prev_idx.data] = 1\n", 211 | " logit[mask_copy] = -np.inf\n", 212 | " \n", 213 | " return logit, mask_copy" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "#### Decoder\n", 221 | "\n", 222 | "It also maintains its latent memory states $\\{dec_i\\}_{i=1}^n$, where $dec_i \\in \\mathbb{R}^d$.\n", 223 | "* Input:\n", 224 | " * encoder last cell output: hidden state and cell state\n", 225 | " * decoder input initializes with normal distribution between $\\left[-\\frac{1}{\\sqrt{d}}, \\frac{1}{\\sqrt{d}}\\right]$. It should be trainable parameters." 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": 6, 231 | "metadata": { 232 | "collapsed": true 233 | }, 234 | "outputs": [], 235 | "source": [ 236 | "class Decoder(nn.Module):\n", 237 | " \n", 238 | " def __init__(self, embedding_dim, hidden_dim, sequence_length, \n", 239 | " decoder_type = \"sampling\", num_glimpse = 1, use_cuda = USE_CUDA):\n", 240 | " super().__init__()\n", 241 | " self.embedding_dim = embedding_dim\n", 242 | " self.hidden_dim = hidden_dim\n", 243 | " self.num_glimpse = num_glimpse\n", 244 | " self.sequence_length = sequence_length\n", 245 | " \n", 246 | " # lstm cell weights\n", 247 | " self.lstm_cell = nn.LSTMCell(embedding_dim, hidden_dim)\n", 248 | " \n", 249 | " # pointer and glimpse\n", 250 | " self.pointer = Attention(hidden_dim, use_cuda = use_cuda)\n", 251 | " self.glimpse = Attention(hidden_dim, use_logit_clip=False, use_cuda = use_cuda)\n", 252 | " self.use_cuda = use_cuda\n", 253 | " \n", 254 | " self.softmax = nn.Softmax()\n", 255 | " \n", 256 | " self.decoder_type = decoder_type\n", 257 | " \n", 258 | " def forward(self, decoder_input, embedding_x, hidden, encoder_output):\n", 259 | " '''\n", 260 | " Args:\n", 261 | " decoder_input (tensor): (batch_size, embedding_dim)\n", 262 | " embedding_x (tensor): (k, batch_size, embedding_dim)\n", 263 | " hidden (tuple): (h, c), initially, \n", 264 | " (encoder_output[-1], encoder_output[-1]), (batch_size, hidden_dim)\n", 265 | " encoder_output (tensor): encoder output, shape is (k, batch_size, embedding_dim)\n", 266 | " \n", 267 | " Return:\n", 268 | " prob_list (list): list of probability through the sequence \n", 269 | " index_list (list): list of indice\n", 270 | " hidden (tuple): last layer hidden state and cell state\n", 271 | " '''\n", 272 | " batch_size = decoder_input.size(0)\n", 273 | " seq_len = embedding_x.size(0)\n", 274 | " # save result\n", 275 | " prob_list = []\n", 276 | " index_list = []\n", 277 | " mask = None\n", 278 | " mask = torch.zeros(batch_size, seq_len).byte()\n", 279 | " if self.use_cuda:\n", 280 | " mask = mask.cuda()\n", 281 | " prev_idx = None\n", 282 | " \n", 283 | " embedding_x = embedding_x.permute(1, 0, 2) # to (batch_size, seq_len, embedding_dim)\n", 284 | " ref = encoder_output.permute(1, 2, 0) # to (batch_size, embedding_dim, seq_len)\n", 285 | " for i in range(self.sequence_length):\n", 286 | " h, c = self.lstm_cell(decoder_input, hidden)\n", 287 | " hidden = (h, c)\n", 288 | " g_l = h # (batch_size, hidden_dim)\n", 289 | " for _ in range(self.num_glimpse):\n", 290 | " logit = self.glimpse(encoder_output, g_l)\n", 291 | " logit, mask = mask_logit(logit, mask, prev_idx)\n", 292 | " p = self.softmax(logit) # (batch_size, seq_len)\n", 293 | " # ref (batch_size, hidden_dim, seq_len)\n", 294 | " g_l = torch.bmm(ref, p.unsqueeze(2)).squeeze(2) # (batch_size, hidden_dim)\n", 295 | " logit = self.pointer(encoder_output, g_l)\n", 296 | " logit_mask, mask = mask_logit(logit, mask, prev_idx)\n", 297 | "\n", 298 | " if self.decoder_type == \"greedy\": # for validation\n", 299 | " probs = self.softmax(logit_mask) # batch_size, k\n", 300 | " prev_idx, decoder_input = greedy(probs, embedding_x)\n", 301 | " elif self.decoder_type == \"sampling\": # for training\n", 302 | " probs = self.softmax(softmax_temperature(logit_mask, T = 1.) )# batch_size, k\n", 303 | " prev_idx, decoder_input = sampling(probs, embedding_x, index_list)\n", 304 | " else:\n", 305 | " raise NotImplementedError\n", 306 | " # record previous index \n", 307 | " index_list.append(prev_idx)\n", 308 | " # record probability (like lstm output)\n", 309 | " prob_list.append(probs)\n", 310 | " return prob_list, index_list" 311 | ] 312 | }, 313 | { 314 | "cell_type": "markdown", 315 | "metadata": {}, 316 | "source": [ 317 | "#### Search Strategies" 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": 7, 323 | "metadata": { 324 | "collapsed": true 325 | }, 326 | "outputs": [], 327 | "source": [ 328 | "def greedy(probs, embedding_x):\n", 329 | " '''\n", 330 | " greedy search and return the index with \n", 331 | " the biggest probability used in validation set\n", 332 | " \n", 333 | " Args: \n", 334 | " probs (tensor): (batch_size, k)\n", 335 | " embedding_x (tensor): (k, batch_size, embedding_dim)\n", 336 | " \n", 337 | " Return:\n", 338 | " -- new_decoder_input (tensor): selected embedding x with shape (batch_size, embedding_dim)\n", 339 | " as new decoder_input\n", 340 | " -- idx (tensor): selected idx tensor （k,)\n", 341 | " '''\n", 342 | " batch_size = probs.size(0)\n", 343 | " idx = torch.argmax(probs, dim = 1).long()\n", 344 | " new_decoder_input = embedding_x[[x for x in range(batch_size)], idx.data, :]\n", 345 | " return idx, new_decoder_input\n", 346 | "\n", 347 | "def sampling(probs, embedding_x, prev_idx):\n", 348 | " '''\n", 349 | " sampling indice from probability used in train and validation is ok\n", 350 | " \n", 351 | " Args:\n", 352 | " probs (tensor): (batch_size, k)\n", 353 | " embedding_x (tensor): (k, batch_size, embedding_dim)\n", 354 | " prev_idx (list): list of previous index (batch_size, 1), should be LongTensor\n", 355 | " \n", 356 | " Return:\n", 357 | " -- new_decoder_input (tensor): selected embedding x with shape (batch_size, embedding_dim)\n", 358 | " as new decoder_input\n", 359 | " -- idx (tensor): selected idx tensor （k,)\n", 360 | " '''\n", 361 | " batch_size = probs.size(0)\n", 362 | " idx = probs.multinomial(1).squeeze(1).long()\n", 363 | " \n", 364 | " def is_exist(idx, prev_idx):\n", 365 | " for old_idx in prev_idx:\n", 366 | " if old_idx.eq(idx).data.any():\n", 367 | " return True\n", 368 | " return False\n", 369 | " \n", 370 | " while is_exist(idx, prev_idx):\n", 371 | " idx = probs.multinomial(1).squeeze(1).long() \n", 372 | " \n", 373 | " return idx, embedding_x[[x for x in range(batch_size)], idx.data, :]\n", 374 | "\n", 375 | "def softmax_temperature(logit_mask, T = 2.):\n", 376 | " '''\n", 377 | " Implement softmax temperature strategy\n", 378 | " \n", 379 | " Args:\n", 380 | " logit_mask (batch_size, seq_len)\n", 381 | " T (float): temperature\n", 382 | " '''\n", 383 | " return logit_mask / T\n", 384 | "\n", 385 | "def active_search(self):\n", 386 | " \"TO DO\" \n", 387 | " pass" 388 | ] 389 | }, 390 | { 391 | "cell_type": "markdown", 392 | "metadata": {}, 393 | "source": [ 394 | "#### Pointer Network Module" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": {}, 400 | "source": [ 401 | "Note that we should embed the raw input for the input of the network. Here I spent much time fixing bugs. The embedding for encoders should be shared for a sequence length of LSTM cells inputs, otherwise it will take much time to learn. " 402 | ] 403 | }, 404 | { 405 | "cell_type": "code", 406 | "execution_count": 8, 407 | "metadata": { 408 | "collapsed": true 409 | }, 410 | "outputs": [], 411 | "source": [ 412 | "class Embedding(nn.Module):\n", 413 | " def __init__(self, input_size, embedding_size, use_cuda = USE_CUDA):\n", 414 | " super().__init__()\n", 415 | " self.embedding_size = embedding_size\n", 416 | " \n", 417 | " self.embedding = nn.Parameter(torch.FloatTensor(input_size, embedding_size)) \n", 418 | " self.embedding.data.uniform_(-(1. / math.sqrt(embedding_size)), 1. / math.sqrt(embedding_size))\n", 419 | " \n", 420 | " def forward(self, inputs):\n", 421 | " '''\n", 422 | " Args:\n", 423 | " inputs (batch_size, seq_len, input_size)\n", 424 | " \n", 425 | " Return:\n", 426 | " embedded (batch_size, seq_len, hidden_size)\n", 427 | " '''\n", 428 | " batch_size = inputs.size(0)\n", 429 | " seq_len = inputs.size(1)\n", 430 | " embedding = self.embedding.repeat(batch_size, 1, 1) # batch_size, input_size, embedding_size\n", 431 | " embedded = []\n", 432 | " for i in range(seq_len):\n", 433 | " # batch multiplication should be same dimensions, so, unsqueeze 1\n", 434 | " embedded.append(torch.bmm(inputs[:, i, :].unsqueeze(1).float(), embedding))\n", 435 | " embedded = torch.cat(embedded, 1)\n", 436 | " return embedded" 437 | ] 438 | }, 439 | { 440 | "cell_type": "code", 441 | "execution_count": 9, 442 | "metadata": { 443 | "collapsed": true 444 | }, 445 | "outputs": [], 446 | "source": [ 447 | "class PointerNet(nn.Module): \n", 448 | " \n", 449 | " def __init__(self, embedding_dim, hidden_dim, \\\n", 450 | " seq_length, \\\n", 451 | " decoder_type = \"sampling\", num_glimpse = 1, use_cuda = USE_CUDA):\n", 452 | " super().__init__()\n", 453 | " \n", 454 | " # define encoder and decoder\n", 455 | " self.encoder = Encoder(embedding_dim, hidden_dim)\n", 456 | " self.decoder = Decoder(embedding_dim, hidden_dim, \\\n", 457 | " seq_length, \\\n", 458 | " decoder_type = decoder_type, \\\n", 459 | " num_glimpse = num_glimpse, use_cuda = use_cuda)\n", 460 | "\n", 461 | " decoder_input = torch.Tensor(embedding_dim).float()\n", 462 | " self.decoder_input = nn.Parameter(decoder_input) # trainable, default require grad is true\n", 463 | " self.decoder_input.data.uniform_(-1 / math.sqrt(embedding_dim), 1 / math.sqrt(embedding_dim))\n", 464 | " \n", 465 | " # embedding\n", 466 | " self.embedding = Embedding(input_dim, embedding_dim, use_cuda = use_cuda)\n", 467 | " \n", 468 | " def forward(self, x):\n", 469 | " '''\n", 470 | " propagate through the network\n", 471 | " Args:\n", 472 | " x (tensor): (batch_size, k, input_dim), like in paper, embedding dim = d\n", 473 | " \n", 474 | " Return:\n", 475 | " - prob_list (list): length is max length of decoder, \n", 476 | " with the element shape (batch_size, sequence length), \n", 477 | " - index_list (list): length is max length of decoder, \n", 478 | " with the element shape (batch_size,)\n", 479 | " '''\n", 480 | " batch_size = x.size(0)\n", 481 | " embedding_x = self.embedding(x).permute(1, 0, 2)\n", 482 | " encoder_output, (encoder_ht, encoder_ct) = self.encoder(embedding_x)\n", 483 | " \n", 484 | " # last layer output h, c as decoder initial state\n", 485 | " hidden = (encoder_ht.squeeze(0), encoder_ct.squeeze(0)) # (batch_size, hidden_dim)\n", 486 | "\n", 487 | " decoder_input = self.decoder_input.unsqueeze(0).repeat(batch_size, 1)\n", 488 | " prob_list, index_list = self.decoder(decoder_input, embedding_x, hidden, encoder_output)\n", 489 | " \n", 490 | " return prob_list, index_list" 491 | ] 492 | }, 493 | { 494 | "cell_type": "markdown", 495 | "metadata": {}, 496 | "source": [ 497 | "### Critic Network for TSP\n", 498 | "\n", 499 | "Map an input sequence $s$ into a baseline prediction $b_{\\theta_v}(s)$, because the objective\n", 500 | "$$\\mathcal{L}(\\theta_v) = \\frac{1}{B} \\sum_{i=1}^B \\left\\|b_{\\theta_v}(s) - L(\\pi_i | s_i) \\right\\|_2^2$$\n", 501 | "\n", 502 | "* an LSTM encoder: same as the encode in pointer network\n", 503 | "* an LSTM process block: performs P steps of computation over the hidden state $h$, update by glimpsing the memory state\n", 504 | "* a 2-layer ReLU neural network decoder" 505 | ] 506 | }, 507 | { 508 | "cell_type": "code", 509 | "execution_count": 10, 510 | "metadata": { 511 | "collapsed": true 512 | }, 513 | "outputs": [], 514 | "source": [ 515 | "class Critic(nn.Module):\n", 516 | " \n", 517 | " def __init__(self, embedding_dim, hidden_dim, process_iters, use_logit_clip = False, use_cuda = USE_CUDA):\n", 518 | " super().__init__()\n", 519 | " self.encoder = Encoder(embedding_dim, hidden_dim) \n", 520 | " self.process_block = Attention(hidden_dim, use_logit_clip=use_logit_clip, \\\n", 521 | " use_cuda = use_cuda) # output is (batch_size, hidden_dim)\n", 522 | " self.decoder = nn.Sequential(\n", 523 | " nn.Linear(hidden_dim, hidden_dim),\n", 524 | " nn.ReLU(),\n", 525 | " nn.Linear(hidden_dim, 1)\n", 526 | " )\n", 527 | " self.process_iters = process_iters\n", 528 | " self.softmax = nn.Softmax()\n", 529 | " self.embedding = Embedding(input_dim, embedding_dim, use_cuda = use_cuda)\n", 530 | " \n", 531 | " def forward(self, x):\n", 532 | " '''\n", 533 | " Args:\n", 534 | " x (tensor): with shape (k, batch_size, embedding_dim)\n", 535 | " \n", 536 | " Return:\n", 537 | " output (tensor): (batch_size, 1)\n", 538 | " '''\n", 539 | " batch_size = x.size(0)\n", 540 | " embedding_x = self.embedding(x).permute(1, 0, 2)\n", 541 | " encoder_output, (encoder_ht, encoder_ct) = self.encoder(embedding_x)\n", 542 | " ref = encoder_output.permute(1, 2, 0) # to (batch_size, embedding_dim, seq_len)\n", 543 | " g_l = encoder_ht.squeeze(0)\n", 544 | " for p in range(self.process_iters):\n", 545 | " logit = self.process_block(encoder_output, g_l)\n", 546 | " p = self.softmax(logit) # (batch_size, k)\n", 547 | " g_l = torch.bmm(ref, p.unsqueeze(2)).squeeze(2)\n", 548 | " output = self.decoder(g_l)\n", 549 | " return output" 550 | ] 551 | }, 552 | { 553 | "cell_type": "markdown", 554 | "metadata": {}, 555 | "source": [ 556 | "#### Combinatorial Model" 557 | ] 558 | }, 559 | { 560 | "cell_type": "code", 561 | "execution_count": 11, 562 | "metadata": { 563 | "collapsed": true 564 | }, 565 | "outputs": [], 566 | "source": [ 567 | "class Model(nn.Module):\n", 568 | " \n", 569 | " def __init__(self, embedding_dim, hidden_dim, seq_len, batch_size = 128, process_iters = 3, use_cuda = USE_CUDA):\n", 570 | " super().__init__()\n", 571 | " self.pointer_net = PointerNet(embedding_dim, hidden_dim, seq_len, use_cuda = use_cuda)\n", 572 | " self.critic = Critic(embedding_dim, hidden_dim, process_iters, use_cuda = use_cuda)\n", 573 | " self.batch_size = batch_size\n", 574 | " self.seq_len = seq_len\n", 575 | " \n", 576 | " def forward(self, x):\n", 577 | " '''\n", 578 | " Args:\n", 579 | " x (batch_size, seq_len, input_dim)\n", 580 | " '''\n", 581 | " prob_list, index_list = self.pointer_net(x)\n", 582 | " b = self.critic(x)\n", 583 | " \n", 584 | " pi = []\n", 585 | " probs = []\n", 586 | " for i, index in enumerate(index_list):\n", 587 | " pi_ = x[[j for j in range(self.batch_size)], index.data, :]\n", 588 | " pi.append(pi_)\n", 589 | " prob_ = prob_list[i]\n", 590 | " prob_ = prob_[[j for j in range(self.batch_size)], index.data]\n", 591 | " probs.append(prob_)\n", 592 | " \n", 593 | " L = tour_length(pi)\n", 594 | " log_probs = 0\n", 595 | " for prob in probs:\n", 596 | " log_prob = torch.log(prob)\n", 597 | " log_probs += log_prob\n", 598 | " \n", 599 | " return L, log_probs, pi, index_list, b" 600 | ] 601 | }, 602 | { 603 | "cell_type": "markdown", 604 | "metadata": {}, 605 | "source": [ 606 | "### Actor-Critic and Moving Average Training " 607 | ] 608 | }, 609 | { 610 | "cell_type": "markdown", 611 | "metadata": {}, 612 | "source": [ 613 | "#### Calculate tour length\n", 614 | "\n", 615 | "$$L(\\pi | s) = \\left\\| x_{\\pi(n)} - x_{\\pi(1)} \\right\\|_2 + \\sum_{i=1}^{n-1} \\left\\|x_{\\pi(i)} - x_{\\pi(i+1)} \\right\\|_2$$" 616 | ] 617 | }, 618 | { 619 | "cell_type": "code", 620 | "execution_count": 12, 621 | "metadata": { 622 | "collapsed": true 623 | }, 624 | "outputs": [], 625 | "source": [ 626 | "# define tour length function as reward\n", 627 | "def tour_length(pi, use_cuda = USE_CUDA):\n", 628 | " '''\n", 629 | " calculate the total length of the tour\n", 630 | " Args:\n", 631 | " pi (list): length is sequence length, \n", 632 | " the element shape is (batch_size, point_size)\n", 633 | " Return:\n", 634 | " tour_len (tensor): (batch_size, 1)\n", 635 | " '''\n", 636 | " \n", 637 | " n = len(pi)\n", 638 | " batch_size = pi[0].size(0)\n", 639 | " tour_len = Variable(torch.zeros(batch_size))\n", 640 | " \n", 641 | " if use_cuda:\n", 642 | " tour_len = tour_len.cuda()\n", 643 | " \n", 644 | " for i in range(n-1):\n", 645 | " tour_len += torch.norm(pi[i+1] - pi[i], p = 2, dim = 1)\n", 646 | " tour_len += torch.norm(pi[n-1] - pi[0], p = 2, dim = 1)\n", 647 | " return tour_len" 648 | ] 649 | }, 650 | { 651 | "cell_type": "markdown", 652 | "metadata": {}, 653 | "source": [ 654 | "#### Hyperparameters" 655 | ] 656 | }, 657 | { 658 | "cell_type": "code", 659 | "execution_count": 13, 660 | "metadata": { 661 | "collapsed": true 662 | }, 663 | "outputs": [], 664 | "source": [ 665 | "# hyperparameter\n", 666 | "input_dim = 2\n", 667 | "embedding_dim = 128\n", 668 | "batch_size = 128\n", 669 | "hidden_dim = 128\n", 670 | "process_iters = 3\n", 671 | "tsp_num = 20\n", 672 | "train_size = 1000000\n", 673 | "validation_size = 10000\n", 674 | "lr = 1e-4\n", 675 | "beta = 0.9\n", 676 | "num_glimpse = 1" 677 | ] 678 | }, 679 | { 680 | "cell_type": "markdown", 681 | "metadata": {}, 682 | "source": [ 683 | "#### Train and Validation Data" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": 14, 689 | "metadata": {}, 690 | "outputs": [ 691 | { 692 | "name": "stdout", 693 | "output_type": "stream", 694 | "text": [ 695 | "train dataset size: 1000000\n", 696 | "validation dataset size: 10000\n" 697 | ] 698 | } 699 | ], 700 | "source": [ 701 | "def generate_tsp_data():\n", 702 | " '''\n", 703 | " Generate tsp data\n", 704 | " \n", 705 | " Return:\n", 706 | " tsp_data (tensor): shape (1, tsp_num, input_dim)\n", 707 | " '''\n", 708 | " tsp_data = torch.FloatTensor(tsp_num, input_dim).uniform_(0, 1)\n", 709 | " return tsp_data.unsqueeze(0)\n", 710 | "\n", 711 | "train_dataset = [generate_tsp_data() for _ in range(train_size)]\n", 712 | "validation_dataset = [generate_tsp_data() for _ in range(validation_size)]\n", 713 | "print(\"train dataset size: \", len(train_dataset))\n", 714 | "print(\"validation dataset size: \", len(validation_dataset))" 715 | ] 716 | }, 717 | { 718 | "cell_type": "code", 719 | "execution_count": 15, 720 | "metadata": { 721 | "collapsed": true 722 | }, 723 | "outputs": [], 724 | "source": [ 725 | "# training\n", 726 | "class Train(object):\n", 727 | " \n", 728 | " def __init__(self, model, train_set, validation_set, batch_size = 128, max_grad_norm = 1., lr = 1e-4, update_steps = 5000):\n", 729 | " self.model = model\n", 730 | " self.train_set = train_set\n", 731 | " self.validation_set = validation_set\n", 732 | " self.batch_size = batch_size\n", 733 | " self.max_grad_norm = max_grad_norm\n", 734 | " self.optimizer_all = Adam(list(model.critic.parameters()) + list(model.pointer_net.parameters()), lr = lr)\n", 735 | " self.optimizer_pointer = Adam(model.pointer_net.parameters(), lr = lr)\n", 736 | " self.lr_scheduler_pointer = lr_scheduler.MultiStepLR(self.optimizer_pointer, \\\n", 737 | " list(range(update_steps, update_steps * 1000, update_steps)), gamma=0.96)\n", 738 | " self.lr_scheduler_all = lr_scheduler.MultiStepLR(self.optimizer_all, \\\n", 739 | " list(range(update_steps, update_steps * 1000, update_steps)), gamma=0.96)\n", 740 | " self.mse_loss = nn.MSELoss()\n", 741 | " self.input_dim = 2 # points dimension\n", 742 | " \n", 743 | " self.train_rewards = []\n", 744 | " self.val_rewards = []\n", 745 | " \n", 746 | " def train_and_validation(self, n_epoch, training_steps, use_critic = True):\n", 747 | " moving_average = 0\n", 748 | " for epoch in range(n_epoch):\n", 749 | " for step in range(training_steps):\n", 750 | " training_set = random.sample(self.train_set, batch_size)\n", 751 | " training_set = Variable(torch.cat(training_set).view(self.batch_size, -1, self.input_dim))\n", 752 | " L, log_probs, pi, index_list, b = self.model(training_set)\n", 753 | "\n", 754 | " log_probs = log_probs.view(-1)\n", 755 | " log_probs[(log_probs < -1000).detach()] = 0.\n", 756 | " \n", 757 | " if not use_critic:\n", 758 | " if step == 0:\n", 759 | " moving_average = L.mean()\n", 760 | " else:\n", 761 | " moving_average = (moving_average * beta) + ((1. - beta) * L.mean())\n", 762 | "\n", 763 | " advantage = L - moving_average \n", 764 | " actor_loss = (advantage * log_probs).mean()\n", 765 | " \n", 766 | " \n", 767 | " self.optimizer_pointer.zero_grad()\n", 768 | " actor_loss.backward()\n", 769 | " torch.nn.utils.clip_grad_norm_(self.model.pointer_net.parameters(), self.max_grad_norm, norm_type=2)\n", 770 | " self.optimizer_pointer.step()\n", 771 | " self.lr_scheduler_pointer.step()\n", 772 | " moving_average = moving_average.detach()\n", 773 | " \n", 774 | " else:\n", 775 | " critic_loss = self.mse_loss(b.view(-1), L)\n", 776 | " advantage = L - b.view(-1)\n", 777 | " actor_loss = (advantage * log_probs).mean()\n", 778 | " loss = actor_loss + critic_loss\n", 779 | " self.optimizer_all.zero_grad()\n", 780 | " loss.backward()\n", 781 | " torch.nn.utils.clip_grad_norm_(list(self.model.critic.parameters()) + \\\n", 782 | " list(self.model.pointer_net.parameters()), self.max_grad_norm, norm_type=2)\n", 783 | "# torch.nn.utils.clip_grad_norm_(, self.max_grad_norm, norm_type=2)\n", 784 | " self.optimizer_all.step()\n", 785 | " self.lr_scheduler_all.step()\n", 786 | "\n", 787 | " self.train_rewards.append(L.mean().data[0])\n", 788 | " \n", 789 | " if step % 10 == 0:\n", 790 | " self.plot(epoch)\n", 791 | " if step % 100 == 0:\n", 792 | " val_set = Variable(torch.cat(self.validation_set).view(len(self.validation_set), -1, self.input_dim))\n", 793 | " L, log_probs, pi, index_list, b = self.model(val_set)\n", 794 | " self.val_rewards.append(L.mean().data[0]) \n", 795 | " \n", 796 | " # model save\n", 797 | " if step % 1000 == 0:\n", 798 | " if use_critic:\n", 799 | " torch.save(self.model, os.path.join(os.getcwd(), \\\n", 800 | " 'model_tsp{}_critic.pt'.format(self.model.seq_len)))\n", 801 | " else:\n", 802 | " torch.save(self.model, os.path.join(os.getcwd(), \\\n", 803 | " 'model_tsp{}_mvg_avg.pt'.format(self.model.seq_len)))\n", 804 | " \n", 805 | " def plot(self, epoch):\n", 806 | " clear_output(True)\n", 807 | " plt.figure(figsize=(20,5))\n", 808 | " plt.subplot(131)\n", 809 | " plt.title('train tour length: epoch %s reward %s' % (epoch, self.train_rewards[-1] if len(self.train_rewards) else 'collecting'))\n", 810 | " plt.plot(self.train_rewards)\n", 811 | " plt.grid()\n", 812 | " plt.subplot(132)\n", 813 | " plt.title('val tour length: epoch %s reward %s' % (epoch, self.val_rewards[-1] if len(self.val_rewards) else 'collecting'))\n", 814 | " plt.plot(self.val_rewards)\n", 815 | " plt.grid()\n", 816 | " plt.show() " 817 | ] 818 | }, 819 | { 820 | "cell_type": "markdown", 821 | "metadata": {}, 822 | "source": [ 823 | "#### Moving average reward training, more stable" 824 | ] 825 | }, 826 | { 827 | "cell_type": "code", 828 | "execution_count": null, 829 | "metadata": {}, 830 | "outputs": [ 831 | { 832 | "data": { 833 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvcAAAE/CAYAAADCLOz/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nF/H/DXscUNe1lGkAAAAASUVORK5CYII=\n", 834 | "text/plain": [ 835 | "" 836 | ] 837 | }, 838 | "metadata": {}, 839 | "output_type": "display_data" 840 | } 841 | ], 842 | "source": [ 843 | "# moving average reward\n", 844 | "moving_average_model = Model(embedding_dim, hidden_dim, seq_len = tsp_num)\n", 845 | "if USE_CUDA:\n", 846 | " moving_average_model = moving_average_model .cuda()\n", 847 | "train = Train(moving_average_model , train_dataset, validation_dataset, lr = 1e-4)\n", 848 | "train.train_and_validation(6, 10000, use_critic = False)" 849 | ] 850 | }, 851 | { 852 | "cell_type": "markdown", 853 | "metadata": {}, 854 | "source": [ 855 | "#### Actor-Critic training, converge more slowly, not stable, which might be worse sometimes.\n", 856 | "\n", 857 | "I tried learning rate 1e-3 several times, and it might be explode sometimes. Thus, I used same learning rate 1e-4 as moving averages." 858 | ] 859 | }, 860 | { 861 | "cell_type": "code", 862 | "execution_count": 16, 863 | "metadata": {}, 864 | "outputs": [ 865 | { 866 | "data": { 867 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwEAAAE/CAYAAAAe8M/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngiAIgiDaGKQEEARBEARBEEQb4/8DpqLRPVi2jMQAAAAASUVORK5CYII=\n", 868 | "text/plain": [ 869 | "" 870 | ] 871 | }, 872 | "metadata": {}, 873 | "output_type": "display_data" 874 | } 875 | ], 876 | "source": [ 877 | "# use critic\n", 878 | "ac_model = Model(embedding_dim, hidden_dim, seq_len = tsp_num)\n", 879 | "if USE_CUDA:\n", 880 | " ac_model = ac_model.cuda()\n", 881 | "train = Train(ac_model, train_dataset, validation_dataset, lr = 1e-4)\n", 882 | "train.train_and_validation(6, 10000, use_critic = True)" 883 | ] 884 | }, 885 | { 886 | "cell_type": "code", 887 | "execution_count": null, 888 | "metadata": { 889 | "collapsed": true 890 | }, 891 | "outputs": [], 892 | "source": [] 893 | } 894 | ], 895 | "metadata": { 896 | "kernelspec": { 897 | "display_name": "Python 3", 898 | "language": "python", 899 | "name": "python3" 900 | }, 901 | "language_info": { 902 | "codemirror_mode": { 903 | "name": "ipython", 904 | "version": 3 905 | }, 906 | "file_extension": ".py", 907 | "mimetype": "text/x-python", 908 | "name": "python", 909 | "nbconvert_exporter": "python", 910 | "pygments_lexer": "ipython3", 911 | "version": "3.6.5" 912 | } 913 | }, 914 | "nbformat": 4, 915 | "nbformat_minor": 2 916 | } 917 | --------------------------------------------------------------------------------