DRL4TSP (Attention, REINFORCE, active search).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "4bda024b",
   "metadata": {},
   "source": [
    "# Active Search\n",
    "\n",
    "在 **Active Search** 策略中，模型不依赖预先提供的训练数据，而是从测试数据中直接进行优化。具体而言，模型会在测试时针对每个单独的输入问题执行多轮优化，旨在通过主动搜索生成最优解。该过程可以被视为一种无监督的在线优化，目标是针对每个具体问题找到最优解。\n",
    "\n",
    "每次测试时，模型会随机采样不同的解，并在每轮采样后根据反馈信息更新自身的参数。这一迭代过程继续进行，直至找到最优解或达到预设的采样次数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a7b858e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "import os\n",
    "import math\n",
    "import argparse\n",
    "import numpy as np\n",
    "import scipy.stats as stats\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torch.utils.tensorboard import SummaryWriter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04778a16",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义TSPDataset类\n",
    "class TSPDataset(Dataset):\n",
    "    def __init__(self, num_nodes, num_samples, random_seed=42):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.num_nodes = num_nodes\n",
    "        self.num_samples = num_samples\n",
    "        self.sample = torch.rand(self.num_nodes, 2) \n",
    "\n",
    "        self.permutations = []\n",
    "        for idx in range(num_samples):\n",
    "            seed = random_seed + idx\n",
    "            torch.manual_seed(seed)\n",
    "            perm = torch.randperm(num_nodes)\n",
    "            self.permutations.append(perm)\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.num_samples\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        return self.sample[self.permutations[idx]]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "56e1c3ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义reward函数\n",
    "def reward(sols):\n",
    "    # sols: (batch_size, seq_len, input_size)\n",
    "    # lengths: (batch_size,)\n",
    "    lengths = torch.norm(sols[:, 1:, :] - sols[:, :-1, :], dim=2).sum(dim=1)\n",
    "    lengths += torch.norm(sols[:, -1, :] - sols[:, 0, :], dim=1)\n",
    "    return lengths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "504a4b93",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义ResidualConnection类\n",
    "class ResidualConnection(nn.Module):\n",
    "    def __init__(self, module):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.module = module\n",
    "    \n",
    "    def forward(self, x):\n",
    "        return x + self.module(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b3833275",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义Normalization类\n",
    "class Normalization(nn.Module):\n",
    "    def __init__(self, embedding_size, normalization='batch'):\n",
    "        super().__init__()\n",
    "        \n",
    "        normalizer = {\n",
    "            'batch': nn.BatchNorm1d,\n",
    "            'instance': nn.InstanceNorm1d,\n",
    "        }.get(normalization, None)\n",
    "        assert normalizer is not None, f'Unsupported normalization type: {normalization}'\n",
    "        \n",
    "        self.normalizer = normalizer(embedding_size, affine=True)\n",
    "        \n",
    "        self._init_parameters()\n",
    "        \n",
    "    def _init_parameters(self):\n",
    "        if hasattr(self.normalizer, 'weight') and self.normalizer.weight is not None:\n",
    "            nn.init.uniform_(self.normalizer.weight, 0., 1.)\n",
    "        if hasattr(self.normalizer, 'bias') and self.normalizer.bias is not None:\n",
    "            nn.init.zeros_(self.normalizer.bias)\n",
    "            \n",
    "    def forward(self, x):\n",
    "        if isinstance(self.normalizer, nn.BatchNorm1d):\n",
    "            return self.normalizer(x.view(-1, x.size(-1))).view(*x.size())\n",
    "        else:\n",
    "            return self.normalizer(x.permute(0, 2, 1)).permute(0, 2, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fdd89dfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义MultiHeadAttention类\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, num_heads, query_size, key_size, value_size, embedding_size, dropout=0.1):\n",
    "        super().__init__()\n",
    "        assert embedding_size % num_heads == 0\n",
    "        \n",
    "        self.num_heads = num_heads\n",
    "        self.embedding_size = embedding_size\n",
    "        self.head_size = embedding_size // num_heads\n",
    "        \n",
    "        self.W_q = nn.Linear(query_size, embedding_size)\n",
    "        self.W_k = nn.Linear(key_size, embedding_size)\n",
    "        self.W_v = nn.Linear(value_size, embedding_size)\n",
    "        self.W_o = nn.Linear(embedding_size, embedding_size)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        \n",
    "        self.scale_factor = math.sqrt(self.head_size)\n",
    "        \n",
    "        self._init_parameters()\n",
    "        \n",
    "    def _init_parameters(self):\n",
    "        for param in self.parameters():\n",
    "            std = 1. / math.sqrt(param.size(-1))\n",
    "            param.data.uniform_(-std, std)\n",
    "        \n",
    "    def forward(self, q, k=None, v=None, mask=None):\n",
    "        # q: (batch_size, q_len, query_size)\n",
    "        # k: (batch_size, seq_len, key_size)\n",
    "        # v: (batch_size, seq_len, value_size)\n",
    "        # mask: (batch_size, seq_len)\n",
    "        if k is None:\n",
    "            k = q\n",
    "            v = q\n",
    "        q_len = q.size(1)\n",
    "        batch_size, seq_len, _ = k.size()\n",
    "        \n",
    "        # Q: (batch_size, q_len, embedding_size)\n",
    "        Q = self.W_q(q)\n",
    "        # K, V: (batch_size, seq_len, embedding_size)\n",
    "        K = self.W_k(k)\n",
    "        V = self.W_v(v)\n",
    "        \n",
    "        # Q: (batch_size, num_heads, q_len, head_size)\n",
    "        Q = Q.view(batch_size, q_len, self.num_heads, self.head_size).transpose(1, 2)\n",
    "        # K, V: (batch_size, num_heads, seq_len, head_size)\n",
    "        K = K.view(batch_size, seq_len, self.num_heads, self.head_size).transpose(1, 2)\n",
    "        V = V.view(batch_size, seq_len, self.num_heads, self.head_size).transpose(1, 2)\n",
    "        \n",
    "        # attn_scores: (batch_size, num_heads, q_len, seq_len)\n",
    "        attn_scores = torch.matmul(Q, K.transpose(-2, -1)) / self.scale_factor\n",
    "        if mask is not None:\n",
    "            # mask: (batch_size, num_heads, q_len, seq_len)\n",
    "            mask = mask.unsqueeze(1).unsqueeze(1).expand(-1, self.num_heads, q_len, -1)\n",
    "            mask_clone = mask.clone().bool()\n",
    "            attn_scores = attn_scores.masked_fill(mask_clone, float('-inf'))\n",
    "            \n",
    "        # attn_weights: (batch_size, num_heads, q_len, seq_len)\n",
    "        attn_weights = F.softmax(attn_scores, -1)\n",
    "        attn_weights = self.dropout(attn_weights)\n",
    "        \n",
    "        # attn_output: (batch_size, num_heads, q_len, head_size)\n",
    "        attn_output = torch.matmul(attn_weights, V)\n",
    "        # attn_output: (batch_size, q_len, embedding_size)\n",
    "        attn_output = attn_output.transpose(1, 2).contiguous().view(batch_size, q_len, self.embedding_size)\n",
    "        \n",
    "        # output: (batch_size, q_len, embedding_size)\n",
    "        output = self.W_o(attn_output)\n",
    "        \n",
    "        return output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1ecf7a19",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义MultiHeadAttentionLayer类\n",
    "class MultiHeadAttentionLayer(nn.Module):\n",
    "    def __init__(self, num_heads, embedding_size, FF_hidden_size=512, normalization='batch', dropout=0.1):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.attention = ResidualConnection(\n",
    "            MultiHeadAttention(num_heads, embedding_size, embedding_size, embedding_size, embedding_size, dropout)\n",
    "        )\n",
    "        self.norm1 = Normalization(embedding_size, normalization)\n",
    "        \n",
    "        self.feed_forward = ResidualConnection(\n",
    "            nn.Sequential(\n",
    "                nn.Linear(embedding_size, FF_hidden_size),\n",
    "                nn.ReLU(),\n",
    "                nn.Dropout(dropout),\n",
    "                nn.Linear(FF_hidden_size, embedding_size),\n",
    "            ) if FF_hidden_size > 0 else nn.Linear(embedding_size, embedding_size)\n",
    "        )\n",
    "        self.norm2 = Normalization(embedding_size, normalization)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = self.norm1(self.attention(x))\n",
    "        x = self.norm2(self.feed_forward(x))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "44b36b82",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义Encoder类\n",
    "class Encoder(nn.Module):\n",
    "    def __init__(self, num_heads, embedding_size, num_layers, input_size=None, FF_hidden_size=512, normalization='batch', dropout=0.1):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.embedding = nn.Linear(input_size, embedding_size) if input_size is not None else None\n",
    "        self.layers = nn.Sequential(*(\n",
    "            MultiHeadAttentionLayer(num_heads, embedding_size, FF_hidden_size, normalization, dropout)\n",
    "            for _ in range(num_layers)\n",
    "        ))\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        # inputs: (batch_size, seq_len, input_size)\n",
    "        if self.embedding is not None:\n",
    "            # embedded: (batch_size, seq_len, embedding_size)\n",
    "            embedded = self.embedding(inputs)\n",
    "        else:\n",
    "            embedded = inputs\n",
    "        # node_embedding: (batch_size, seq_len, embedding_size)\n",
    "        node_embedding = self.layers(embedded)\n",
    "        return node_embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7402958a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义Decoder类\n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self, num_heads, embedding_size, C=10, dropout=0.1, temperature=None, argmax=False):\n",
    "        super().__init__()\n",
    "        assert embedding_size % num_heads == 0\n",
    "        \n",
    "        self.num_heads = num_heads\n",
    "        self.embedding_size = embedding_size\n",
    "        self.C = C\n",
    "        self.temperature = temperature\n",
    "        self.argmax = argmax\n",
    "        \n",
    "        self.input_placeholder = nn.Parameter(torch.zeros(2 * embedding_size))\n",
    "        \n",
    "        self.multihead_attention = MultiHeadAttention(num_heads, 3 * embedding_size, embedding_size, embedding_size, embedding_size, dropout)\n",
    "        \n",
    "        self.W_q = nn.Linear(embedding_size, embedding_size)\n",
    "        self.W_k = nn.Linear(embedding_size, embedding_size)\n",
    "        self.scale_factor = math.sqrt(embedding_size)\n",
    "        \n",
    "        self._init_parameters()\n",
    "        \n",
    "    def _init_parameters(self):\n",
    "        for param in self.parameters():\n",
    "            std = 1. / math.sqrt(param.size(-1))\n",
    "            param.data.uniform_(-std, std)\n",
    "    \n",
    "    def forward(self, node_embedding):\n",
    "        # node_embedding: (batch_size, seq_len, embedding_size)\n",
    "        batch_size, seq_len, embedding_size = node_embedding.size()\n",
    "        assert self.embedding_size == embedding_size\n",
    "        \n",
    "        # graph_embedding: (batch_size, embedding_size)\n",
    "        graph_embedding = node_embedding.mean(dim=1)\n",
    "        \n",
    "        # mask: (batch_size, seq_len)\n",
    "        mask = torch.zeros(batch_size, seq_len, dtype=torch.bool, device=node_embedding.device)\n",
    "        \n",
    "        idxs = None\n",
    "        first_node_context, current_node_context = None, None\n",
    "        prev_probs, prev_idxs = [], []\n",
    "        \n",
    "        for _ in range(seq_len):\n",
    "            if first_node_context is None:\n",
    "                # context_embedding: (batch_size, 3 * embedding_size)\n",
    "                context_embedding = torch.cat((graph_embedding, self.input_placeholder.unsqueeze(0).expand(batch_size, -1)), dim=1)\n",
    "            else:\n",
    "                # context_embedding: (batch_size, 3 * embedding_size)\n",
    "                context_embedding = torch.cat((graph_embedding, current_node_context, first_node_context), dim=1)\n",
    "                \n",
    "            # attn_output: (batch_size, embedding_size)\n",
    "            attn_output = self.multihead_attention(context_embedding.unsqueeze(1), node_embedding, node_embedding, mask).squeeze(1)\n",
    "            \n",
    "            # query: (batch_size, embedding_size)\n",
    "            query = self.W_q(attn_output)\n",
    "            # key: (batch_size, seq_len, embedding_size)\n",
    "            key = self.W_k(node_embedding)\n",
    "            \n",
    "            # logits: (batch_size, seq_len)\n",
    "            logits = torch.matmul(query.unsqueeze(1), key.transpose(-2, -1)).squeeze(1) / self.scale_factor\n",
    "            logits = self.C * torch.tanh(logits)\n",
    "            mask_clone = mask.clone().bool()\n",
    "            logits = logits.masked_fill(mask_clone, float('-inf'))\n",
    "            \n",
    "            # probs: (batch_size, seq_len)\n",
    "            probs = F.softmax(logits, dim=-1) if self.temperature is None else F.softmax(logits / self.temperature, dim=-1)\n",
    "            # idxs: (batch_size,)\n",
    "            if self.argmax:\n",
    "                idxs = torch.argmax(probs, 1)\n",
    "            else:\n",
    "                idxs = torch.multinomial(probs, 1).squeeze(1)\n",
    "            mask[torch.arange(batch_size), idxs] = True\n",
    "            \n",
    "            \n",
    "            prev_probs.append(probs[torch.arange(batch_size), idxs])\n",
    "            prev_idxs.append(idxs)\n",
    "            \n",
    "            # current_node_context: (batch_size, embedding_size)\n",
    "            current_node_context = node_embedding[torch.arange(batch_size), idxs, :]\n",
    "            if first_node_context is None:\n",
    "                first_node_context = current_node_context\n",
    "                \n",
    "        # prev_probs, prev_idxs: (batch_size, seq_len)\n",
    "        prev_probs = torch.stack(prev_probs, dim=1)\n",
    "        prev_idxs = torch.stack(prev_idxs, dim=1)\n",
    "        return prev_probs, prev_idxs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0d2aabcf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义Actor类\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, num_heads, embedding_size, num_layers, input_size, FF_hidden_size, normalization, dropout, C, temperature, argmax, reward):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.reward = reward\n",
    "        \n",
    "        self.encoder = Encoder(num_heads, embedding_size, num_layers, input_size, FF_hidden_size, normalization, dropout)\n",
    "        self.decoder = Decoder(num_heads, embedding_size, C, dropout, temperature, argmax)\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        # inputs: (batch_size, seq_len, input_size)\n",
    "        # node_embedding: (batch_size, seq_len, input_size)\n",
    "        node_embedding = self.encoder(inputs)\n",
    "        # probs, idxs: (batch_size, seq_len)\n",
    "        probs, idxs = self.decoder(node_embedding)\n",
    "        # actions: (batch_size, seq_len, input_size)\n",
    "        actions = inputs[torch.arange(inputs.size(0)).unsqueeze(1), idxs]\n",
    "        # rewards: (batch_size,)\n",
    "        rewards = self.reward(actions)\n",
    "        return rewards, idxs, probs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "efe10c54",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练\n",
    "def train(args, train_dataset):\n",
    "    train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)\n",
    "    \n",
    "    actor = Actor(args.num_heads, args.embedding_size, args.num_layers, args.input_size, args.FF_hidden_size, args.normalization, args.dropout, args.C, args.temperature, False, reward).to(args.device)\n",
    "    optimizer = optim.Adam(actor.parameters(), lr=args.lr)\n",
    "    \n",
    "    step = 0\n",
    "    baseline = 0\n",
    "    best_length = float('inf')\n",
    "    best_tour, best_input = None, None\n",
    "    writer = SummaryWriter()\n",
    "    model_path = os.path.join(args.output_dir, args.name)\n",
    "    \n",
    "    for epoch in range(args.n_epochs):\n",
    "        for batch_id, train_batch in enumerate(train_loader):\n",
    "            actor.train()\n",
    "            \n",
    "            # inputs: (batch_size, seq_len, input_size)\n",
    "            inputs = train_batch.to(args.device)\n",
    "            # rewards: (batch_size,)\n",
    "            # idxs, probs: (batch_size, seq_len)\n",
    "            rewards, idxs, probs = actor(inputs)\n",
    "            # log_probs: (batch_size)\n",
    "            log_probs = torch.log(probs.clamp(min=1e-10)).sum(dim=1)\n",
    "            baseline = baseline * args.beta + rewards.mean().item() * (1 - args.beta)\n",
    "            # advantage: (batch_size,)\n",
    "            advantage = rewards - baseline\n",
    "            # reinforce: (batch_size,)\n",
    "            reinforce = advantage.detach() * log_probs\n",
    "            actor_loss = reinforce.mean()\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            torch.nn.utils.clip_grad_norm_(actor.parameters(), args.max_grad_norm)\n",
    "            optimizer.step()\n",
    "            \n",
    "            writer.add_scalar('Actor_Loss/train', actor_loss.item(), step)\n",
    "            writer.add_scalar('Length/train', rewards.mean().item(), step)       \n",
    "            best_reward, best_idx = rewards.min(0)\n",
    "            if best_reward < best_length:\n",
    "                best_length = best_reward\n",
    "                best_tour = idxs[best_idx].clone()\n",
    "                best_input = inputs[best_idx].clone()\n",
    "            step += 1\n",
    "            \n",
    "            if batch_id % 100 == 0:\n",
    "                print(f\"Epoch [{epoch + 1}/{args.n_epochs}], Batch [{batch_id + 1}/{len(train_loader)}], \"\n",
    "                      f\"Actor Loss: {actor_loss.item():.4f}, Reward: {rewards.mean().item():.4f}, \"\n",
    "                      f\"Best Length: {best_length:.4f}\")\n",
    "        \n",
    "    plot_tsp_path(args, best_input, best_tour, best_length)\n",
    "    \n",
    "    writer.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "e8522063",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_tsp_path(args, inputs, idxs, rewards):\n",
    "    # inputs: (seq_len, 2)\n",
    "    # idxs: (seq_len)\n",
    "    # rewards: (1,)\n",
    "    inputs = inputs.cpu().numpy()\n",
    "    idxs = idxs.cpu().numpy()\n",
    "    rewards = rewards.cpu().numpy()\n",
    "\n",
    "    fig = plt.figure(figsize=(8, 8))\n",
    "    fig.suptitle(f'{args.name} - Length: {rewards:.3f}')\n",
    "    \n",
    "    for j in range(len(idxs)):\n",
    "        x1, y1 = inputs[idxs[j - 1]]\n",
    "        x2, y2 = inputs[idxs[j]]\n",
    "        plt.plot([x1, x2], [y1, y2], 'bo-') \n",
    "\n",
    "    plt.scatter(inputs[:, 0], inputs[:, 1], c='red')  \n",
    "    plt.scatter(inputs[0, 0], inputs[0, 1], c='yellow')  \n",
    "    \n",
    "    plt.tight_layout(rect=[0, 0, 1, 0.95])\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ceaa263a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 参数\n",
    "args = argparse.Namespace()\n",
    "args.seq_len = 50\n",
    "args.n_epochs = 30\n",
    "args.batch_size = 512\n",
    "args.lr = 1e-4\n",
    "args.num_heads = 8\n",
    "args.embedding_size = 128\n",
    "args.num_layers = 3\n",
    "args.input_size = 2\n",
    "args.FF_hidden_size = 512\n",
    "args.normalization = 'batch'\n",
    "args.dropout = 0.1\n",
    "args.C = 10 \n",
    "args.temperature = None\n",
    "args.max_grad_norm = 1.\n",
    "args.alpha = 0.05\n",
    "args.beta = 0.99\n",
    "args.output_dir = 'output'\n",
    "args.name = 'DRL4TSP_Attention_ActiveSearch_TSP' + str(args.seq_len)\n",
    "args.device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
    "\n",
    "os.makedirs(args.output_dir, exist_ok=True)\n",
    "\n",
    "train_dataset = TSPDataset(args.seq_len, 51200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "560f4ff1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training started...\n",
      "Epoch [1/30], Batch [1/100], Actor Loss: -3643.9551, Reward: 25.0186, Best Length: 20.4292\n",
      "Epoch [2/30], Batch [1/100], Actor Loss: -158.8533, Reward: 13.0274, Best Length: 9.9110\n",
      "Epoch [3/30], Batch [1/100], Actor Loss: 64.8725, Reward: 9.1581, Best Length: 6.9265\n",
      "Epoch [4/30], Batch [1/100], Actor Loss: 41.8810, Reward: 7.9609, Best Length: 6.3865\n",
      "Epoch [5/30], Batch [1/100], Actor Loss: 23.2112, Reward: 7.1440, Best Length: 6.1564\n",
      "Epoch [6/30], Batch [1/100], Actor Loss: 10.9371, Reward: 6.6406, Best Length: 5.9798\n",
      "Epoch [7/30], Batch [1/100], Actor Loss: 4.5864, Reward: 6.3063, Best Length: 5.9612\n",
      "Epoch [8/30], Batch [1/100], Actor Loss: 1.0381, Reward: 6.1799, Best Length: 5.9612\n",
      "Epoch [9/30], Batch [1/100], Actor Loss: 0.5014, Reward: 6.0748, Best Length: 5.9612\n",
      "Epoch [10/30], Batch [1/100], Actor Loss: -0.1862, Reward: 6.0468, Best Length: 5.9612\n",
      "Epoch [11/30], Batch [1/100], Actor Loss: 0.0330, Reward: 6.0078, Best Length: 5.9612\n",
      "Epoch [12/30], Batch [1/100], Actor Loss: -0.1362, Reward: 6.0036, Best Length: 5.9612\n",
      "Epoch [13/30], Batch [1/100], Actor Loss: -0.0729, Reward: 5.9893, Best Length: 5.9612\n",
      "Epoch [14/30], Batch [1/100], Actor Loss: -0.1105, Reward: 6.0004, Best Length: 5.9612\n",
      "Epoch [15/30], Batch [1/100], Actor Loss: -0.3560, Reward: 5.9931, Best Length: 5.9612\n",
      "Epoch [16/30], Batch [1/100], Actor Loss: -0.0774, Reward: 5.9827, Best Length: 5.9612\n",
      "Epoch [17/30], Batch [1/100], Actor Loss: -0.0633, Reward: 5.9814, Best Length: 5.9612\n",
      "Epoch [18/30], Batch [1/100], Actor Loss: -0.1469, Reward: 5.9849, Best Length: 5.9612\n",
      "Epoch [19/30], Batch [1/100], Actor Loss: -0.0543, Reward: 5.9733, Best Length: 5.9612\n",
      "Epoch [20/30], Batch [1/100], Actor Loss: -0.0546, Reward: 5.9738, Best Length: 5.9612\n",
      "Epoch [21/30], Batch [1/100], Actor Loss: -0.0275, Reward: 5.9720, Best Length: 5.9612\n",
      "Epoch [22/30], Batch [1/100], Actor Loss: -0.3545, Reward: 5.9902, Best Length: 5.9612\n",
      "Epoch [23/30], Batch [1/100], Actor Loss: -0.0378, Reward: 5.9713, Best Length: 5.9612\n",
      "Epoch [24/30], Batch [1/100], Actor Loss: -0.1833, Reward: 5.9771, Best Length: 5.9612\n",
      "Epoch [25/30], Batch [1/100], Actor Loss: -0.0431, Reward: 5.9704, Best Length: 5.9612\n",
      "Epoch [26/30], Batch [1/100], Actor Loss: -0.0842, Reward: 5.9727, Best Length: 5.9612\n",
      "Epoch [27/30], Batch [1/100], Actor Loss: -0.0482, Reward: 5.9691, Best Length: 5.9612\n",
      "Epoch [28/30], Batch [1/100], Actor Loss: -0.0146, Reward: 5.9662, Best Length: 5.9612\n",
      "Epoch [29/30], Batch [1/100], Actor Loss: -0.0290, Reward: 5.9677, Best Length: 5.9612\n",
      "Epoch [30/30], Batch [1/100], Actor Loss: -0.0395, Reward: 5.9677, Best Length: 5.9612\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training completed!\n"
     ]
    }
   ],
   "source": [
    "print('Training started...')\n",
    "train(args, train_dataset)\n",
    "print('Training completed!')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}