self_transformer.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## ref : https://github.com/hyunwoongko/transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 导库\n",
    "import torch\n",
    "from torch import nn\n",
    "import spacy\n",
    "import torchtext\n",
    "from torchtext.legacy.data import Field, BucketIterator\n",
    "from torchtext.legacy.datasets.translation import Multi30k\n",
    "import math\n",
    "import time\n",
    "from rich.progress import track\n",
    "from collections import Counter\n",
    "import numpy as np\n",
    "from torch import nn, optim\n",
    "from torch.optim import Adam\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import re\n",
    "# from rich import print\n",
    "## 导入一些参数设置\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda:1\n",
      "1.9.0+cu111\n",
      "0.10.0\n"
     ]
    }
   ],
   "source": [
    "## 设置超参数\n",
    "device = torch.device(\"cuda:1\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(device)\n",
    "print(torch.__version__)\n",
    "print(torchtext.__version__)\n",
    "\n",
    "# model parameter setting\n",
    "batch_size = 128\n",
    "max_len = 256\n",
    "d_model = 512\n",
    "n_layers = 6\n",
    "n_heads = 8\n",
    "ffn_hidden = 2048\n",
    "drop_prob = 0.1\n",
    "\n",
    "# optimizer parameter setting\n",
    "init_lr = 1e-5\n",
    "factor = 0.9\n",
    "adam_eps = 5e-9\n",
    "patience = 10\n",
    "warmup = 100\n",
    "epoch = 10\n",
    "clip = 1.0\n",
    "weight_decay = 5e-4\n",
    "inf = float(\"inf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "### 定义 dataloader 和 tokenzier\n",
    "class Tokenizer:\n",
    "    def __init__(self):\n",
    "        self.spacy_de = spacy.load(\"de_core_news_sm\")\n",
    "        self.spacy_en = spacy.load(\"en_core_web_sm\")\n",
    "\n",
    "    def tokenize_de(self, text):\n",
    "        \"\"\"\n",
    "        Tokenizes German text from a string into a list of strings\n",
    "        \"\"\"\n",
    "        return [tok.text for tok in self.spacy_de.tokenizer(text)]\n",
    "\n",
    "    def tokenize_en(self, text):\n",
    "        \"\"\"\n",
    "        Tokenizes English text from a string into a list of strings\n",
    "        \"\"\"\n",
    "        return [tok.text for tok in self.spacy_en.tokenizer(text)]\n",
    "\n",
    "class DataLoader:\n",
    "    source: Field = None\n",
    "    target: Field = None\n",
    "\n",
    "    def __init__(self, ext, tokenize_en, tokenize_de, init_token, eos_token):\n",
    "        self.ext = ext\n",
    "        self.tokenize_en = tokenize_en\n",
    "        self.tokenize_de = tokenize_de\n",
    "        self.init_token = init_token\n",
    "        self.eos_token = eos_token\n",
    "        print(\"dataset initializing start\")\n",
    "\n",
    "    def make_dataset(self):\n",
    "        if self.ext == (\".de\", \".en\"):\n",
    "            self.source = Field(tokenize=self.tokenize_de, init_token=self.init_token, eos_token=self.eos_token, lower=True, batch_first=True)\n",
    "            self.target = Field(tokenize=self.tokenize_en, init_token=self.init_token, eos_token=self.eos_token, lower=True, batch_first=True)\n",
    "\n",
    "        elif self.ext == (\".en\", \".de\"):\n",
    "            self.source = Field(tokenize=self.tokenize_en, init_token=self.init_token, eos_token=self.eos_token, lower=True, batch_first=True)\n",
    "            self.target = Field(tokenize=self.tokenize_de, init_token=self.init_token, eos_token=self.eos_token, lower=True, batch_first=True)\n",
    "\n",
    "        train_data, valid_data, test_data = Multi30k.splits(exts=self.ext, fields=(self.source, self.target))\n",
    "        return train_data, valid_data, test_data\n",
    "\n",
    "    def build_vocab(self, train_data, min_freq):\n",
    "        self.source.build_vocab(train_data, min_freq=min_freq)\n",
    "        self.target.build_vocab(train_data, min_freq=min_freq)\n",
    "\n",
    "    def make_iter(self, train, validate, test, batch_size, device):\n",
    "        train_iterator, valid_iterator, test_iterator = BucketIterator.splits((train, validate, test), batch_size=batch_size, device=device)\n",
    "        print(\"dataset initializing done\")\n",
    "        return train_iterator, valid_iterator, test_iterator\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dataset initializing start\n",
      "dataset initializing done\n",
      "5893 7853\n",
      "src: ['two', 'young', ',', 'white', 'males', 'are', 'outside', 'near', 'many', 'bushes', '.']\n",
      "trg: ['zwei', 'junge', 'weiße', 'männer', 'sind', 'im', 'freien', 'in', 'der', 'nähe', 'vieler', 'büsche', '.']\n",
      "\n",
      " 数据观察: \n",
      "\n",
      "src: tensor([[  2,   4,  64,  ...,   1,   1,   1],\n",
      "        [  2,  30, 820,  ...,   1,   1,   1],\n",
      "        [  2,   4,   9,  ...,   1,   1,   1],\n",
      "        ...,\n",
      "        [  2,   4,   9,  ...,   1,   1,   1],\n",
      "        [  2,   4,  14,  ...,   1,   1,   1],\n",
      "        [  2,   4,   9,  ...,   1,   1,   1]], device='cuda:1')\n",
      "src: tensor([[  2,   5, 431,  ...,   1,   1,   1],\n",
      "        [  2,  30, 400,  ...,   1,   1,   1],\n",
      "        [  2,   5,  13,  ...,   1,   1,   1],\n",
      "        ...,\n",
      "        [  2,   5,  13,  ...,   1,   1,   1],\n",
      "        [  2,   8,  16,  ...,   1,   1,   1],\n",
      "        [  2,   5,  13,  ...,   1,   1,   1]], device='cuda:1')\n"
     ]
    }
   ],
   "source": [
    "## 加载分词后的数据 并观察\n",
    "tokenizer = Tokenizer()\n",
    "loader = DataLoader(\n",
    "    ext=(\".en\", \".de\"),\n",
    "    tokenize_en=tokenizer.tokenize_en,\n",
    "    tokenize_de=tokenizer.tokenize_de,\n",
    "    init_token=\"<sos>\",\n",
    "    eos_token=\"<eos>\",\n",
    ")\n",
    "\n",
    "train, valid, test = loader.make_dataset()\n",
    "loader.build_vocab(train_data=train, min_freq=2)\n",
    "train_iter, valid_iter, test_iter = loader.make_iter(\n",
    "    train,\n",
    "    valid,\n",
    "    test,\n",
    "    batch_size=batch_size,\n",
    "    device=device,\n",
    ")\n",
    "src_pad_idx = loader.source.vocab.stoi[\"<pad>\"]\n",
    "trg_pad_idx = loader.target.vocab.stoi[\"<pad>\"]\n",
    "trg_sos_idx = loader.target.vocab.stoi[\"<sos>\"]\n",
    "\n",
    "enc_voc_size = len(loader.source.vocab)\n",
    "dec_voc_size = len(loader.target.vocab)\n",
    "\n",
    "print(enc_voc_size, dec_voc_size)\n",
    "\n",
    "print(\"src:\", train[0].src)\n",
    "print(\"trg:\", train[0].trg)\n",
    "\n",
    "print(\"\\n 数据观察: \\n\")\n",
    "item = None\n",
    "for item1 in train_iter:\n",
    "    item = item1\n",
    "    break\n",
    "print(\"src:\", item.src)\n",
    "print(\"src:\", item.trg)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 功能块定义\n",
    "class LayerNorm(nn.Module):\n",
    "    def __init__(self, d_model, eps=1e-12):\n",
    "        super(LayerNorm, self).__init__()\n",
    "        self.gamma = nn.Parameter(torch.ones(d_model))\n",
    "        self.beta = nn.Parameter(torch.zeros(d_model))\n",
    "        self.eps = eps\n",
    "\n",
    "    def forward(self, x):\n",
    "        mean = x.mean(-1, keepdim=True)\n",
    "        var = x.var(-1, unbiased=False, keepdim=True)\n",
    "        # '-1' means last dimension.\n",
    "        out = (x - mean) / torch.sqrt(var + self.eps)\n",
    "        out = self.gamma * out + self.beta\n",
    "        return out\n",
    "\n",
    "\n",
    "class ScaleDotProductAttention(nn.Module):\n",
    "    \"\"\"\n",
    "    compute scale dot product attention\n",
    "    \n",
    "    Query : given sentence that we focused on (decoder)\n",
    "    Key : every sentence to check relationship with Qeury(encoder)\n",
    "    Value : every sentence same with Key (encoder)\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        super(ScaleDotProductAttention, self).__init__()\n",
    "        self.softmax = nn.Softmax(dim=-1)\n",
    "\n",
    "    def forward(self, q, k, v, mask=None, e=1e-12):\n",
    "        \"\"\"\n",
    "        * @description:\n",
    "        * @param {*} self\n",
    "        * @param {*} q     b * H * L * d_model/H\n",
    "        * @param {*} k     b * H * L * d_model/H\n",
    "        * @param {*} v     b * H * L * d_model/H\n",
    "        * @param {*} mask  encode:  b *1 *1 * L   ||  decode: b *1 *L *L\n",
    "        * @param {*} e\n",
    "        * @return {*}\n",
    "        \"\"\"\n",
    "        # input is 4 dimension tensor\n",
    "        # [batch_size, head, length, d_tensor]\n",
    "        batch_size, head, length, d_tensor = k.size()\n",
    "\n",
    "        # 1. dot product Query with Key^T to compute similarity\n",
    "        k_t = k.transpose(2, 3)  # transpose\n",
    "        score = (q @ k_t) / math.sqrt(d_tensor)  # scaled dot product  ## b *H * L*L\n",
    "\n",
    "        # 2. apply masking (opt)\n",
    "        if mask is not None:\n",
    "            score = score.masked_fill(mask == 0, -10000)\n",
    "\n",
    "        # 3. pass them softmax to make [0, 1] range\n",
    "        score = self.softmax(score)\n",
    "\n",
    "        # 4. multiply with Value\n",
    "        v = score @ v\n",
    "\n",
    "        return v, score\n",
    "\n",
    "\n",
    "class MultiHeadAttention(nn.Module):\n",
    "    def __init__(self, d_model, n_head):\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        self.n_head = n_head\n",
    "        self.attention = ScaleDotProductAttention()\n",
    "        self.w_q = nn.Linear(d_model, d_model)\n",
    "        self.w_k = nn.Linear(d_model, d_model)\n",
    "        self.w_v = nn.Linear(d_model, d_model)\n",
    "        self.w_concat = nn.Linear(d_model, d_model)\n",
    "\n",
    "    def forward(self, q, k, v, mask=None):  ## if  encoder: mask b*1*1*L  decoder : masrk  b *1 * L *L   || if cross attention\n",
    "        # 1. dot product with weight matrices\n",
    "        q, k, v = self.w_q(q), self.w_k(k), self.w_v(v)  ## b *h *L*L\n",
    "\n",
    "        # 2. split tensor by number of heads\n",
    "        q, k, v = self.split(q), self.split(k), self.split(v)  ## b * h * L *(d_model/h)\n",
    "        # 3. do scale dot product to compute similarity\n",
    "        out, attention = self.attention(q, k, v, mask=mask)\n",
    "\n",
    "        # 4. concat and pass to linear layer\n",
    "        out = self.concat(out)\n",
    "        out = self.w_concat(out)\n",
    "\n",
    "        # 5. visualize attention map\n",
    "        # TODO : we should implement visualization\n",
    "\n",
    "        return out  ## b * L * d_model\n",
    "\n",
    "    def split(self, tensor):\n",
    "        \"\"\"\n",
    "        split tensor by number of head\n",
    "\n",
    "        :param tensor: [batch_size, length, d_model]\n",
    "        :return: [batch_size, head, length, d_tensor]\n",
    "        \"\"\"\n",
    "        batch_size, length, d_model = tensor.size()\n",
    "\n",
    "        d_tensor = d_model // self.n_head\n",
    "        tensor = tensor.view(batch_size, length, self.n_head, d_tensor).transpose(1, 2)\n",
    "        # it is similar with group convolution (split by number of heads)\n",
    "\n",
    "        return tensor\n",
    "\n",
    "    def concat(self, tensor):\n",
    "        \"\"\"\n",
    "        inverse function of self.split(tensor : torch.Tensor)\n",
    "\n",
    "        :param tensor: [batch_size, head, length, d_tensor]\n",
    "        :return: [batch_size, length, d_model]\n",
    "        \"\"\"\n",
    "        batch_size, head, length, d_tensor = tensor.size()\n",
    "        d_model = head * d_tensor\n",
    "\n",
    "        tensor = tensor.transpose(1, 2).contiguous().view(batch_size, length, d_model)\n",
    "        return tensor\n",
    "\n",
    "\n",
    "class PositionwiseFeedForward(nn.Module):\n",
    "    def __init__(self, d_model, hidden, drop_prob=0.1):\n",
    "        super(PositionwiseFeedForward, self).__init__()\n",
    "        self.linear1 = nn.Linear(d_model, hidden)\n",
    "        self.linear2 = nn.Linear(hidden, d_model)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout(p=drop_prob)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.linear1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.dropout(x)\n",
    "        x = self.linear2(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 定义embedding _layer\n",
    "class PositionalEncoding(nn.Module):\n",
    "    \"\"\"\n",
    "    compute sinusoid encoding.\n",
    "    \"\"\"\n",
    "    def __init__(self, d_model, max_len, device):\n",
    "        \"\"\"\n",
    "        constructor of sinusoid encoding class\n",
    "\n",
    "        :param d_model: dimension of model\n",
    "        :param max_len: max sequence length\n",
    "        :param device: hardware device setting\n",
    "        \"\"\"\n",
    "        super(PositionalEncoding, self).__init__()\n",
    "\n",
    "        # same size with input matrix (for adding with input matrix)\n",
    "        self.encoding = torch.zeros(max_len, d_model, device=device)\n",
    "        self.encoding.requires_grad = False  # we don't need to compute gradient\n",
    "\n",
    "        pos = torch.arange(0, max_len, device=device)\n",
    "        pos = pos.float().unsqueeze(dim=1)\n",
    "        # 1D => 2D unsqueeze to represent word's position\n",
    "\n",
    "        _2i = torch.arange(0, d_model, step=2, device=device).float()\n",
    "        # 'i' means index of d_model (e.g. embedding size = 50, 'i' = [0,50])\n",
    "        # \"step=2\" means 'i' multiplied with two (same with 2 * i)\n",
    "\n",
    "        self.encoding[:, 0::2] = torch.sin(pos / (10000 ** (_2i / d_model)))\n",
    "        self.encoding[:, 1::2] = torch.cos(pos / (10000 ** (_2i / d_model)))\n",
    "        # compute positional encoding to consider positional information of words\n",
    "\n",
    "    def forward(self, x):\n",
    "        # self.encoding\n",
    "        # [max_len = 512, d_model = 512]\n",
    "\n",
    "        batch_size, seq_len = x.size()\n",
    "        # [batch_size = 128, seq_len = 30]\n",
    "\n",
    "        return self.encoding[:seq_len, :]\n",
    "        # [seq_len = 30, d_model = 512]\n",
    "        # it will add with tok_emb : [128, 30, 512]\n",
    "\n",
    "\n",
    "class TokenEmbedding(nn.Embedding):\n",
    "    \"\"\"\n",
    "    Token Embedding using torch.nn\n",
    "    they will dense representation of word using weighted matrix\n",
    "    \"\"\"\n",
    "    def __init__(self, vocab_size, d_model):\n",
    "        \"\"\"\n",
    "        class for token embedding that included positional information\n",
    "\n",
    "        :param vocab_size: size of vocabulary\n",
    "        :param d_model: dimensions of model\n",
    "        \"\"\"\n",
    "        super(TokenEmbedding, self).__init__(vocab_size, d_model, padding_idx=1)\n",
    "\n",
    "\n",
    "class TransformerEmbedding(nn.Module):\n",
    "    \"\"\"\n",
    "    token embedding + positional encoding (sinusoid)\n",
    "    positional encoding can give positional information to network\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, vocab_size, d_model, max_len, drop_prob, device):\n",
    "        \"\"\"\n",
    "        class for word embedding that included positional information\n",
    "\n",
    "        :param vocab_size: size of vocabulary\n",
    "        :param d_model: dimensions of model\n",
    "        \"\"\"\n",
    "        super(TransformerEmbedding, self).__init__()\n",
    "        self.tok_emb = TokenEmbedding(vocab_size, d_model)\n",
    "        self.pos_emb = PositionalEncoding(d_model, max_len, device)\n",
    "        self.drop_out = nn.Dropout(p=drop_prob)\n",
    "\n",
    "    def forward(self, x):\n",
    "        tok_emb = self.tok_emb(x)\n",
    "        pos_emb = self.pos_emb(x)\n",
    "        return self.drop_out(tok_emb + pos_emb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 定义Encoder decoder 层\n",
    "class EncoderLayer(nn.Module):\n",
    "    def __init__(self, d_model, ffn_hidden, n_head, drop_prob):\n",
    "        super(EncoderLayer, self).__init__()\n",
    "        self.attention = MultiHeadAttention(d_model=d_model, n_head=n_head)\n",
    "        self.norm1 = LayerNorm(d_model=d_model)\n",
    "        self.dropout1 = nn.Dropout(p=drop_prob)\n",
    "\n",
    "        self.ffn = PositionwiseFeedForward(d_model=d_model, hidden=ffn_hidden, drop_prob=drop_prob)\n",
    "        self.norm2 = LayerNorm(d_model=d_model)\n",
    "        self.dropout2 = nn.Dropout(p=drop_prob)\n",
    "\n",
    "    def forward(self, x, src_mask):\n",
    "        # 1. compute self attention\n",
    "        _x = x\n",
    "        x = self.attention(q=x, k=x, v=x, mask=src_mask)\n",
    "\n",
    "        # 2. add and norm\n",
    "        x = self.dropout1(x)\n",
    "        x = self.norm1(x + _x)\n",
    "\n",
    "        # 3. positionwise feed forward network\n",
    "        _x = x\n",
    "        x = self.ffn(x)\n",
    "\n",
    "        # 4. add and norm\n",
    "        x = self.dropout2(x)\n",
    "        x = self.norm2(x + _x)\n",
    "        return x\n",
    "\n",
    "\n",
    "class DecoderLayer(nn.Module):\n",
    "    def __init__(self, d_model, ffn_hidden, n_head, drop_prob):\n",
    "        super(DecoderLayer, self).__init__()\n",
    "        self.self_attention = MultiHeadAttention(d_model=d_model, n_head=n_head)\n",
    "        self.norm1 = LayerNorm(d_model=d_model)\n",
    "        self.dropout1 = nn.Dropout(p=drop_prob)\n",
    "\n",
    "        self.enc_dec_attention = MultiHeadAttention(d_model=d_model, n_head=n_head)\n",
    "        self.norm2 = LayerNorm(d_model=d_model)\n",
    "        self.dropout2 = nn.Dropout(p=drop_prob)\n",
    "\n",
    "        self.ffn = PositionwiseFeedForward(d_model=d_model, hidden=ffn_hidden, drop_prob=drop_prob)\n",
    "        self.norm3 = LayerNorm(d_model=d_model)\n",
    "        self.dropout3 = nn.Dropout(p=drop_prob)\n",
    "\n",
    "    def forward(self, dec, enc, trg_mask, src_mask):  # src_mask : b * 1 * L *L\n",
    "        # 1. compute self attention\n",
    "        _x = dec\n",
    "        x = self.self_attention(q=dec, k=dec, v=dec, mask=trg_mask)\n",
    "\n",
    "        # 2. add and norm\n",
    "        x = self.dropout1(x)\n",
    "        x = self.norm1(x + _x)  ## b * L * 512\n",
    "\n",
    "        if enc is not None:\n",
    "            # 3. compute encoder - decoder attention\n",
    "            _x = x\n",
    "            x = self.enc_dec_attention(q=x, k=enc, v=enc, mask=src_mask)\n",
    "\n",
    "            # 4. add and norm\n",
    "            x = self.dropout2(x)\n",
    "            x = self.norm2(x + _x)\n",
    "\n",
    "        # 5. positionwise feed forward network\n",
    "        _x = x\n",
    "        x = self.ffn(x)\n",
    "\n",
    "        # 6. add and norm\n",
    "        x = self.dropout3(x)\n",
    "        x = self.norm3(x + _x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "### 定义整体模型\n",
    "class Encoder(nn.Module):\n",
    "    def __init__(self, enc_voc_size, max_len, d_model, ffn_hidden, n_head, n_layers, drop_prob, device):\n",
    "        super().__init__()\n",
    "        self.emb = TransformerEmbedding(d_model=d_model, max_len=max_len, vocab_size=enc_voc_size, drop_prob=drop_prob, device=device)\n",
    "        self.layers = nn.ModuleList([EncoderLayer(d_model=d_model, ffn_hidden=ffn_hidden, n_head=n_head, drop_prob=drop_prob) for _ in range(n_layers)])\n",
    "\n",
    "    def forward(self, x, src_mask):\n",
    "        x = self.emb(x)\n",
    "        for layer in self.layers:\n",
    "            x = layer(x, src_mask)\n",
    "        return x\n",
    "\n",
    "\n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self, dec_voc_size, max_len, d_model, ffn_hidden, n_head, n_layers, drop_prob, device):\n",
    "        super().__init__()\n",
    "        self.emb = TransformerEmbedding(d_model=d_model, drop_prob=drop_prob, max_len=max_len, vocab_size=dec_voc_size, device=device)\n",
    "        self.layers = nn.ModuleList([DecoderLayer(d_model=d_model, ffn_hidden=ffn_hidden, n_head=n_head, drop_prob=drop_prob) for _ in range(n_layers)])\n",
    "        self.linear = nn.Linear(d_model, dec_voc_size)\n",
    "\n",
    "    def forward(self, trg, enc_src, trg_mask, src_mask):\n",
    "        trg = self.emb(trg)\n",
    "        for layer in self.layers:\n",
    "            trg = layer(trg, enc_src, trg_mask, src_mask)\n",
    "        # pass to LM head\n",
    "        output = self.linear(trg)\n",
    "        return output\n",
    "\n",
    "\n",
    "class Transformer(nn.Module):\n",
    "    def __init__(self, src_pad_idx, trg_pad_idx, trg_sos_idx, enc_voc_size, dec_voc_size, d_model, n_head, max_len, ffn_hidden, n_layers, drop_prob, device):\n",
    "        super().__init__()\n",
    "        self.src_pad_idx = src_pad_idx\n",
    "        self.trg_pad_idx = trg_pad_idx\n",
    "        self.trg_sos_idx = trg_sos_idx\n",
    "        self.device = device\n",
    "        self.encoder = Encoder(d_model=d_model, n_head=n_head, max_len=max_len, ffn_hidden=ffn_hidden, enc_voc_size=enc_voc_size, drop_prob=drop_prob, n_layers=n_layers, device=device)\n",
    "        self.decoder = Decoder(d_model=d_model, n_head=n_head, max_len=max_len, ffn_hidden=ffn_hidden, dec_voc_size=dec_voc_size, drop_prob=drop_prob, n_layers=n_layers, device=device)\n",
    "\n",
    "    def forward(self, src, trg):\n",
    "        src_mask = self.make_src_mask(src)\n",
    "        trg_mask = self.make_trg_mask(trg)\n",
    "        enc_src = self.encoder(src, src_mask)  ## b * L * d_model\n",
    "        output = self.decoder(trg, enc_src, trg_mask, src_mask)\n",
    "        return output\n",
    "\n",
    "    def make_src_mask(self, src):\n",
    "        src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2)\n",
    "        return src_mask\n",
    "\n",
    "    def make_trg_mask(self, trg):\n",
    "        trg_pad_mask = (trg != self.trg_pad_idx).unsqueeze(1).unsqueeze(3)\n",
    "        trg_len = trg.shape[1]\n",
    "        trg_sub_mask = torch.tril(torch.ones(trg_len, trg_len)).type(torch.ByteTensor).to(self.device)\n",
    "        trg_mask = trg_pad_mask & trg_sub_mask.to(torch.bool)\n",
    "        return trg_mask\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "## 定义一些工具方法\n",
    "def count_parameters(model):\n",
    "    return sum(p.numel() for p in model.parameters() if p.requires_grad)\n",
    "\n",
    "def initialize_weights(m):\n",
    "    if hasattr(m, \"weight\") and m.weight.dim() > 1:\n",
    "        nn.init.kaiming_uniform_(m.weight.data)\n",
    "\n",
    "def epoch_time(start_time, end_time):\n",
    "    elapsed_time = end_time - start_time\n",
    "    elapsed_mins = int(elapsed_time / 60)\n",
    "    elapsed_secs = int(elapsed_time - (elapsed_mins * 60))\n",
    "    return elapsed_mins, elapsed_secs\n",
    "\n",
    "def bleu_stats(hypothesis, reference):\n",
    "    \"\"\"Compute statistics for BLEU.\"\"\"\n",
    "    stats = []\n",
    "    stats.append(len(hypothesis))\n",
    "    stats.append(len(reference))\n",
    "    for n in range(1, 5):\n",
    "        s_ngrams = Counter([tuple(hypothesis[i : i + n]) for i in range(len(hypothesis) + 1 - n)])\n",
    "        r_ngrams = Counter([tuple(reference[i : i + n]) for i in range(len(reference) + 1 - n)])\n",
    "\n",
    "        stats.append(max([sum((s_ngrams & r_ngrams).values()), 0]))\n",
    "        stats.append(max([len(hypothesis) + 1 - n, 0]))\n",
    "    return stats\n",
    "\n",
    "\n",
    "def bleu(stats):\n",
    "    \"\"\"Compute BLEU given n-gram statistics.\"\"\"\n",
    "    if len(list(filter(lambda x: x == 0, stats))) > 0:\n",
    "        return 0\n",
    "    (c, r) = stats[:2]\n",
    "    log_bleu_prec = sum([math.log(float(x) / y) for x, y in zip(stats[2::2], stats[3::2])]) / 4.0\n",
    "    return math.exp(min([0, 1 - float(r) / c]) + log_bleu_prec)\n",
    "\n",
    "def get_bleu(hypotheses, reference):\n",
    "    \"\"\"Get validation BLEU score for dev set.\"\"\"\n",
    "    stats = np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0])\n",
    "    for hyp, ref in zip(hypotheses, reference):\n",
    "        stats += np.array(bleu_stats(hyp, ref))\n",
    "    return 100 * bleu(stats)\n",
    "\n",
    "def idx_to_word(x, vocab):\n",
    "    words = []\n",
    "    for i in x:\n",
    "        word = vocab.itos[i]\n",
    "        if \"<\" not in word:\n",
    "            words.append(word)\n",
    "    words = \" \".join(words)\n",
    "    return words"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model has 55,205,037 trainable parameters\n"
     ]
    }
   ],
   "source": [
    "## 初始化模型\n",
    "model = Transformer(\n",
    "    src_pad_idx=src_pad_idx,\n",
    "    trg_pad_idx=trg_pad_idx,\n",
    "    trg_sos_idx=trg_sos_idx,\n",
    "    d_model=d_model,\n",
    "    enc_voc_size=enc_voc_size,\n",
    "    dec_voc_size=dec_voc_size,\n",
    "    max_len=max_len,\n",
    "    ffn_hidden=ffn_hidden,\n",
    "    n_head=n_heads,\n",
    "    n_layers=n_layers,\n",
    "    drop_prob=drop_prob,\n",
    "    device=device,\n",
    ").to(device)\n",
    "model = model.apply(initialize_weights)\n",
    "print(f\"The model has {count_parameters(model):,} trainable parameters\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = Adam(params=model.parameters(), lr=init_lr, weight_decay=weight_decay, eps=adam_eps)\n",
    "\n",
    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, verbose=True, factor=factor, patience=patience)\n",
    "\n",
    "criterion = nn.CrossEntropyLoss(ignore_index=src_pad_idx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, iterator, optimizer, criterion, clip):\n",
    "    model.train()\n",
    "    epoch_loss = 0\n",
    "    for i, batch in (enumerate(iterator)):\n",
    "        src = batch.src\n",
    "        trg = batch.trg\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        output = model(src, trg[:, :-1])\n",
    "        output_reshape = output.contiguous().view(-1, output.shape[-1])\n",
    "        trg = trg[:, 1:].contiguous().view(-1)\n",
    "\n",
    "        loss = criterion(output_reshape, trg)\n",
    "        loss.backward()\n",
    "        torch.nn.utils.clip_grad_norm_(model.parameters(), clip)\n",
    "        optimizer.step()\n",
    "\n",
    "        epoch_loss += loss.item()\n",
    "        # print('step :', round((i / len(iterator)) * 100, 2), '% , loss :', loss.item())\n",
    "    return epoch_loss / len(iterator)\n",
    "\n",
    "def evaluate(model, iterator, criterion):\n",
    "    model.eval()\n",
    "    epoch_loss = 0\n",
    "    batch_bleu = []\n",
    "    with torch.no_grad():\n",
    "        for i, batch in enumerate(iterator):\n",
    "            src = batch.src\n",
    "            trg = batch.trg\n",
    "            output = model(src, trg[:, :-1])\n",
    "            output_reshape = output.contiguous().view(-1, output.shape[-1])\n",
    "            trg = trg[:, 1:].contiguous().view(-1)\n",
    "\n",
    "            loss = criterion(output_reshape, trg)\n",
    "            epoch_loss += loss.item()\n",
    "\n",
    "            total_bleu = []\n",
    "            for j in range(batch_size):\n",
    "                try:\n",
    "                    trg_words = idx_to_word(batch.trg[j], loader.target.vocab)\n",
    "                    output_words = output[j].max(dim=1)[1]\n",
    "                    output_words = idx_to_word(output_words, loader.target.vocab)\n",
    "                    bleu = get_bleu(hypotheses=output_words.split(), reference=trg_words.split())\n",
    "                    total_bleu.append(bleu)\n",
    "                except:\n",
    "                    pass\n",
    "                \n",
    "            total_bleu = sum(total_bleu) / len(total_bleu)\n",
    "            batch_bleu.append(total_bleu)\n",
    "\n",
    "    batch_bleu = sum(batch_bleu) / len(batch_bleu)\n",
    "    return epoch_loss / len(iterator), batch_bleu\n",
    "\n",
    "def run(total_epoch, best_loss):\n",
    "    train_losses, test_losses, bleus = [], [], []\n",
    "    for step in range(total_epoch):\n",
    "        start_time = time.time()\n",
    "        train_loss = train(model, train_iter, optimizer, criterion, clip)\n",
    "        valid_loss, bleu = evaluate(model, valid_iter, criterion)\n",
    "        end_time = time.time()\n",
    "\n",
    "        if step > warmup:\n",
    "            scheduler.step(valid_loss)\n",
    "\n",
    "        train_losses.append(train_loss)\n",
    "        test_losses.append(valid_loss)\n",
    "        bleus.append(bleu)\n",
    "        epoch_mins, epoch_secs = epoch_time(start_time, end_time)\n",
    "\n",
    "        if valid_loss < best_loss:\n",
    "            best_loss = valid_loss\n",
    "            torch.save(model.state_dict(), \"saved/model-{0}.pt\".format(valid_loss))\n",
    "\n",
    "        f = open(\"result/train_loss.txt\", \"w\")\n",
    "        f.write(str(train_losses))\n",
    "        f.close()\n",
    "\n",
    "        f = open(\"result/bleu.txt\", \"w\")\n",
    "        f.write(str(bleus))\n",
    "        f.close()\n",
    "\n",
    "        f = open(\"result/test_loss.txt\", \"w\")\n",
    "        f.write(str(test_losses))\n",
    "        f.close()\n",
    "\n",
    "        print(f\"Epoch: {step + 1} | Time: {epoch_mins}m {epoch_secs}s\")\n",
    "        print(f\"\\tTrain Loss: {train_loss:.3f} | Train PPL: {math.exp(train_loss):7.3f}\")\n",
    "        print(f\"\\tVal Loss: {valid_loss:.3f} |  Val PPL: {math.exp(valid_loss):7.3f}\")\n",
    "        print(f\"\\tBLEU Score: {bleu:.3f}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 | Time: 0m 24s\n",
      "\tTrain Loss: 6.775 | Train PPL: 875.629\n",
      "\tVal Loss: 5.964 |  Val PPL: 389.127\n",
      "\tBLEU Score: 0.000\n",
      "Epoch: 2 | Time: 0m 25s\n",
      "\tTrain Loss: 5.916 | Train PPL: 370.840\n",
      "\tVal Loss: 5.897 |  Val PPL: 363.963\n",
      "\tBLEU Score: 4.823\n",
      "Epoch: 3 | Time: 0m 25s\n",
      "\tTrain Loss: 5.539 | Train PPL: 254.403\n",
      "\tVal Loss: 5.486 |  Val PPL: 241.351\n",
      "\tBLEU Score: 10.490\n",
      "Epoch: 4 | Time: 0m 25s\n",
      "\tTrain Loss: 5.362 | Train PPL: 213.173\n",
      "\tVal Loss: 5.208 |  Val PPL: 182.773\n",
      "\tBLEU Score: 11.258\n",
      "Epoch: 5 | Time: 0m 25s\n",
      "\tTrain Loss: 5.260 | Train PPL: 192.536\n",
      "\tVal Loss: 5.170 |  Val PPL: 175.875\n",
      "\tBLEU Score: 11.205\n",
      "Epoch: 6 | Time: 0m 25s\n",
      "\tTrain Loss: 5.195 | Train PPL: 180.350\n",
      "\tVal Loss: 5.074 |  Val PPL: 159.870\n",
      "\tBLEU Score: 11.346\n",
      "Epoch: 7 | Time: 0m 25s\n",
      "\tTrain Loss: 5.153 | Train PPL: 172.905\n",
      "\tVal Loss: 5.052 |  Val PPL: 156.374\n",
      "\tBLEU Score: 10.876\n",
      "Epoch: 8 | Time: 0m 24s\n",
      "\tTrain Loss: 5.119 | Train PPL: 167.102\n",
      "\tVal Loss: 4.984 |  Val PPL: 146.020\n",
      "\tBLEU Score: 9.938\n",
      "Epoch: 9 | Time: 0m 25s\n",
      "\tTrain Loss: 5.069 | Train PPL: 159.058\n",
      "\tVal Loss: 4.826 |  Val PPL: 124.766\n",
      "\tBLEU Score: 9.954\n",
      "Epoch: 10 | Time: 0m 25s\n",
      "\tTrain Loss: 4.978 | Train PPL: 145.220\n",
      "\tVal Loss: 4.797 |  Val PPL: 121.102\n",
      "\tBLEU Score: 12.288\n"
     ]
    }
   ],
   "source": [
    "run(total_epoch=epoch, best_loss=inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## 画图\n",
    "def read(name):\n",
    "    f = open(name, 'r')\n",
    "    file = f.read()\n",
    "    file = re.sub('\\\\[', '', file)\n",
    "    file = re.sub('\\\\]', '', file)\n",
    "    f.close()\n",
    "    return [float(i) for idx, i in enumerate(file.split(','))]\n",
    "\n",
    "def draw(mode):\n",
    "    if mode == 'loss':\n",
    "        train = read('./result/train_loss.txt')\n",
    "        test = read('./result/test_loss.txt')\n",
    "        plt.plot(train, 'r', label='train')\n",
    "        plt.plot(test, 'b', label='validation')\n",
    "        plt.legend(loc='lower left')\n",
    "\n",
    "\n",
    "    elif mode == 'bleu':\n",
    "        bleu = read('./result/bleu.txt')\n",
    "        plt.plot(bleu, 'b', label='bleu score')\n",
    "        plt.legend(loc='lower right')\n",
    "\n",
    "    plt.xlabel('epoch')\n",
    "    plt.ylabel(mode)\n",
    "    plt.title('training result')\n",
    "    plt.grid(True, which='both', axis='both')\n",
    "    plt.show()\n",
    "draw(mode='loss')\n",
    "draw(mode='bleu')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "yyb_lowtorch",
   "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.8.0"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}