transformer翻译.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:07:46.504385600Z",
     "start_time": "2023-10-31T15:07:40.027404600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.10.0\n",
      "sys.version_info(major=3, minor=10, micro=5, releaselevel='final', serial=0)\n",
      "matplotlib 3.8.0\n",
      "numpy 1.24.1\n",
      "pandas 2.1.2\n",
      "sklearn 1.3.2\n",
      "tensorflow 2.10.0\n",
      "keras.api._v2.keras 2.10.0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow import keras\n",
    "\n",
    "print(tf.__version__)\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, tf, keras:\n",
    "    print(module.__name__, module.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. loads data\n",
    "2. preprocesses data -> dataset\n",
    "3. tools\n",
    "    - generates position embedding\n",
    "    - create mask. (a. padding, b. decoder)\n",
    "    - scaled_dot_product_attention\n",
    "4. builds model 分为以下6步\n",
    "    - MultiheadAttention\n",
    "    - EncoderLayer\n",
    "    - DecoderLayer\n",
    "    - EncoderModel\n",
    "    - DecoderModel\n",
    "    - Transformer\n",
    "5. optimizer & loss\n",
    "6. train step -> train\n",
    "7. Evaluate and Visualize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:07:51.251473100Z",
     "start_time": "2023-10-31T15:07:46.504385600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "tfds.core.DatasetInfo(\n",
      "    name='ted_hrlr_translate',\n",
      "    full_name='ted_hrlr_translate/pt_to_en/1.0.0',\n",
      "    description=\"\"\"\n",
      "    Data sets derived from TED talk transcripts for comparing similar language pairs\n",
      "    where one is high resource and the other is low resource.\n",
      "    \"\"\",\n",
      "    config_description=\"\"\"\n",
      "    Translation dataset from pt to en in plain text.\n",
      "    \"\"\",\n",
      "    homepage='https://github.com/neulab/word-embeddings-for-nmt',\n",
      "    data_path='C:\\\\Users\\\\83633\\\\tensorflow_datasets\\\\ted_hrlr_translate\\\\pt_to_en\\\\1.0.0',\n",
      "    file_format=tfrecord,\n",
      "    download_size=124.94 MiB,\n",
      "    dataset_size=Unknown size,\n",
      "    features=Translation({\n",
      "        'en': Text(shape=(), dtype=string),\n",
      "        'pt': Text(shape=(), dtype=string),\n",
      "    }),\n",
      "    supervised_keys=('pt', 'en'),\n",
      "    disable_shuffling=False,\n",
      "    splits={\n",
      "        'test': <SplitInfo num_examples=1803, num_shards=1>,\n",
      "        'train': <SplitInfo num_examples=51785, num_shards=1>,\n",
      "        'validation': <SplitInfo num_examples=1193, num_shards=1>,\n",
      "    },\n",
      "    citation=\"\"\"@inproceedings{Ye2018WordEmbeddings,\n",
      "      author  = {Ye, Qi and Devendra, Sachan and Matthieu, Felix and Sarguna, Padmanabhan and Graham, Neubig},\n",
      "      title   = {When and Why are pre-trained word embeddings useful for Neural Machine Translation},\n",
      "      booktitle = {HLT-NAACL},\n",
      "      year    = {2018},\n",
      "      }\"\"\",\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import tensorflow_datasets as tfds\n",
    "# 葡萄牙语Portugal -> 英语English，基于subword_level\n",
    "examples, info = tfds.load('ted_hrlr_translate/pt_to_en', with_info=True, as_supervised=True)\n",
    "\n",
    "print(type(examples)) # <class 'dict'>, 有train和validation两个key\n",
    "train_examples, val_examples = examples['train'], examples['validation']\n",
    "print(info) # 查看数据集信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:07:51.346744900Z",
     "start_time": "2023-10-31T15:07:51.240363400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'e quando melhoramos a procura , tiramos a \\xc3\\xbanica vantagem da impress\\xc3\\xa3o , que \\xc3\\xa9 a serendipidade .'\n",
      "b'and when you improve searchability , you actually take away the one advantage of print , which is serendipity .'\n",
      "<class 'tensorflow.python.framework.ops.EagerTensor'>\n",
      "<PrefetchDataset element_spec=(TensorSpec(shape=(), dtype=tf.string, name=None), TensorSpec(shape=(), dtype=tf.string, name=None))>\n"
     ]
    }
   ],
   "source": [
    "#葡萄牙语中有一些特除的字符，用转义字符来打印\n",
    "for pt, en in train_examples.take(1):\n",
    "    print(pt.numpy())\n",
    "    print(en.numpy())\n",
    "    print(type(pt))\n",
    "print(train_examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:08:43.152686400Z",
     "start_time": "2023-10-31T15:07:51.346744900Z"
    }
   },
   "outputs": [],
   "source": [
    "# 制作语料库，subword_level\n",
    "# tfds.deprecated.text.SubwordTextEncoder.build_from_corpus 在2.5之后已弃用，改为 maybe_build_from_corpus\n",
    "# 2.5之后使用 maybe_build_from_corpus\n",
    "pt_tokenizer = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(\n",
    "                                                        [pt.numpy() for pt, _ in train_examples],\n",
    "                                                        target_vocab_size=2**13)\n",
    "\n",
    "en_tokenizer = tfds.deprecated.text.SubwordTextEncoder.build_from_corpus(\n",
    "                                                        [en.numpy() for _, en in train_examples],\n",
    "                                                        target_vocab_size=2**13)\n",
    "\n",
    "                                                          "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:08:43.167286200Z",
     "start_time": "2023-10-31T15:08:43.152686400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokenized string is [7915, 1248, 7946, 7194, 13, 2799, 7877]\n",
      "The original string: Transformer is awesome.\n",
      "7915 --> \"T\"--> 1\n",
      "1248 --> \"ran\"--> 3\n",
      "7946 --> \"s\"--> 1\n",
      "7194 --> \"former \"--> 7\n",
      "13 --> \"is \"--> 3\n",
      "2799 --> \"awesome\"--> 7\n",
      "7877 --> \".\"--> 1\n"
     ]
    }
   ],
   "source": [
    "# 测试\n",
    "sample_string = \"Transformer is awesome.\"\n",
    "# string -> token\n",
    "tokenized_string = en_tokenizer.encode(sample_string)\n",
    "print ('Tokenized string is {}'.format(tokenized_string))\n",
    "# token -> string\n",
    "original_string = en_tokenizer.decode(tokenized_string)\n",
    "print ('The original string: {}'.format(original_string))\n",
    "\n",
    "assert original_string == sample_string,'原始字符串和编码解码后的字符串不一致'\n",
    "\n",
    "for token in tokenized_string:\n",
    "    print('{} --> \"{}\"--> {}'.format(token, en_tokenizer.decode([token]),len(en_tokenizer.decode([token]))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:08:43.230407200Z",
     "start_time": "2023-10-31T15:08:43.167286200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8087\n",
      "8214\n"
     ]
    }
   ],
   "source": [
    "print(en_tokenizer.vocab_size)\n",
    "print(pt_tokenizer.vocab_size)\n",
    "print(en_tokenizer.decode([0]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:08:43.246033100Z",
     "start_time": "2023-10-31T15:08:43.183708500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tensorflow.python.data.ops.dataset_ops.PrefetchDataset'>\n"
     ]
    }
   ],
   "source": [
    "print(type(train_examples))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:08:43.961415100Z",
     "start_time": "2023-10-31T15:08:43.204278300Z"
    }
   },
   "outputs": [],
   "source": [
    "buffer_size = 20000\n",
    "batch_size = 64\n",
    "max_length = 40\n",
    "\n",
    "#把两段文本转为subword形式，[pt_tokenizer.vocab_size]和[pt_tokenizer.vocab_size + 1]\n",
    "#分别代表一句话开始标记和结束标记，和seq2seq一致的 <start> 和 <end>\n",
    "def encode_to_subword(pt_sentence, en_sentence):\n",
    "    pt_sentence = [pt_tokenizer.vocab_size] + pt_tokenizer.encode(pt_sentence.numpy()) + [pt_tokenizer.vocab_size + 1]\n",
    "    en_sentence = [en_tokenizer.vocab_size] + en_tokenizer.encode(en_sentence.numpy()) + [en_tokenizer.vocab_size + 1]\n",
    "    return pt_sentence, en_sentence\n",
    "\n",
    "# 用tf的API消去大于最大长度的,只要葡萄牙语和英语同时小于等于40的样本\n",
    "def filter_by_max_length(pt, en):\n",
    "    return tf.math.logical_and(tf.size(pt) <= max_length, \n",
    "                          tf.size(en) <= max_length) # 逻辑与\n",
    "# 用py_function把python函数包装成tensorflow的操作\n",
    "def tf_encode_to_subword(pt_sentence, en_sentence):\n",
    "    return tf.py_function(encode_to_subword, \n",
    "                          [pt_sentence, en_sentence], \n",
    "                          [tf.int64, tf.int64])\n",
    "\n",
    "# 把句子转换成subword形式\n",
    "train_dataset = train_examples.map(tf_encode_to_subword)\n",
    "# max1=0\n",
    "# max2=0\n",
    "# for pi,ei in train_dataset:\n",
    "#   if len(pi)>max1:\n",
    "#     max1=len(pi)\n",
    "#   if len(ei)>max2:\n",
    "#     max2=len(ei)\n",
    "# print(max1,max2) 这部分代码是看最大长度的，pt最大长度是222，en最大长度是203\n",
    "# 为了提高训练效率，加快模型训练过程\n",
    "train_dataset = train_dataset.filter(filter_by_max_length)\n",
    "# 洗牌，分batch，在inp 与 out上分别取每个batch最大长度做为填充标准\n",
    "train_dataset = train_dataset.shuffle(buffer_size).padded_batch(batch_size, \n",
    "                                                                padded_shapes=([-1],[-1])) # 在最后一个维度上做填充\n",
    "\n",
    "#验证集只做了过滤和padding，没有洗牌\n",
    "valid_dataset = val_examples.map(tf_encode_to_subword)\n",
    "valid_dataset = valid_dataset.filter(filter_by_max_length).padded_batch(batch_size, \n",
    "                                                                        padded_shapes=([-1], [-1]))\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:08:57.629807400Z",
     "start_time": "2023-10-31T15:08:43.961415100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 39) (64, 38)\n",
      "(64, 37) (64, 40)\n",
      "(64, 39) (64, 39)\n",
      "(64, 39) (64, 40)\n",
      "(64, 40) (64, 38)\n"
     ]
    }
   ],
   "source": [
    "for pt_batch, en_batch in train_dataset.take(5):\n",
    "    print(pt_batch.shape, en_batch.shape) #填充到batch内的最大长度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:13.228289600Z",
     "start_time": "2023-10-31T15:08:57.629807400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[8214   21  551   57   45    5   16 1230  256 1255  112  850   20   10\n",
      "  186 7358  467   29 8215    0    0    0    0    0    0    0    0    0\n",
      "    0    0    0    0    0    0    0    0    0    0    0    0], shape=(40,), dtype=int64)\n",
      "tf.Tensor(\n",
      "[8087   61   30   14  485   57  434    8   74 3942   49 5209 7863   11\n",
      "   47  700  220   18  418    7  163 6336 7932   33 8088    0    0    0\n",
      "    0    0    0    0    0    0    0    0    0    0], shape=(38,), dtype=int64)\n"
     ]
    }
   ],
   "source": [
    "for pt_batch, en_batch in train_dataset.take(1):\n",
    "    print(pt_batch[0])\n",
    "    print(en_batch[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Position_Embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:13.321553600Z",
     "start_time": "2023-10-31T15:09:13.232282200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 50, 512)\n"
     ]
    }
   ],
   "source": [
    "# 写一些工具函数\n",
    "# PE(pos, 2i)   = sin(pos / 10000^(2i/d_model))\n",
    "# PE(pos, 2i+1) = cos(pos / 10000^(2i/d_model))\n",
    "\n",
    "# pos 和 i\n",
    "# pos.shape: (seq_len, 1)\n",
    "# i.shape: (1, d_model)\n",
    "# PE(pos, i).shape: (seq_len, d_model)\n",
    "\n",
    "# 计算 pos / 10000^(2i/d_model)\n",
    "def get_angles(pos, i, d_model):\n",
    "    angles = 1 / np.power(10000, (2 * (i // 2)) / np.float32(d_model))\n",
    "    return pos * angles\n",
    "# 计算位置信息,sentence_length长度是多少，就有多少个位置要变为位置编码\n",
    "def get_position_embedding(sentence_length, d_model):\n",
    "    \n",
    "    \n",
    "    angle_rads = get_angles(np.arange(sentence_length)[:, np.newaxis],\n",
    "                            np.arange(d_model)[np.newaxis, :],\n",
    "                            d_model)\n",
    "    # sines.shape: [seq_len, d_model / 2]\n",
    "    # cosines.shape: [seq_len, d_model / 2]\n",
    "    sines = np.sin(angle_rads[:, 0::2])\n",
    "    cosines = np.cos(angle_rads[:, 1::2])\n",
    "    # position_embedding.shape: [seq_len, d_model]\n",
    "    position_embedding = np.concatenate([sines, cosines], axis=-1)\n",
    "    # 进行维度扩展，把[seq_len, d_model]，变为[1, seq_len, d_model]\n",
    "    position_embedding = position_embedding[np.newaxis, ...]\n",
    "    # 变为float32类型 \n",
    "    return tf.cast(position_embedding, dtype=tf.float32)\n",
    "\n",
    "# 测试\n",
    "# pos是0到49，就是词的位置，i是从0到511，总计512，和dim相等,输出的angle_rads尺寸是（50,512）\n",
    "position_embedding = get_position_embedding(sentence_length=50, d_model=512)\n",
    "print(position_embedding.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:13.393453900Z",
     "start_time": "2023-10-31T15:09:13.246701300Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plt_position_embedding(position_embedding):\n",
    "    plt.pcolormesh(position_embedding[0,::-1,:], cmap='RdBu')\n",
    "    plt.xlabel('Depth')\n",
    "    plt.xlim((0, 512))\n",
    "    plt.ylabel('Position')\n",
    "    plt.colorbar()\n",
    "    plt.show()\n",
    "    \n",
    "plt_position_embedding(position_embedding.numpy())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 生成掩码mask\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:13.434675800Z",
     "start_time": "2023-10-31T15:09:13.386832500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<tf.Tensor: shape=(3, 1, 1, 5), dtype=float32, numpy=\narray([[[[0., 0., 1., 1., 1.]]],\n\n\n       [[[0., 0., 0., 1., 1.]]],\n\n\n       [[[0., 0., 1., 1., 1.]]]], dtype=float32)>"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1. padding mask, 2. look ahead mask\n",
    "\n",
    "def create_padding_mask(batch_data):\n",
    "    \"\"\"\n",
    "    :param batch_data: [batch_size, seq_len]\n",
    "    :return: [batch_size, 1, 1, seq_len]\n",
    "    \"\"\"\n",
    "    padding_mask = tf.cast(tf.math.equal(batch_data, 0), dtype=tf.float32)\n",
    "    return padding_mask[:, tf.newaxis, tf.newaxis, :]\n",
    "\n",
    "# 测试\n",
    "# 设置3x5矩阵，0都是padding，是零的得到的都是1，其他的都是零\n",
    "x = tf.constant([[7, 6, 0, 0, 0], [1, 2, 3, 0, 0], [4,5, 0, 0,0]])\n",
    "create_padding_mask(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:13.434675800Z",
     "start_time": "2023-10-31T15:09:13.423014300Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<tf.Tensor: shape=(5, 5), dtype=float32, numpy=\narray([[0., 1., 1., 1., 1.],\n       [0., 0., 1., 1., 1.],\n       [0., 0., 0., 1., 1.],\n       [0., 0., 0., 0., 1.],\n       [0., 0., 0., 0., 0.]], dtype=float32)>"
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# attention_weights.shape: [3,3]\n",
    "# 第一个位置代表第一个单词和自己的attention，第二位置是第二个单词和第一个单词的attention\n",
    "# 看不到后面的词刚好是下三角，使用库函数来实现\n",
    "# [[1, 0, 0],\n",
    "#  [4, 5, 0],\n",
    "#  [7, 8, 9]]\n",
    "def create_look_ahead_mask(size):\n",
    "    mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)\n",
    "    return mask # (seq_len, seq_len)\n",
    "\n",
    "# 前面看不到后面的padding，矩阵下面全部为0\n",
    "# 在mask里，应该被忽略的我们会设成1，应该被保留的会设成0，\n",
    "# 而如果mask相应位置上为1，那么我们就给对应的logits \n",
    "# 加上一个超级小的负数， -1000000000， 这样对应的logits也就变成了一个超级小的数。\n",
    "# 然后在计算softmax的时候，一个超级小的数的指数会无限接近与0。也就是它对应的attention的权重就是0了,\n",
    "# 下面可以看到\n",
    "create_look_ahead_mask(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 缩放点积注意力"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:13.451356900Z",
     "start_time": "2023-10-31T15:09:13.434675800Z"
    }
   },
   "outputs": [],
   "source": [
    "# 参考原理文档，q是query，k，v代表k和value，q和k做完矩阵乘法后，做mask\n",
    "# 缩放点积注意力，也叫自注意力\n",
    "\n",
    "def scaled_dot_product_attention(q, k, v, mask):\n",
    "    \"\"\"\n",
    "    Args:\n",
    "    - q: shape == (..., seq_len_q, depth)\n",
    "    - k: shape == (..., seq_len_k, depth)\n",
    "    - v: shape == (..., seq_len_v, depth_v)\n",
    "    - seq_len_k == seq_len_v  这两个是相等的\n",
    "    - mask: shape == (..., seq_len_q, seq_len_k)\n",
    "    Returns:\n",
    "    - output: weighted sum\n",
    "    - attention_weights: weights of attention\n",
    "    \"\"\"\n",
    "    # 计算attentions时，我们只用了后两维在计算\n",
    "    # transpose_b代表第二个矩阵是否做转置\n",
    "    # matmul_qk.shape: (..., seq_len_q, seq_len_k)\n",
    "    matmul_qk = tf.matmul(q, k, transpose_b = True)\n",
    "    \n",
    "    # 获得dk，dk是k最后一维的维度\n",
    "    dk = tf.cast(tf.shape(k)[-1], tf.float32)\n",
    "    # 根据文档公式，除以根号dk，维度为 （..., seq_len_q, seq_len_k）\n",
    "    scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n",
    "    \n",
    "    # 将mask加入到scaled_attention_logits \n",
    "    if mask is not None:\n",
    "        # 加了很大的负数，使得softmax后，mask的位置的值趋近于0\n",
    "        scaled_attention_logits += (mask * -1e9)\n",
    "        \n",
    "    # softmax在最后一个轴（seq_len_k）上归一化，因此分数相加等于1\n",
    "    # attention_weights.shape: (..., seq_len_q, seq_len_k)\n",
    "    attention_weights = tf.nn.softmax(scaled_attention_logits, axis = -1)\n",
    "    \n",
    "    # output.shape: (..., seq_len_q, depth_v)\n",
    "    output = tf.matmul(attention_weights, v)\n",
    "    \n",
    "    return output, attention_weights\n",
    "\n",
    "# 测试\n",
    "def print_scaled_dot_product_attention(q, k, v):\n",
    "    temp_out, temp_att = scaled_dot_product_attention(q, k, v, None)\n",
    "    print(\"Attention weights are:\")\n",
    "    print(temp_att)\n",
    "    print(\"Output is:\")\n",
    "    print(temp_out)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.569367900Z",
     "start_time": "2023-10-31T15:09:13.451356900Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention weights are:\n",
      "tf.Tensor([[8.433274e-26 1.000000e+00 8.433274e-26 8.433274e-26]], shape=(1, 4), dtype=float32)\n",
      "Output is:\n",
      "tf.Tensor([[1.00000e+01 9.27448e-25]], shape=(1, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# 我们定义一个测试的Q，K，V\n",
    "temp_k = tf.constant([[10, 0, 0],\n",
    "                      [0, 10, 0],\n",
    "                      [0, 0, 10],\n",
    "                      [0, 0, 10]], dtype=tf.float32) # (4, 3)\n",
    "\n",
    "temp_v = tf.constant([[1, 0],\n",
    "                      [10, 0],\n",
    "                      [100, 5],\n",
    "                      [1000, 6]], dtype=tf.float32) # (4, 2)\n",
    "\n",
    "temp_q1 = tf.constant([[0, 10, 0]], dtype=tf.float32) # (1, 3)\n",
    "\n",
    "print_scaled_dot_product_attention(temp_q1, temp_k, temp_v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.588454800Z",
     "start_time": "2023-10-31T15:09:14.572813Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention weights are:\n",
      "tf.Tensor([[0.  0.  0.5 0.5]], shape=(1, 4), dtype=float32)\n",
      "Output is:\n",
      "tf.Tensor([[550.    5.5]], shape=(1, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# 下面的作用是做四舍五入，让结果清爽\n",
    "np.set_printoptions(suppress=True)\n",
    "temp_q2 = tf.constant([[0, 0, 10]], dtype=tf.float32) # (1, 3)\n",
    "#0.  0.  0.5 0.5 会和temp_v去做平均，因此得到的是550,5.5\n",
    "print_scaled_dot_product_attention(temp_q2, temp_k, temp_v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.650944700Z",
     "start_time": "2023-10-31T15:09:14.588454800Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention weights are:\n",
      "tf.Tensor([[0.5 0.5 0.  0. ]], shape=(1, 4), dtype=float32)\n",
      "Output is:\n",
      "tf.Tensor([[5.5 0. ]], shape=(1, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "temp_q3 = tf.constant([[10, 10, 0]], dtype=tf.float32) # (1, 3)\n",
    "print_scaled_dot_product_attention(temp_q3, temp_k, temp_v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.666568900Z",
     "start_time": "2023-10-31T15:09:14.604078400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Attention weights are:\n",
      "tf.Tensor(\n",
      "[[0.         1.         0.         0.        ]\n",
      " [0.         0.         0.5        0.5       ]\n",
      " [0.5        0.5        0.         0.        ]\n",
      " [0.33333334 0.         0.33333334 0.33333334]], shape=(4, 4), dtype=float32)\n",
      "Output is:\n",
      "tf.Tensor(\n",
      "[[ 10.          0.       ]\n",
      " [550.          5.5      ]\n",
      " [  5.5         0.       ]\n",
      " [366.9104      3.6657715]], shape=(4, 2), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "# 拼起来再来测试\n",
    "temp_q4 = tf.constant([[0, 10, 0],\n",
    "                       [0, 0, 10],\n",
    "                       [10, 10, 0],\n",
    "                       [10,0,10]], dtype=tf.float32) # (3, 3)\n",
    "print_scaled_dot_product_attention(temp_q4, temp_k, temp_v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 多头注意力"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.744687200Z",
     "start_time": "2023-10-31T15:09:14.619702500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 40, 512)\n",
      "(1, 8, 40, 40)\n"
     ]
    }
   ],
   "source": [
    "# 多头注意力的实现\n",
    "class MultiHeadAttention(keras.layers.Layer):\n",
    "    \"\"\"\n",
    "    理论上:\n",
    "    x -> Wq0 -> q0\n",
    "    x -> Wk0 -> k0\n",
    "    x -> Wv0 -> v0\n",
    "    \n",
    "    实战中:把三个概念区分开\n",
    "    q -> Wq0 -> q0\n",
    "    k -> Wk0 -> k0\n",
    "    v -> Wv0 -> v0\n",
    "    \n",
    "    实战中技巧：q乘以W得到一个大的Q，然后分割为多个小q，拿每一个小q去做缩放点积\n",
    "    q -> Wq -> Q -> split -> q0, q1, q2...\n",
    "    \"\"\"\n",
    "    def __init__(self, d_model, num_heads):\n",
    "        super(MultiHeadAttention, self).__init__()\n",
    "        self.num_heads = num_heads  #分成几份,几头\n",
    "        self.d_model = d_model\n",
    "        assert self.d_model % self.num_heads == 0\n",
    "        \n",
    "        # 这里对应的大Q变小q怎么变，层次， self.depth代表每份的大小\n",
    "        self.depth = self.d_model // self.num_heads\n",
    "        # 神经元个数是512\n",
    "        self.WQ = keras.layers.Dense(self.d_model)\n",
    "        self.WK = keras.layers.Dense(self.d_model)\n",
    "        self.WV = keras.layers.Dense(self.d_model)\n",
    "        # 这里是拼接，拼接的输出是512，拼接后还要经过一个全连接层\n",
    "        self.dense = keras.layers.Dense(self.d_model)\n",
    "    \n",
    "    def split_heads(self, x, batch_size):\n",
    "        # x.shape: (batch_size, seq_len, d_model)\n",
    "        # d_model = num_heads * depth\n",
    "        #把x变为下面维度，用reshape\n",
    "        #x--> (64,40,512)  (64,40,8,64) (batch_size, seq_len, num_heads, depth)\n",
    "        x = tf.reshape(x,\n",
    "                       (batch_size, -1, self.num_heads, self.depth))\n",
    "        # 轴滚动后 x -> (batch_size, num_heads, seq_len, depth)\n",
    "        return tf.transpose(x, perm=[0, 2, 1, 3])#轴滚动  (64,8,40,64)\n",
    "    \n",
    "    \n",
    "    def call(self, q, k, v, mask):\n",
    "        batch_size = tf.shape(q)[0] #形状的第0维就是batch_size\n",
    "        #经过Q K V变化\n",
    "        # print(q.shape)\n",
    "        q = self.WQ(q) # q.shape: (batch_size, seq_len_q, d_model)\n",
    "        k = self.WK(k) # k.shape: (batch_size, seq_len_k, d_model)\n",
    "        v = self.WV(v) # v.shape: (batch_size, seq_len_v, d_model)\n",
    "        # print('-'*50)\n",
    "        # print(q.shape)  (64,8,40,64)\n",
    "        # q.shape: (batch_size, num_heads, seq_len_q, depth)\n",
    "        q = self.split_heads(q, batch_size)\n",
    "        # k.shape: (batch_size, num_heads, seq_len_k, depth)\n",
    "        k = self.split_heads(k, batch_size)\n",
    "        # v.shape: (batch_size, num_heads, seq_len_v, depth)\n",
    "        v = self.split_heads(v, batch_size)\n",
    "    \n",
    "        # 开始做缩放点积，得到的多头的信息存在在num_heads，depth上  (64,8,40,64)\n",
    "        # scaled_attention_outputs.shape: (batch_size, num_heads, seq_len_q, depth)\n",
    "        # attention_weights.shape: (batch_size, num_heads, seq_len_q, seq_len_k)\n",
    "        scaled_attention_outputs, attention_weights = scaled_dot_product_attention(q, k, v, mask)\n",
    "        \n",
    "        # 这里做一下转置，让num_heads，depth在后面，为了还原成原来的形状\n",
    "        # 在transpose之前，维度是(batch_size, num_heads, seq_len_v, depth)\n",
    "        # scaled_attention_outputs.shape: (batch_size, seq_len_v, num_heads, depth)\n",
    "        scaled_attention_outputs = tf.transpose(\n",
    "            scaled_attention_outputs, perm = [0, 2, 1, 3])\n",
    "        \n",
    "        # 对计算出的8个缩放点积注意力进行合并\n",
    "        # concat_attention.shape: (batch_size, seq_len_v, d_model)\n",
    "        concat_attention = tf.reshape(scaled_attention_outputs,\n",
    "                                      (batch_size, -1, self.d_model))\n",
    "        \n",
    "        #多头注意力计算完毕\n",
    "        # output.shape : (batch_size, seq_len_v, d_model)\n",
    "        output = self.dense(concat_attention)\n",
    "        \n",
    "        return output, attention_weights\n",
    "\n",
    "temp_mha = MultiHeadAttention(d_model=512, num_heads=8)\n",
    "       \n",
    "# 测试多头注意力\n",
    "#创建一份虚拟数据\n",
    "x = tf.random.uniform((1, 40, 256)) # (batch_size, seq_len_q, dim)\n",
    "#开始计算，把y既当q，又当k，v\n",
    "output, attn = temp_mha(x, x, x, mask = None)\n",
    "print(output.shape)  #输出的尺寸，和x的尺寸一致\n",
    "print(attn.shape)   #注意力的尺寸"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 前馈网络"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.760317800Z",
     "start_time": "2023-10-31T15:09:14.682194900Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "TensorShape([64, 50, 512])"
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#定义我们的feed_forward_network，d_model节点数\n",
    "def feed_forward_network(d_model, dff):\n",
    "    # dff: dim of feed forward network.\n",
    "    return keras.Sequential([\n",
    "        keras.layers.Dense(dff, activation='relu'),\n",
    "        keras.layers.Dense(d_model)\n",
    "    ])\n",
    "\n",
    "sample_ffn = feed_forward_network(512, 2048)\n",
    "# 给一个输入测试\n",
    "sample_ffn(tf.random.uniform((64, 50, 512))).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encoder 层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:09:14.870314800Z",
     "start_time": "2023-10-31T15:09:14.744687200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 50, 512)\n"
     ]
    }
   ],
   "source": [
    "class EncoderLayer(keras.layers.Layer):\n",
    "    \"\"\"\n",
    "    x -> self attention -> add & normalize & dropout\n",
    "      -> feed_forward -> add & normalize & dropout\n",
    "    原理对应文档Add & Normalize 标题下的图\n",
    "    \"\"\"\n",
    "    # d_model 给self attention和feed_forward_network，num_heads给self_attention用的\n",
    "    # dff给feed_forward_network，rate是做dropout的\n",
    "    def __init__(self, d_model, num_heads, dff, rate=0.1):\n",
    "        super(EncoderLayer, self).__init__()\n",
    "        self.mha = MultiHeadAttention(d_model, num_heads)\n",
    "        self.ffn = feed_forward_network(d_model, dff)\n",
    "        \n",
    "        self.layer_norm1 = keras.layers.LayerNormalization(\n",
    "            epsilon = 1e-6)\n",
    "        # epsilon 将epsilon加上方差以避免 除零问题\n",
    "        self.layer_norm2 = keras.layers.LayerNormalization(\n",
    "            epsilon = 1e-6)\n",
    "        #下面两个层次用了做dropout，每次有10%的几率被drop掉\n",
    "        self.dropout1 = keras.layers.Dropout(rate)\n",
    "        self.dropout2 = keras.layers.Dropout(rate)\n",
    "        \n",
    "    def call(self, x, training, encoder_padding_mask):\n",
    "        # x.shape          : (batch_size, seq_len, dim=d_model)\n",
    "        # attn_output.shape: (batch_size, seq_len, d_model)\n",
    "        # out1.shape       : (batch_size, seq_len, d_model)\n",
    "        #x作为q，k，v  原理对应文档Add & Normalize 标题下的图\n",
    "        attn_output, _ = self.mha(x, x, x, encoder_padding_mask)\n",
    "        attn_output = self.dropout1(attn_output, training=training) #预测时这里为False，预测时没有这层\n",
    "        #dim=d_model 两个必须相等，这样x才可以和attn_output做加法\n",
    "        out1 = self.layer_norm1(x + attn_output)\n",
    "        \n",
    "        # ffn_output.shape: (batch_size, seq_len, d_model)\n",
    "        # out2.shape      : (batch_size, seq_len, d_model)\n",
    "        ffn_output = self.ffn(out1)\n",
    "        ffn_output = self.dropout2(ffn_output, training=training)#预测时这里为False，预测时没有这层\n",
    "        out2 = self.layer_norm2(out1 + ffn_output)\n",
    "        \n",
    "        return out2\n",
    "    \n",
    "# 测试\n",
    "sample_encoder_layer = EncoderLayer(512, 8, 2048)\n",
    "sample_input = tf.random.uniform((64, 50, 512))  #因为做了残差连接，所以x的形状必须和mha输出形状一致\n",
    "sample_output = sample_encoder_layer(sample_input, False, None)\n",
    "print(sample_output.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:03:58.287359500Z",
     "start_time": "2023-10-31T15:03:58.240476600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(\n",
      "[[ 0.  5. 15. 10.  5.]\n",
      " [ 0. 20. 15. 10. 15.]], shape=(2, 5), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "data = tf.constant(np.random.randint(0,5,(2,5)) * 5, dtype=tf.float32)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2023-10-31T15:03:58.256096500Z"
    }
   },
   "outputs": [],
   "source": [
    "layer = tf.keras.layers.LayerNormalization()\n",
    "output = layer(data)\n",
    "print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = np.mean(data, axis=1)\n",
    "s = np.std(data, axis=1)\n",
    "print(m, s)\n",
    "res = (data - m[:, np.newaxis]) / s[:, np.newaxis]\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_encoder_layer.variables\n",
    "sample_encoder_layer.trainable_variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decoder 层"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:00.736524700Z",
     "start_time": "2023-10-31T15:10:00.421940200Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 60, 512)\n",
      "(64, 8, 60, 60)\n",
      "(64, 8, 60, 50)\n"
     ]
    }
   ],
   "source": [
    "class DecoderLayer(keras.layers.Layer):\n",
    "    \"\"\"\n",
    "    x -> self attention -> add & normalize & dropout -> out1\n",
    "    out1 , encoding_outputs -> attention -> add & normalize & dropout -> out2\n",
    "    out2 -> ffn -> add & normalize & dropout -> out3\n",
    "    \"\"\"\n",
    "    def __init__(self, d_model, num_heads, dff, rate = 0.1):\n",
    "        super(DecoderLayer, self).__init__()\n",
    "        \n",
    "        self.mha1 = MultiHeadAttention(d_model, num_heads)\n",
    "        self.mha2 = MultiHeadAttention(d_model, num_heads)\n",
    "        \n",
    "        self.ffn = feed_forward_network(d_model, dff)\n",
    "        #因为有两个attention，还有一个feed_forward_network，所以有3个\n",
    "        #LayerNormalization和3个dropout\n",
    "        self.layer_norm1 = keras.layers.LayerNormalization(\n",
    "            epsilon = 1e-6)\n",
    "        self.layer_norm2 = keras.layers.LayerNormalization(\n",
    "            epsilon = 1e-6)\n",
    "        self.layer_norm3 = keras.layers.LayerNormalization(\n",
    "            epsilon = 1e-6)\n",
    "        \n",
    "        self.dropout1 = keras.layers.Dropout(rate)\n",
    "        self.dropout2 = keras.layers.Dropout(rate)\n",
    "        self.dropout3 = keras.layers.Dropout(rate)\n",
    "        \n",
    "    def call(self, x, encoding_outputs, training,\n",
    "             decoder_mask, encoder_decoder_padding_mask):\n",
    "        # decoder_mask: 由look_ahead_mask和decoder_padding_mask合并而来\n",
    "        \n",
    "        # x.shape: (batch_size, target_seq_len, d_model)\n",
    "        # encoding_outputs.shape: (batch_size, input_seq_len, d_model)\n",
    "        \n",
    "        #按照上面类的注释的步骤依次来编写call实现\n",
    "        # attn1, out1.shape : (batch_size, target_seq_len, d_model)\n",
    "        attn1, attn_weights1 = self.mha1(x, x, x, decoder_mask)\n",
    "        attn1 = self.dropout1(attn1, training = training)\n",
    "        out1 = self.layer_norm1(attn1 + x)\n",
    "        \n",
    "        # attn2, out2.shape : (batch_size, target_seq_len, d_model)\n",
    "        attn2, attn_weights2 = self.mha2(\n",
    "            out1, encoding_outputs, encoding_outputs,\n",
    "            encoder_decoder_padding_mask)\n",
    "        attn2 = self.dropout2(attn2, training = training) #qttn2和out1尺寸一致，和q的尺寸一致\n",
    "        out2 = self.layer_norm2(attn2 + out1)  \n",
    "        \n",
    "        # ffn_output, out3.shape: (batch_size, target_seq_len, d_model)\n",
    "        ffn_output = self.ffn(out2)\n",
    "        ffn_output = self.dropout3(ffn_output, training=training)\n",
    "        out3 = self.layer_norm3(ffn_output + out2)\n",
    "        \n",
    "        return out3, attn_weights1, attn_weights2\n",
    "    \n",
    "# 测试\n",
    "sample_decoder_layer = DecoderLayer(512, 8, 2048)\n",
    "sample_decoder_input = tf.random.uniform((64, 60, 512))\n",
    "sample_decoder_output, sample_decoder_attn_weights1, sample_decoder_attn_weights2 = sample_decoder_layer(\n",
    "    sample_decoder_input, sample_output, False, None, None)\n",
    "\n",
    "print(sample_decoder_output.shape)\n",
    "print(sample_decoder_attn_weights1.shape)  #最后一维60是和x的维度一致的\n",
    "print(sample_decoder_attn_weights2.shape) #最后一维60是和x的维度相关的"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EncoderModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:00.736524700Z",
     "start_time": "2023-10-31T15:10:00.535345600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 37, 512)\n"
     ]
    }
   ],
   "source": [
    "class EncoderModel(keras.layers.Layer):\n",
    "    def __init__(self, num_layers, input_vocab_size, max_length,\n",
    "                 d_model, num_heads, dff, rate=0.1):\n",
    "        super(EncoderModel, self).__init__()\n",
    "        self.d_model = d_model\n",
    "        # 这是layers数目\n",
    "        self.num_layers = num_layers\n",
    "        self.max_length = max_length\n",
    "        \n",
    "        # 构建embedding层\n",
    "        self.embedding = keras.layers.Embedding(input_vocab_size,\n",
    "                                                self.d_model)\n",
    "        # position_embedding.shape: (1, max_length, d_model)\n",
    "        self.position_embedding = get_position_embedding(max_length,\n",
    "                                                         self.d_model)\n",
    "        \n",
    "        self.dropout = keras.layers.Dropout(rate)\n",
    "        self.encoder_layers = [\n",
    "            EncoderLayer(d_model, num_heads, dff, rate)\n",
    "            for _ in range(self.num_layers)]\n",
    "        \n",
    "    \n",
    "    def call(self, x, training, encoder_padding_mask):\n",
    "        # x.shape: (batch_size, input_seq_len)\n",
    "        input_seq_len = tf.shape(x)[1]\n",
    "        tf.debugging.assert_less_equal(\n",
    "            input_seq_len, self.max_length,\n",
    "            \"input_seq_len should be less or equal to self.max_length\")\n",
    "        \n",
    "        # x.shape: (batch_size, input_seq_len, d_model)\n",
    "        x = self.embedding(x)\n",
    "        #x做缩放，是值在0到d_model之间\n",
    "        # 这个缩放的目的是为了防止在自注意力计算中出现梯度消失或梯度爆炸的问题\n",
    "        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
    "        # 因为x长度比position_embedding可能要小，因此embedding切片后和x相加\n",
    "        # position_embedding的轴0的size是1，在x的轴零维度广播相加\n",
    "        x += self.position_embedding[:, :input_seq_len, :]\n",
    "        \n",
    "        x = self.dropout(x, training = training) #在进入encoderLayer之前进行dropout，防止过拟合\n",
    "        \n",
    "        #得到的x不断作为下一层的输入\n",
    "        for i in range(self.num_layers):\n",
    "            x = self.encoder_layers[i](x, training,\n",
    "                                       encoder_padding_mask)\n",
    "        # x最终shape如下\n",
    "        # x.shape: (batch_size, input_seq_len, d_model)\n",
    "        return x\n",
    "    \n",
    "# 测试\n",
    "sample_encoder_model = EncoderModel(2, 8500, max_length,\n",
    "                                    512, 8, 2048)\n",
    "sample_encoder_model_input = tf.random.uniform((64, 37))\n",
    "sample_encoder_model_output = sample_encoder_model(\n",
    "    sample_encoder_model_input, False, encoder_padding_mask = None)\n",
    "print(sample_encoder_model_output.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DecoderModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:00.909898100Z",
     "start_time": "2023-10-31T15:10:00.736524700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 35, 512)\n"
     ]
    }
   ],
   "source": [
    "class DecoderModel(keras.layers.Layer):\n",
    "    def __init__(self, num_layers, target_vocab_size, max_length,\n",
    "                 d_model, num_heads, dff, rate=0.1):\n",
    "        super(DecoderModel, self).__init__()\n",
    "        self.num_layers = num_layers #有多少个decoder Layer\n",
    "        self.max_length = max_length\n",
    "        self.d_model = d_model\n",
    "        \n",
    "        self.embedding = keras.layers.Embedding(target_vocab_size,\n",
    "                                                d_model)\n",
    "        self.position_embedding = get_position_embedding(max_length,\n",
    "                                                         d_model)\n",
    "        \n",
    "        self.dropout = keras.layers.Dropout(rate)\n",
    "        self.decoder_layers = [\n",
    "            DecoderLayer(d_model, num_heads, dff, rate)\n",
    "            for _ in range(self.num_layers)]\n",
    "        \n",
    "    def call(self, x, encoding_outputs, training,\n",
    "             decoder_mask, encoder_decoder_padding_mask):\n",
    "        # x.shape: (batch_size, output_seq_len)\n",
    "        output_seq_len = tf.shape(x)[1]\n",
    "        # 如果要输出的商都超出了max_length，就报错\n",
    "        tf.debugging.assert_less_equal(\n",
    "            output_seq_len, self.max_length,\n",
    "            \"output_seq_len should be less or equal to self.max_length\")\n",
    "        \n",
    "        #a ttention_weights都是由decoder layer返回，把它保存下来\n",
    "        attention_weights = {}\n",
    "        \n",
    "        # x.shape: (batch_size, output_seq_len, d_model)\n",
    "        x = self.embedding(x)\n",
    "        #缩放\n",
    "        x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n",
    "        x += self.position_embedding[:, :output_seq_len, :]\n",
    "        \n",
    "        x = self.dropout(x, training = training)\n",
    "        \n",
    "        for i in range(self.num_layers):\n",
    "            # attn1,attn2分别是两个attention\n",
    "            x, attn1, attn2 = self.decoder_layers[i](\n",
    "                x, encoding_outputs, training,\n",
    "                decoder_mask, encoder_decoder_padding_mask)\n",
    "            attention_weights[\n",
    "                'decoder_layer{}_att1'.format(i+1)] = attn1\n",
    "            attention_weights[\n",
    "                'decoder_layer{}_att2'.format(i+1)] = attn2\n",
    "        # x.shape: (batch_size, output_seq_len, d_model),attention_weights是为了画图\n",
    "        return x, attention_weights\n",
    "\n",
    " \n",
    "sample_decoder_model = DecoderModel(2, 8000, max_length,\n",
    "                                    512, 8, 2048)  \n",
    "  \n",
    " # 测试\n",
    "sample_decoder_model_input = tf.random.uniform((64, 35))\n",
    "sample_decoder_model_output, sample_decoder_model_att = sample_decoder_model(\n",
    "    sample_decoder_model_input,\n",
    "    sample_encoder_model_output,#注意这里是encoder的output\n",
    "    training = False, decoder_mask = None,\n",
    "    encoder_decoder_padding_mask = None)\n",
    "\n",
    "print(sample_decoder_model_output.shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:01.433925800Z",
     "start_time": "2023-10-31T15:10:00.919430100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 31, 8089)\n",
      "--------------------------------------------------\n",
      "decoder_layer1_att1 (64, 8, 31, 31)\n",
      "decoder_layer1_att2 (64, 8, 31, 26)\n",
      "decoder_layer2_att1 (64, 8, 31, 31)\n",
      "decoder_layer2_att2 (64, 8, 31, 26)\n",
      "decoder_layer3_att1 (64, 8, 31, 31)\n",
      "decoder_layer3_att2 (64, 8, 31, 26)\n",
      "decoder_layer4_att1 (64, 8, 31, 31)\n",
      "decoder_layer4_att2 (64, 8, 31, 26)\n",
      "--------------------------------------------------\n",
      "Model: \"transformer\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " encoder_model_1 (EncoderMod  multiple                 1844736   \n",
      " el)                                                             \n",
      "                                                                 \n",
      " decoder_model_1 (DecoderMod  multiple                 2093696   \n",
      " el)                                                             \n",
      "                                                                 \n",
      " dense_128 (Dense)           multiple                  1043481   \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 4,981,913\n",
      "Trainable params: 4,981,913\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "class Transformer(keras.Model):\n",
    "    def __init__(self, num_layers, input_vocab_size, target_vocab_size,\n",
    "                 max_length, d_model, num_heads, dff, rate=0.1):\n",
    "        super(Transformer, self).__init__()\n",
    "        \n",
    "        self.encoder_model = EncoderModel(\n",
    "            num_layers, input_vocab_size, max_length,\n",
    "            d_model, num_heads, dff, rate)\n",
    "        \n",
    "        self.decoder_model = DecoderModel(\n",
    "            num_layers, target_vocab_size, max_length,\n",
    "            d_model, num_heads, dff, rate)\n",
    "        \n",
    "        self.final_layer = keras.layers.Dense(target_vocab_size)\n",
    "    \n",
    "    def call(self, inp, tar, training, encoder_padding_mask,\n",
    "             decoder_mask, encoder_decoder_padding_mask):\n",
    "        # encoding_outputs.shape: (batch_size, input_seq_len, d_model)\n",
    "        encoding_outputs = self.encoder_model(\n",
    "            inp, training, encoder_padding_mask)\n",
    "        \n",
    "        # decoding_outputs.shape: (batch_size, output_seq_len, d_model)\n",
    "        decoding_outputs, attention_weights = self.decoder_model(\n",
    "            tar, encoding_outputs, training,\n",
    "            decoder_mask, encoder_decoder_padding_mask)\n",
    "        \n",
    "        # predictions.shape: (batch_size, output_seq_len, target_vocab_size)\n",
    "        predictions = self.final_layer(decoding_outputs)\n",
    "        \n",
    "        return predictions, attention_weights\n",
    "    \n",
    "\n",
    "# 测试\n",
    "sample_transformer = Transformer(4, pt_tokenizer.vocab_size + 2, en_tokenizer.vocab_size + 2, max_length,\n",
    "                                 128, 8, 512, rate = 0.1)\n",
    "temp_input = tf.random.uniform((64, 26))\n",
    "temp_target = tf.random.uniform((64, 31))\n",
    "\n",
    "# 得到输出\n",
    "predictions, attention_weights = sample_transformer(\n",
    "    temp_input, temp_target, training = False,\n",
    "    encoder_padding_mask = None,\n",
    "    decoder_mask = None,\n",
    "    encoder_decoder_padding_mask = None)\n",
    "# 输出shape\n",
    "print(predictions.shape)\n",
    "print('-'*50)\n",
    "# attention_weights 的shape打印，为了后面画图做铺垫\n",
    "for key in attention_weights:\n",
    "    print(key, attention_weights[key].shape)\n",
    "print('-'*50)\n",
    "sample_transformer.summary()        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:01.530827Z",
     "start_time": "2023-10-31T15:10:01.433925800Z"
    }
   },
   "outputs": [],
   "source": [
    "#超参数\n",
    "num_layers = 4\n",
    "d_model = 128\n",
    "dff = 512\n",
    "num_heads = 8\n",
    "#加2是因为最后两个位置是start和end\n",
    "input_vocab_size = pt_tokenizer.vocab_size + 2\n",
    "target_vocab_size = en_tokenizer.vocab_size + 2\n",
    "\n",
    "dropout_rate = 0.1\n",
    "\n",
    "transformer = Transformer(num_layers,\n",
    "                          input_vocab_size,\n",
    "                          target_vocab_size,\n",
    "                          max_length,\n",
    "                          d_model, num_heads, dff, dropout_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 学习率变化，warm up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:01.532631Z",
     "start_time": "2023-10-31T15:10:01.499389600Z"
    }
   },
   "outputs": [],
   "source": [
    "# 学习率变化，是先增后减，因为前期可以快点，后期模型比较好，就要慢点\n",
    "# lrate = (d_model ** -0.5) * min(step_num ** (-0.5),\n",
    "#                                 step_num * warm_up_steps **(-1.5))\n",
    "# 自定义的学习率调整设计实现\n",
    "# 这里的公式看这里 https://tensorflow.google.cn/tutorials/text/transformer\n",
    "class CustomizedSchedule(\n",
    "    keras.optimizers.schedules.LearningRateSchedule):\n",
    "    def __init__(self, d_model, warmup_steps = 4000):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.d_model = tf.cast(d_model, tf.float32)\n",
    "        self.warmup_steps = warmup_steps\n",
    "    \n",
    "    def __call__(self, step):\n",
    "        step=tf.cast(step, tf.float32)\n",
    "        arg1 = tf.math.rsqrt(step)\n",
    "        arg2 = step * (self.warmup_steps ** (-1.5))\n",
    "        \n",
    "        arg3 = tf.math.rsqrt(self.d_model)\n",
    "        \n",
    "        return arg3 * tf.math.minimum(arg1, arg2)\n",
    "    \n",
    "learning_rate = CustomizedSchedule(d_model)\n",
    "# 优化器每次会调用learning_rate对，把step传给它，得到学习率的值\n",
    "optimizer = keras.optimizers.Adam(learning_rate,\n",
    "                                  beta_1 = 0.9,\n",
    "                                  beta_2 = 0.98,\n",
    "                                  epsilon = 1e-9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:01.641161700Z",
     "start_time": "2023-10-31T15:10:01.515077600Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "Text(0.5, 0, 'Train step')"
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "temp_learning_rate_schedule = CustomizedSchedule(d_model)\n",
    "# 下面是学习率的设计图\n",
    "plt.plot(\n",
    "    temp_learning_rate_schedule(\n",
    "        tf.range(40000, dtype=tf.float32)))\n",
    "plt.ylabel(\"Leraning rate\")\n",
    "plt.xlabel(\"Train step\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:01.657900500Z",
     "start_time": "2023-10-31T15:10:01.641161700Z"
    }
   },
   "outputs": [],
   "source": [
    "loss_object = keras.losses.SparseCategoricalCrossentropy(\n",
    "    from_logits = True)\n",
    "\n",
    "# 下面是损失的padd\n",
    "def loss_function(real, pred):\n",
    "    # 损失做了掩码处理，是padding的地方不计算损失\n",
    "    mask = tf.math.logical_not(tf.math.equal(real, 0))\n",
    "    loss_ = loss_object(real, pred)\n",
    "    \n",
    "    mask = tf.cast(mask, dtype=loss_.dtype)\n",
    "    loss_ *= mask\n",
    "    \n",
    "    return tf.reduce_mean(loss_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 初始化mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:01.690463700Z",
     "start_time": "2023-10-31T15:10:01.657900500Z"
    }
   },
   "outputs": [],
   "source": [
    "def create_masks(inp, tar):\n",
    "    \"\"\"\n",
    "    Encoder:\n",
    "      - encoder_padding_mask (self attention of EncoderLayer)\n",
    "      对于encoder中padding值没作用，所以无需attention\n",
    "    Decoder:\n",
    "      - look_ahead_mask (self attention of DecoderLayer)\n",
    "      target位置上的词不能看到之后的词，因为之后的词没预测出来\n",
    "      - encoder_decoder_padding_mask (encoder-decoder attention of DecoderLayer)\n",
    "      decoder不应该到encoder的padding上去花费精力\n",
    "      - decoder_padding_mask (self attention of DecoderLayer)\n",
    "      decoder也有padding，所以mask掉\n",
    "    \"\"\"\n",
    "    # inp的shape (64,37)\n",
    "    # tar的shape (64,40)\n",
    "    encoder_padding_mask = create_padding_mask(inp)\n",
    "    encoder_decoder_padding_mask = create_padding_mask(inp)\n",
    "    \n",
    "    look_ahead_mask = create_look_ahead_mask(tf.shape(tar)[1]) #上三角矩阵 (40,40)\n",
    "    decoder_padding_mask = create_padding_mask(tar) #tar的padding mask (64,1,1,40)\n",
    "    decoder_mask = tf.maximum(decoder_padding_mask,\n",
    "                              look_ahead_mask)\n",
    "    \n",
    "    # print( encoder_padding_mask.shape ) #这里看完要注释掉，避免下面太多打印\n",
    "    # print( encoder_decoder_padding_mask.shape )\n",
    "    # print( look_ahead_mask.shape)\n",
    "    # print('-'*50)\n",
    "    # print( decoder_padding_mask.shape)\n",
    "    # print('-'*50)\n",
    "    # print( decoder_mask.shape)\n",
    "\n",
    "    \n",
    "    return encoder_padding_mask, decoder_mask, encoder_decoder_padding_mask"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.251390700Z",
     "start_time": "2023-10-31T15:10:01.673909700Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64, 40)\n",
      "(64, 40)\n"
     ]
    },
    {
     "data": {
      "text/plain": "(<tf.Tensor: shape=(64, 1, 1, 40), dtype=float32, numpy=\n array([[[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        ...,\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 0., 0., 0.]]]], dtype=float32)>,\n <tf.Tensor: shape=(64, 1, 40, 40), dtype=float32, numpy=\n array([[[[0., 1., 1., ..., 1., 1., 1.],\n          [0., 0., 1., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          ...,\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 1., 1., ..., 1., 1., 1.],\n          [0., 0., 1., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          ...,\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 1., 1., ..., 1., 1., 1.],\n          [0., 0., 1., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          ...,\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        ...,\n \n \n        [[[0., 1., 1., ..., 1., 1., 1.],\n          [0., 0., 1., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          ...,\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 1., 1., ..., 1., 1., 1.],\n          [0., 0., 1., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          ...,\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 1., 1., ..., 1., 1., 1.],\n          [0., 0., 1., ..., 1., 1., 1.],\n          [0., 0., 0., ..., 1., 1., 1.],\n          ...,\n          [0., 0., 0., ..., 0., 1., 1.],\n          [0., 0., 0., ..., 0., 0., 1.],\n          [0., 0., 0., ..., 0., 0., 0.]]]], dtype=float32)>,\n <tf.Tensor: shape=(64, 1, 1, 40), dtype=float32, numpy=\n array([[[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        ...,\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 1., 1., 1.]]],\n \n \n        [[[0., 0., 0., ..., 0., 0., 0.]]]], dtype=float32)>)"
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 测试\n",
    "temp_inp, temp_tar = iter(train_dataset.take(1)).next()\n",
    "print(temp_inp.shape)\n",
    "print(temp_tar.shape)\n",
    "create_masks(temp_inp, temp_tar)\n",
    "#样本大小是64，不足的补齐35，或者39\n",
    "#最后是(64, 1, 39, 39)原因是既不关注前面的padding，也不关注后面的单词"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.314566200Z",
     "start_time": "2023-10-31T15:10:20.251390700Z"
    }
   },
   "outputs": [],
   "source": [
    "checkpoint_dir = './checkpoints'\n",
    "if not os.path.exists(checkpoint_dir):\n",
    "    os.mkdir(checkpoint_dir)\n",
    "checkpoint_prefix = os.path.join(checkpoint_dir, \"ckpt\")\n",
    "checkpoint = tf.train.Checkpoint(optimizer=optimizer,\n",
    "                  transformer=transformer) # 监控的对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.314566200Z",
     "start_time": "2023-10-31T15:10:20.267000200Z"
    }
   },
   "outputs": [],
   "source": [
    "train_loss = keras.metrics.Mean(name = 'train_loss') #累计求batch平均损失\n",
    "train_accuracy = keras.metrics.SparseCategoricalAccuracy(\n",
    "    name = 'train_accuracy')\n",
    "\n",
    "# 原始的标签是这样的 <start>  I  hava a bag <end>\n",
    "\n",
    "# Decoder input   <start>  I  hava a bag\n",
    "# Decoder output  I  hava a bag <end>\n",
    "\n",
    "@tf.function\n",
    "def train_step(inp, tar):\n",
    "    tar_inp  = tar[:, :-1]  # 没带end decoder 模块的输入\n",
    "    tar_real = tar[:, 1:]   # 没有start  decoder模块的输出\n",
    "\n",
    "    encoder_padding_mask, decoder_mask, encoder_decoder_padding_mask \\\n",
    "    = create_masks(inp, tar_inp)\n",
    "\n",
    "    with tf.GradientTape() as tape:\n",
    "        predictions, _ = transformer(inp, tar_inp, True,\n",
    "                                     encoder_padding_mask,\n",
    "                                     decoder_mask,\n",
    "                                     encoder_decoder_padding_mask)\n",
    "        loss = loss_function(tar_real, predictions)\n",
    "\n",
    "    gradients = tape.gradient(loss, transformer.trainable_variables)\n",
    "    optimizer.apply_gradients(\n",
    "        zip(gradients, transformer.trainable_variables))\n",
    "    train_loss(loss) # 损失，具有累计效果\n",
    "    train_accuracy(tar_real, predictions) #准确率，具有累计效果\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.427453200Z",
     "start_time": "2023-10-31T15:10:20.298557800Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<tensorflow.python.checkpoint.checkpoint.CheckpointLoadStatus at 0x17a0facfe50>"
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#如果加载成功，是<tensorflow.python.checkpoint.checkpoint.CheckpointLoadStatus，不成功有init\n",
    "checkpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.473353400Z",
     "start_time": "2023-10-31T15:10:20.427453200Z"
    }
   },
   "outputs": [],
   "source": [
    "# # 一个epochs接近100多秒，在kaggle上\n",
    "# epochs = 20\n",
    "# for epoch in range(epochs):\n",
    "#     start = time.time()\n",
    "#     # reset后就会从零开始累计\n",
    "#     train_loss.reset_states()\n",
    "#     train_accuracy.reset_states()\n",
    "#     \n",
    "#     for (batch, (inp, tar)) in enumerate(train_dataset):\n",
    "#         train_step(inp, tar)\n",
    "#         if batch % 100 == 0:\n",
    "#             print('Epoch {} Batch {} Loss {:.4f} Accuracy {:.4f}'.format(\n",
    "#                 epoch + 1, batch, train_loss.result(),\n",
    "#                 train_accuracy.result()))\n",
    "#     \n",
    "#     print('Epoch {} Loss {:.4f} Accuracy {:.4f}'.format(\n",
    "#         epoch + 1, train_loss.result(), train_accuracy.result()))\n",
    "#     print('Time take for 1 epoch: {} secs\\n'.format(\n",
    "#         time.time() - start))\n",
    "\n",
    "# loss是一个正常的指标，accuracy只是机器翻译的一个参考指标，可以看趋势\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.475140200Z",
     "start_time": "2023-10-31T15:10:20.442035900Z"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "eg: A B C D E F G H.\n",
    "Train: A B C D, E F G \n",
    "Eval:  A-》B\n",
    "     A B-->C\n",
    "     A B C-->D\n",
    "类似seq2seq2\n",
    "不同的是 transformer可以并行的处理，前后没有依赖，而seq2seq前后有依赖\n",
    "\"\"\"\n",
    "def evaluate(inp_sentence):\n",
    "    #文本的句子转换为id的句子\n",
    "    input_id_sentence = [pt_tokenizer.vocab_size] \\\n",
    "    + pt_tokenizer.encode(inp_sentence) + [pt_tokenizer.vocab_size + 1]\n",
    "    #transformer转换是两维的，因此转换\n",
    "    # encoder_input.shape: (1, input_sentence_length)\n",
    "    encoder_input = tf.expand_dims(input_id_sentence, 0)\n",
    "    \n",
    "    # decoder_input.shape: (1, 1)\n",
    "    #我们预测一个词就放入decoder_input，decoder_input给多个就可以预测多个，我们给一个\n",
    "    decoder_input = tf.expand_dims([en_tokenizer.vocab_size], 0)  #做一个<start>传进去，去预测i\n",
    "    \n",
    "    for i in range(max_length):\n",
    "        #产生mask并传给transformer\n",
    "        encoder_padding_mask, decoder_mask, encoder_decoder_padding_mask \\\n",
    "        = create_masks(encoder_input, decoder_input)\n",
    "        # predictions.shape: (batch_size, output_target_len, target_vocab_size)\n",
    "        predictions, attention_weights = transformer(\n",
    "            encoder_input,\n",
    "            decoder_input,\n",
    "            False,\n",
    "            encoder_padding_mask,\n",
    "            decoder_mask,\n",
    "            encoder_decoder_padding_mask)\n",
    "        # predictions.shape: (batch_size, target_vocab_size)\n",
    "        #我们每次只预测一个，所以是最后一个，第三个维度是vocab_size维度\n",
    "        print(predictions.shape)\n",
    "        predictions = predictions[:, -1, :]\n",
    "        #预测值就是概率最大的那个的索引，那最后一个维度中最大的那个值\n",
    "        predicted_id = tf.cast(tf.argmax(predictions, axis = -1),\n",
    "                               tf.int32)\n",
    "        #如果等于end token id，预测结束\n",
    "        if tf.equal(predicted_id, en_tokenizer.vocab_size + 1):\n",
    "            return tf.squeeze(decoder_input, axis = 0), attention_weights\n",
    "        #如果predicted_id不是end id，添加到新的decoder_input中\n",
    "        decoder_input = tf.concat([decoder_input, [predicted_id]],\n",
    "                                  axis = -1)\n",
    "        # print(decoder_input)\n",
    "    return tf.squeeze(decoder_input, axis = 0), attention_weights\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.475140200Z",
     "start_time": "2023-10-31T15:10:20.457667Z"
    }
   },
   "outputs": [],
   "source": [
    "def plot_encoder_decoder_attention(attention, input_sentence,\n",
    "                                   result, layer_name):\n",
    "    fig = plt.figure(figsize = (16, 8))\n",
    "    \n",
    "    input_id_sentence = pt_tokenizer.encode(input_sentence)\n",
    "    \n",
    "    # attention.shape: (num_heads, tar_len, input_len)\n",
    "    attention = tf.squeeze(attention[layer_name], axis = 0)\n",
    "    \n",
    "    for head in range(attention.shape[0]):\n",
    "        ax = fig.add_subplot(2, 4, head + 1)\n",
    "        \n",
    "        ax.matshow(attention[head][:-1, :])\n",
    "        \n",
    "        fontdict = {'fontsize': 10}\n",
    "        \n",
    "        ax.set_xticks(range(len(input_id_sentence) + 2))\n",
    "        ax.set_yticks(range(len(result)))\n",
    "        \n",
    "        ax.set_ylim(len(result) - 1.5, -0.5)\n",
    "        \n",
    "        ax.set_xticklabels(\n",
    "            ['<start>'] + [pt_tokenizer.decode([i]) for i in input_id_sentence] + ['<end>'],\n",
    "            fontdict = fontdict, rotation = 90)\n",
    "        ax.set_yticklabels(\n",
    "            [en_tokenizer.decode([i]) for i in result if i < en_tokenizer.vocab_size],\n",
    "            fontdict = fontdict)\n",
    "        ax.set_xlabel('Head {}'.format(head + 1))\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:20.492555600Z",
     "start_time": "2023-10-31T15:10:20.475140200Z"
    }
   },
   "outputs": [],
   "source": [
    "def translate(input_sentence, layer_name = ''):\n",
    "    result, attention_weights = evaluate(input_sentence)\n",
    "    \n",
    "    predicted_sentence = en_tokenizer.decode(\n",
    "        [i for i in result if i < en_tokenizer.vocab_size])\n",
    "    \n",
    "    print(\"Input: {}\".format(input_sentence))\n",
    "    print(\"Predicted translation: {}\".format(predicted_sentence))\n",
    "    \n",
    "    if layer_name:\n",
    "        plot_encoder_decoder_attention(attention_weights, input_sentence,\n",
    "                                       result, layer_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:23.712669500Z",
     "start_time": "2023-10-31T15:10:20.492555600Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "Input: está muito frio aqui.\n",
      "Predicted translation: it 's very interesting now , there 's the same thing .\n"
     ]
    }
   ],
   "source": [
    "translate('está muito frio aqui.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-10-31T15:10:24.455273400Z",
     "start_time": "2023-10-31T15:10:23.712669500Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "Input: isto é minha vida\n",
      "Predicted translation: this is my life .\n"
     ]
    }
   ],
   "source": [
    "translate('isto é minha vida')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 1, 8089)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\83633\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\nltk\\translate\\bleu_score.py:552: UserWarning: \n",
      "The hypothesis contains 0 counts of 2-gram overlaps.\n",
      "Therefore the BLEU score evaluates to 0, independently of\n",
      "how many N-gram overlaps of lower order it contains.\n",
      "Consider using lower n-gram order or use SmoothingFunction()\n",
      "  warnings.warn(_msg)\n",
      "C:\\Users\\83633\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\nltk\\translate\\bleu_score.py:552: UserWarning: \n",
      "The hypothesis contains 0 counts of 3-gram overlaps.\n",
      "Therefore the BLEU score evaluates to 0, independently of\n",
      "how many N-gram overlaps of lower order it contains.\n",
      "Consider using lower n-gram order or use SmoothingFunction()\n",
      "  warnings.warn(_msg)\n",
      "C:\\Users\\83633\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\nltk\\translate\\bleu_score.py:552: UserWarning: \n",
      "The hypothesis contains 0 counts of 4-gram overlaps.\n",
      "Therefore the BLEU score evaluates to 0, independently of\n",
      "how many N-gram overlaps of lower order it contains.\n",
      "Consider using lower n-gram order or use SmoothingFunction()\n",
      "  warnings.warn(_msg)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 30, 8089)\n",
      "(1, 31, 8089)\n",
      "(1, 32, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 30, 8089)\n",
      "(1, 31, 8089)\n",
      "(1, 32, 8089)\n",
      "(1, 33, 8089)\n",
      "(1, 34, 8089)\n",
      "(1, 35, 8089)\n",
      "(1, 36, 8089)\n",
      "(1, 37, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 30, 8089)\n",
      "(1, 31, 8089)\n",
      "(1, 32, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 30, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n",
      "(1, 16, 8089)\n",
      "(1, 17, 8089)\n",
      "(1, 18, 8089)\n",
      "(1, 19, 8089)\n",
      "(1, 20, 8089)\n",
      "(1, 21, 8089)\n",
      "(1, 22, 8089)\n",
      "(1, 23, 8089)\n",
      "(1, 24, 8089)\n",
      "(1, 25, 8089)\n",
      "(1, 26, 8089)\n",
      "(1, 27, 8089)\n",
      "(1, 28, 8089)\n",
      "(1, 29, 8089)\n",
      "(1, 30, 8089)\n",
      "(1, 31, 8089)\n",
      "(1, 32, 8089)\n",
      "(1, 33, 8089)\n",
      "(1, 34, 8089)\n",
      "(1, 35, 8089)\n",
      "(1, 36, 8089)\n",
      "(1, 37, 8089)\n",
      "(1, 38, 8089)\n",
      "(1, 1, 8089)\n",
      "(1, 2, 8089)\n",
      "(1, 3, 8089)\n",
      "(1, 4, 8089)\n",
      "(1, 5, 8089)\n",
      "(1, 6, 8089)\n",
      "(1, 7, 8089)\n",
      "(1, 8, 8089)\n",
      "(1, 9, 8089)\n",
      "(1, 10, 8089)\n",
      "(1, 11, 8089)\n",
      "(1, 12, 8089)\n",
      "(1, 13, 8089)\n",
      "(1, 14, 8089)\n",
      "(1, 15, 8089)\n"
     ]
    },
    {
     "data": {
      "text/plain": "0.008361719186432779"
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from nltk.translate.bleu_score import sentence_bleu\n",
    "total_bleu = 0.0\n",
    "i = 0\n",
    "for pt_val, en_val in val_examples:\n",
    "    if len(pt_tokenizer.encode(pt_val.numpy())) > 38 or len(en_tokenizer.encode(en_val.numpy())) > 38:\n",
    "        continue\n",
    "    result, _ = evaluate(pt_val.numpy())\n",
    "    predicted_sentence = en_tokenizer.decode([i for i in result\n",
    "                                              if i < en_tokenizer.vocab_size])\n",
    "    bleu = sentence_bleu(\n",
    "        [en_val.numpy().decode('utf8').split(' ')],\n",
    "        predicted_sentence.split(' '),\n",
    "        weights=(0.5, 0.5, 0., 0.)) # weights是四个指标的权重，即1-gram,2-gram,3-gram,4-gram\n",
    "    total_bleu += bleu\n",
    "    i+=1\n",
    "    if i==100:\n",
    "        break\n",
    "total_bleu/i"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2023-10-31T15:19:26.088774900Z",
     "start_time": "2023-10-31T15:16:04.637837400Z"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.9.7"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}