From 7d7509ba6564b763ef71a984bbee8edb23fdedc8 Mon Sep 17 00:00:00 2001
From: ShotaSato01 <sato11sho03@outlook.jp>
Date: Tue, 16 Jul 2024 02:27:18 +0900
Subject: [PATCH] chapter09

---
 shota/chapter09/knock85.ipynb |  699 ++++++++++
 shota/chapter09/knock86.ipynb |  609 +++++++++
 shota/chapter09/knock87.ipynb |  745 ++++++++++
 shota/chapter09/knock88.ipynb |  741 ++++++++++
 shota/chapter09/knock89.ipynb | 2423 +++++++++++++++++++++++++++++++++
 5 files changed, 5217 insertions(+)
 create mode 100644 shota/chapter09/knock85.ipynb
 create mode 100644 shota/chapter09/knock86.ipynb
 create mode 100644 shota/chapter09/knock87.ipynb
 create mode 100644 shota/chapter09/knock88.ipynb
 create mode 100644 shota/chapter09/knock89.ipynb

diff --git a/shota/chapter09/knock85.ipynb b/shota/chapter09/knock85.ipynb
new file mode 100644
index 0000000..216bf49
--- /dev/null
+++ b/shota/chapter09/knock85.ipynb
@@ -0,0 +1,699 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u3LQlfugXBRi",
+        "outputId": "d2b7bd4c-65ce-4b91-f41b-f5d497d16ec3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データ\n",
+            "CATEGORY\n",
+            "b    4502\n",
+            "e    4223\n",
+            "t    1219\n",
+            "m     728\n",
+            "Name: count, dtype: int64\n",
+            "検証データ\n",
+            "CATEGORY\n",
+            "b    562\n",
+            "e    528\n",
+            "t    153\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n",
+            "評価データ\n",
+            "CATEGORY\n",
+            "b    563\n",
+            "e    528\n",
+            "t    152\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "#データの読み込み\n",
+        "import pandas as pd\n",
+        "train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/train.txt', sep=\"\\t\")\n",
+        "test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/test.txt', sep=\"\\t\")\n",
+        "valid = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/valid.txt', sep=\"\\t\")\n",
+        "# データ数の確認\n",
+        "print('学習データ')\n",
+        "print(train['CATEGORY'].value_counts())\n",
+        "print('検証データ')\n",
+        "print(valid['CATEGORY'].value_counts())\n",
+        "print('評価データ')\n",
+        "print(test['CATEGORY'].value_counts())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語の辞書を作成\n",
+        "from collections import Counter\n",
+        "words = []\n",
+        "for text in train['TITLE']:                #訓練データから文章を1つずつ取り出す\n",
+        "    for word in text.rstrip().split():     #文章を単語に分解\n",
+        "        words.append(word)                 #単語をリストに追加\n",
+        "c = Counter(words)                         #単語の出現回数を数える\n",
+        "print(c.most_common(10))                   #頻度上位10単語\n",
+        "word2id = {}                               #単語IDの辞書\n",
+        "for i, cnt in enumerate(c.most_common()):  #頻度上位10単語分繰り返す\n",
+        "    if cnt[1] > 1:                         #出現回数が1より大きい単語のみ\n",
+        "        word2id[cnt[0]] = i + 1            #辞書に単語とIDを紐付ける\n",
+        "for i, cnt in enumerate(word2id.items()):  #辞書の中身を確認\n",
+        "    if i >= 10:                            #10単語だけ表示\n",
+        "        break                              #for文を抜ける\n",
+        "    print(cnt[0], cnt[1])                  #単語とIDを表示"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BaoFH2FcaZcJ",
+        "outputId": "12b687be-da12-42ea-ff91-e1711c2801be"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[('to', 2151), ('...', 2031), ('in', 1415), ('as', 1027), ('on', 1025), ('UPDATE', 1000), ('-', 991), ('for', 969), ('of', 957), ('The', 859)]\n",
+            "to 1\n",
+            "... 2\n",
+            "in 3\n",
+            "as 4\n",
+            "on 5\n",
+            "UPDATE 6\n",
+            "- 7\n",
+            "for 8\n",
+            "of 9\n",
+            "The 10\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語のID化\n",
+        "def tokenizer(text):                                 #単語IDのリストを返す関数\n",
+        "    words = text.rstrip().split()                    #単語に分解\n",
+        "    return [word2id.get(word, 0) for word in words]  #単語のIDに変換\n",
+        "\n",
+        "sample = train.at[0, 'TITLE']                        #学習データの1つ目の文章\n",
+        "print(sample)                                        #文章を表示\n",
+        "print(tokenizer(sample))                             #文章を単語IDに変換"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d-hhnRWjagOZ",
+        "outputId": "22eb39e1-08ad-48d3-987e-65c038720d51"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Justin Bieber Under Investigation For Attempted Robbery At Dave & Buster's\n",
+            "[66, 79, 733, 2094, 21, 4933, 6674, 35, 1514, 86, 0]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# RNNの作成\n",
+        "# モデルの構築\n",
+        "import random\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.utils.data as data\n",
+        "from torchinfo import summary\n",
+        "import numpy as np\n",
+        "\n",
+        "# 乱数のシードを設定\n",
+        "# parserなどで指定\n",
+        "seed = 1234\n",
+        "\n",
+        "random.seed(seed)                                   # Python標準ライブラリの乱数のシードを設定\n",
+        "np.random.seed(seed)                                # Numpy乱数のシードを設定\n",
+        "torch.manual_seed(seed)                             # PyTorch乱数のシードを設定\n",
+        "torch.cuda.manual_seed(seed)                        # PyTorchのCUDA乱数のシードを設定\n",
+        "torch.backends.cudnn.benchmark = False              # PyTorchのCUDNNのベンチマークを使用しない  (cudnn内の非決定的な処理の固定化)\n",
+        "torch.backends.cudnn.deterministic = True           # PyTorchのCUDNNの定着を使用\n",
+        "\n",
+        "def seed_worker(worker_id):\n",
+        "    worker_seed = torch.initial_seed() % 2**32      # 乱数生成のシードの初期値を設定\n",
+        "    np.random.seed(worker_seed)                     # Numpy乱数のシードを設定\n",
+        "    random.seed(worker_seed)                        # Python標準ライブラリの乱数のシードを設定\n",
+        "\n",
+        "g = torch.Generator()                               # PyTorch乱数のシードを設定\n",
+        "g.manual_seed(seed)                                 # 乱数生成器にシードを設定"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HY0GKwcpKlfN",
+        "outputId": "6800f591-1306-4fe9-bfde-568e72762ce1"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<torch._C.Generator at 0x7df746d78d30>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 20
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x = torch.tensor([tokenizer(sample)], dtype=torch.int64)                           # 文章を単語IDに変換\n",
+        "print(x)                                                                           # 文章をIDでを表示\n",
+        "print(x.size())                                                                    # 文章のサイズを確認"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "B-8OkqkTLAXg",
+        "outputId": "49e03136-fe88-47cd-a34e-37ce148eb03a"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  66,   79,  733, 2094,   21, 4933, 6674,   35, 1514,   86,    0]])\n",
+            "torch.Size([1, 11])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ターゲットのテンソル化\n",
+        "category_dict = {'b': 0, 't': 1, 'e':2, 'm':3}\n",
+        "Y_train = torch.from_numpy(train['CATEGORY'].map(category_dict).values)\n",
+        "Y_valid = torch.from_numpy(valid['CATEGORY'].map(category_dict).values)\n",
+        "Y_test = torch.from_numpy(test['CATEGORY'].map(category_dict).values)\n",
+        "print(Y_train.size())\n",
+        "print(Y_train)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IhA2l-VwAsr_",
+        "outputId": "7f4eaf51-d2aa-4157-d525-2c179d99617f"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([10672])\n",
+            "tensor([2, 0, 2,  ..., 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class NewsDataset(data.Dataset):\n",
+        "    \"\"\"\n",
+        "    newsのDatasetクラス\n",
+        "\n",
+        "    Attributes\n",
+        "    ----------------------------\n",
+        "    X : データフレーム\n",
+        "        単語ベクトルの平均をまとめたテンソル\n",
+        "    y : テンソル\n",
+        "        カテゴリをラベル化したテンソル\n",
+        "    phase : 'train' or 'val'\n",
+        "        学習か訓練かを設定する\n",
+        "    \"\"\"\n",
+        "    def __init__(self, X, y, phase='train'):\n",
+        "        self.X = X['TITLE']\n",
+        "        self.y = y\n",
+        "        self.phase = phase\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        \"\"\"全データサイズを返す\"\"\"\n",
+        "        return len(self.y)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        \"\"\"idxに対応するテンソル形式のデータとラベルを取得\"\"\"\n",
+        "        inputs = torch.tensor(tokenizer(self.X[idx]))\n",
+        "        return inputs, self.y[idx]\n",
+        "\n",
+        "train_dataset = NewsDataset(train, Y_train, phase='train')\n",
+        "valid_dataset = NewsDataset(valid, Y_valid, phase='val')\n",
+        "test_dataset = NewsDataset(test, Y_test, phase='val')\n",
+        "# 動作確認\n",
+        "idx = 0\n",
+        "print(train_dataset.__getitem__(idx)[0].size())\n",
+        "print(train_dataset.__getitem__(idx)[1])\n",
+        "print(valid_dataset.__getitem__(idx)[0].size())\n",
+        "print(valid_dataset.__getitem__(idx)[1])\n",
+        "print(test_dataset.__getitem__(idx)[0].size())\n",
+        "print(test_dataset.__getitem__(idx)[1])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qMifdMwaAvji",
+        "outputId": "81a9ba7b-f0c5-4270-addc-b209b3aaf523"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([11])\n",
+            "tensor(2)\n",
+            "torch.Size([11])\n",
+            "tensor(3)\n",
+            "torch.Size([13])\n",
+            "tensor(2)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def collate_fn(batch):\n",
+        "    sequences = [x[0] for x in batch]\n",
+        "    labels = torch.LongTensor([x[1] for x in batch])\n",
+        "    x = torch.nn.utils.rnn.pad_sequence(sequences, batch_first=True, padding_value=PADDING_IDX)\n",
+        "    return x, labels\n",
+        "\n",
+        "# DataLoaderを作成\n",
+        "batch_size = 64\n",
+        "\n",
+        "train_dataloader = data.DataLoader(\n",
+        "            train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "valid_dataloader = data.DataLoader(\n",
+        "            valid_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "test_dataloader = data.DataLoader(\n",
+        "            test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "\n",
+        "dataloaders_dict = {'train': train_dataloader,\n",
+        "                    'val': valid_dataloader,\n",
+        "                    'test': test_dataloader,\n",
+        "                   }\n",
+        "\n",
+        "# 動作確認\n",
+        "batch_iter = iter(dataloaders_dict['train'])\n",
+        "inputs, labels = next(batch_iter)\n",
+        "print(inputs)\n",
+        "print(labels)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xRSh5D22Axsg",
+        "outputId": "2ef056d9-2c38-4f53-c486-8e50ec595c8d"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[ 1136,   890,    22,  ..., 10327, 10327, 10327],\n",
+            "        [ 9241,   853,  8128,  ..., 10327, 10327, 10327],\n",
+            "        [  211,  1843,   104,  ..., 10327, 10327, 10327],\n",
+            "        ...,\n",
+            "        [ 2886,  4097,  5178,  ..., 10327, 10327, 10327],\n",
+            "        [ 2595,    40,  8576,  ..., 10327, 10327, 10327],\n",
+            "        [    6,     0,  3373,  ..., 10327, 10327, 10327]])\n",
+            "tensor([2, 2, 0, 0, 2, 1, 0, 0, 2, 1, 1, 1, 0, 2, 0, 0, 0, 0, 1, 2, 2, 2, 0, 1,\n",
+            "        0, 0, 1, 2, 1, 2, 2, 0, 2, 2, 2, 0, 0, 2, 0, 0, 0, 3, 2, 3, 1, 2, 0, 2,\n",
+            "        0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from gensim.models import KeyedVectors\n",
+        "\n",
+        "# 学習済みモデルのロード\n",
+        "file = '/content/drive/MyDrive/Colab Notebooks/chapter09/GoogleNews-vectors-negative300.bin.gz'\n",
+        "model = KeyedVectors.load_word2vec_format(file, binary=True)\n",
+        "\n",
+        "# 学習済み単語ベクトルの取得\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "weights = np.zeros((VOCAB_SIZE, EMB_SIZE))\n",
+        "words_in_pretrained = 0\n",
+        "for i, word in enumerate(word2id.keys()):\n",
+        "    try:\n",
+        "        weights[i] = model[word]\n",
+        "        words_in_pretrained += 1\n",
+        "    except KeyError:\n",
+        "        weights[i] = np.random.normal(scale=0.1, size=(EMB_SIZE,))\n",
+        "weights = torch.from_numpy(weights.astype((np.float32)))\n",
+        "\n",
+        "print(f'学習済みベクトル利用単語数: {words_in_pretrained} / {VOCAB_SIZE}')\n",
+        "print(weights.size())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zLn_cZ71QGqD",
+        "outputId": "29eba55b-a1c1-4879-88c7-2e6005d674ed"
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習済みベクトル利用単語数: 8340 / 10328\n",
+            "torch.Size([10328, 300])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def calc_acc(net, dataloader):\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    net.eval()\n",
+        "    corrects = 0\n",
+        "    with torch.no_grad():\n",
+        "        for inputs, labels in dataloader:\n",
+        "            inputs = inputs.to(device)\n",
+        "            labels = labels.to(device)\n",
+        "            outputs = net(inputs)\n",
+        "            _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "            corrects += torch.sum(preds == labels.data).cpu()\n",
+        "    return corrects / len(dataloader.dataset)"
+      ],
+      "metadata": {
+        "id": "orK8m3eSRY11"
+      },
+      "execution_count": 26,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 学習を実行する\n",
+        "# 学習用の関数を定義\n",
+        "def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):\n",
+        "\n",
+        "    # 初期設定\n",
+        "    # GPUが使えるか確認\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    print(torch.cuda.get_device_name())\n",
+        "    print(\"使用デバイス:\", device)\n",
+        "\n",
+        "    # ネットワークをgpuへ\n",
+        "    net.to(device)\n",
+        "\n",
+        "    train_loss = []\n",
+        "    train_acc = []\n",
+        "    valid_loss = []\n",
+        "    valid_acc = []\n",
+        "\n",
+        "    # epochのループ\n",
+        "    for epoch in range(num_epochs):\n",
+        "        # epochごとの学習と検証のループ\n",
+        "        for phase in ['train', 'val']:\n",
+        "            if phase == 'train':\n",
+        "                net.train() # 訓練モード\n",
+        "            else:\n",
+        "                net.eval() # 検証モード\n",
+        "\n",
+        "            epoch_loss = 0.0 # epochの損失和\n",
+        "            epoch_corrects = 0 # epochの正解数\n",
+        "\n",
+        "            # データローダーからミニバッチを取り出すループ\n",
+        "            for inputs, labels in dataloaders_dict[phase]:\n",
+        "                # GPUが使えるならGPUにおっくる\n",
+        "                inputs = inputs.to(device)\n",
+        "                labels = labels.to(device)\n",
+        "                optimizer.zero_grad() # optimizerを初期化\n",
+        "\n",
+        "                # 順伝播計算(forward)\n",
+        "                with torch.set_grad_enabled(phase == 'train'):\n",
+        "                    outputs = net(inputs)\n",
+        "                    loss = criterion(outputs, labels) # 損失を計算\n",
+        "                    _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "\n",
+        "                    # 訓練時は逆伝播\n",
+        "                    if phase == 'train':\n",
+        "                        loss.backward()\n",
+        "                        optimizer.step()\n",
+        "\n",
+        "                    # イテレーション結果の計算\n",
+        "                    # lossの合計を更新\n",
+        "                    epoch_loss += loss.item() * inputs.size(0)\n",
+        "                    # 正解数の合計を更新\n",
+        "                    epoch_corrects += torch.sum(preds == labels.data)\n",
+        "\n",
+        "            # epochごとのlossと正解率の表示\n",
+        "            epoch_loss = epoch_loss / len(dataloaders_dict[phase].dataset)\n",
+        "            epoch_acc = epoch_corrects.double() / len(dataloaders_dict[phase].dataset)\n",
+        "            if phase == 'train':\n",
+        "                train_loss.append(epoch_loss)\n",
+        "                train_acc.append(epoch_acc.cpu())\n",
+        "            else:\n",
+        "                valid_loss.append(epoch_loss)\n",
+        "                valid_acc.append(epoch_acc.cpu())\n",
+        "\n",
+        "        print('Epoch {} / {} (train) Loss: {:.4f}, Acc: {:.4f}, (val) Loss: {:.4f}, Acc: {:.4f}'.format(epoch + 1, num_epochs, train_loss[-1], train_acc[-1], valid_loss[-1], valid_acc[-1]))\n",
+        "    return train_loss, train_acc, valid_loss, valid_acc"
+      ],
+      "metadata": {
+        "id": "T-hgB0t7Tf_h"
+      },
+      "execution_count": 27,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class RNN(nn.Module):\n",
+        "    def __init__(self, vocab_size, emb_size, padding_idx, hidden_size, output_size, num_layers=3, emb_weights=None):\n",
+        "        super().__init__()\n",
+        "        if emb_weights != None:\n",
+        "            self.emb = nn.Embedding.from_pretrained(emb_weights, padding_idx=padding_idx)\n",
+        "        else:\n",
+        "            self.emb = nn.Embedding(vocab_size, emb_size, padding_idx=padding_idx)\n",
+        "        self.rnn = nn.LSTM(emb_size, hidden_size, num_layers, batch_first=True, bidirectional=True)\n",
+        "        self.fc = nn.Linear(hidden_size * 2, output_size)\n",
+        "\n",
+        "    def forward(self, x, h0=None):\n",
+        "        x = self.emb(x)\n",
+        "        x, h = self.rnn(x, h0)\n",
+        "        x = x[:, -1, :]\n",
+        "        logits = self.fc(x)\n",
+        "        return logits\n",
+        "\n",
+        "# パラメータの設定\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2  # 辞書のID数 + unknown + パディングID\n",
+        "EMB_SIZE = 300\n",
+        "PADDING_IDX = len(set(word2id.values())) + 1\n",
+        "OUTPUT_SIZE = 4\n",
+        "HIDDEN_SIZE = 50\n",
+        "NUM_LAYERS = 3\n",
+        "\n",
+        "# モデルの定義\n",
+        "net = RNN(VOCAB_SIZE, EMB_SIZE, PADDING_IDX, HIDDEN_SIZE, OUTPUT_SIZE, NUM_LAYERS, weights)\n",
+        "net.train()\n",
+        "\n",
+        "# 損失関数の定義\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "\n",
+        "# 最適化手法の定義\n",
+        "optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)\n",
+        "\n",
+        "num_epochs = 30\n",
+        "train_loss, train_acc, valid_loss, valid_acc = train_model(net,\n",
+        "            dataloaders_dict, criterion, optimizer, num_epochs=num_epochs)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wWmrRsDCXMxQ",
+        "outputId": "91e7bf0b-efa1-433a-cb34-4da4b9549eb2"
+      },
+      "execution_count": 28,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Tesla T4\n",
+            "使用デバイス: cuda:0\n",
+            "Epoch 1 / 30 (train) Loss: 1.1713, Acc: 0.4162, (val) Loss: 1.1660, Acc: 0.3966\n",
+            "Epoch 2 / 30 (train) Loss: 1.1610, Acc: 0.4319, (val) Loss: 1.1490, Acc: 0.5210\n",
+            "Epoch 3 / 30 (train) Loss: 1.1220, Acc: 0.5179, (val) Loss: 1.1301, Acc: 0.3958\n",
+            "Epoch 4 / 30 (train) Loss: 1.0503, Acc: 0.5875, (val) Loss: 0.9574, Acc: 0.6522\n",
+            "Epoch 5 / 30 (train) Loss: 1.0028, Acc: 0.6304, (val) Loss: 0.9307, Acc: 0.6694\n",
+            "Epoch 6 / 30 (train) Loss: 0.9164, Acc: 0.6714, (val) Loss: 0.8776, Acc: 0.6904\n",
+            "Epoch 7 / 30 (train) Loss: 0.8681, Acc: 0.6911, (val) Loss: 0.8389, Acc: 0.7076\n",
+            "Epoch 8 / 30 (train) Loss: 0.8374, Acc: 0.7060, (val) Loss: 0.8713, Acc: 0.6822\n",
+            "Epoch 9 / 30 (train) Loss: 0.7779, Acc: 0.7233, (val) Loss: 0.7800, Acc: 0.7286\n",
+            "Epoch 10 / 30 (train) Loss: 0.7189, Acc: 0.7389, (val) Loss: 0.7550, Acc: 0.7301\n",
+            "Epoch 11 / 30 (train) Loss: 0.7084, Acc: 0.7427, (val) Loss: 0.7080, Acc: 0.7466\n",
+            "Epoch 12 / 30 (train) Loss: 0.6801, Acc: 0.7526, (val) Loss: 0.7298, Acc: 0.7406\n",
+            "Epoch 13 / 30 (train) Loss: 0.6364, Acc: 0.7601, (val) Loss: 0.6850, Acc: 0.7474\n",
+            "Epoch 14 / 30 (train) Loss: 0.6206, Acc: 0.7659, (val) Loss: 0.6979, Acc: 0.7414\n",
+            "Epoch 15 / 30 (train) Loss: 0.5707, Acc: 0.7796, (val) Loss: 0.6937, Acc: 0.7556\n",
+            "Epoch 16 / 30 (train) Loss: 0.6297, Acc: 0.7629, (val) Loss: 0.8360, Acc: 0.6934\n",
+            "Epoch 17 / 30 (train) Loss: 0.6277, Acc: 0.7627, (val) Loss: 0.7032, Acc: 0.7549\n",
+            "Epoch 18 / 30 (train) Loss: 0.5577, Acc: 0.7818, (val) Loss: 0.7104, Acc: 0.7466\n",
+            "Epoch 19 / 30 (train) Loss: 0.5265, Acc: 0.7939, (val) Loss: 0.6519, Acc: 0.7684\n",
+            "Epoch 20 / 30 (train) Loss: 0.4806, Acc: 0.8141, (val) Loss: 0.6682, Acc: 0.7774\n",
+            "Epoch 21 / 30 (train) Loss: 0.5146, Acc: 0.8050, (val) Loss: 0.7227, Acc: 0.7421\n",
+            "Epoch 22 / 30 (train) Loss: 0.4896, Acc: 0.8064, (val) Loss: 0.6305, Acc: 0.7819\n",
+            "Epoch 23 / 30 (train) Loss: 0.4300, Acc: 0.8270, (val) Loss: 0.7219, Acc: 0.7541\n",
+            "Epoch 24 / 30 (train) Loss: 0.4015, Acc: 0.8397, (val) Loss: 0.7034, Acc: 0.7789\n",
+            "Epoch 25 / 30 (train) Loss: 0.3793, Acc: 0.8445, (val) Loss: 0.6839, Acc: 0.7864\n",
+            "Epoch 26 / 30 (train) Loss: 0.3761, Acc: 0.8479, (val) Loss: 0.6891, Acc: 0.7414\n",
+            "Epoch 27 / 30 (train) Loss: 0.3526, Acc: 0.8567, (val) Loss: 0.6628, Acc: 0.7639\n",
+            "Epoch 28 / 30 (train) Loss: 0.5746, Acc: 0.7815, (val) Loss: 0.7149, Acc: 0.7384\n",
+            "Epoch 29 / 30 (train) Loss: 0.5849, Acc: 0.7738, (val) Loss: 0.6664, Acc: 0.7459\n",
+            "Epoch 30 / 30 (train) Loss: 0.5124, Acc: 0.8020, (val) Loss: 0.6733, Acc: 0.7459\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "fig, ax = plt.subplots(1,2, figsize=(10, 5))\n",
+        "epochs = np.arange(num_epochs)\n",
+        "ax[0].plot(epochs, train_loss, label='train')\n",
+        "ax[0].plot(epochs, valid_loss, label='valid')\n",
+        "ax[0].set_title('loss')\n",
+        "ax[0].set_xlabel('epoch')\n",
+        "ax[0].set_ylabel('loss')\n",
+        "ax[1].plot(epochs, train_acc, label='train')\n",
+        "ax[1].plot(epochs, valid_acc, label='valid')\n",
+        "ax[1].set_title('acc')\n",
+        "ax[1].set_xlabel('epoch')\n",
+        "ax[1].set_ylabel('acc')\n",
+        "ax[0].legend(loc='best')\n",
+        "ax[1].legend(loc='best')\n",
+        "plt.tight_layout()\n",
+        "plt.savefig('fig85.png')\n",
+        "plt.show()\n",
+        "\n",
+        "acc_train = calc_acc(net, train_dataloader)\n",
+        "acc_valid = calc_acc(net, valid_dataloader)\n",
+        "acc_test = calc_acc(net, test_dataloader)\n",
+        "print('学習データの正解率: {:.4f}'.format(acc_train))\n",
+        "print('検証データの正解率: {:.4f}'.format(acc_valid))\n",
+        "print('テストデータの正解率: {:.4f}'.format(acc_test))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 559
+        },
+        "id": "VtS1g3b8UcfR",
+        "outputId": "ed56c93f-1fd1-483b-9375-c85b727d5e8c"
+      },
+      "execution_count": 29,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データの正解率: 0.8086\n",
+            "検証データの正解率: 0.7459\n",
+            "テストデータの正解率: 0.7519\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "id": "D3W_cKr_XQdh"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install torchinfo"
+      ],
+      "metadata": {
+        "id": "GJp3iMQQKqVL"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/shota/chapter09/knock86.ipynb b/shota/chapter09/knock86.ipynb
new file mode 100644
index 0000000..9b8f962
--- /dev/null
+++ b/shota/chapter09/knock86.ipynb
@@ -0,0 +1,609 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u3LQlfugXBRi",
+        "outputId": "d2b7bd4c-65ce-4b91-f41b-f5d497d16ec3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データ\n",
+            "CATEGORY\n",
+            "b    4502\n",
+            "e    4223\n",
+            "t    1219\n",
+            "m     728\n",
+            "Name: count, dtype: int64\n",
+            "検証データ\n",
+            "CATEGORY\n",
+            "b    562\n",
+            "e    528\n",
+            "t    153\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n",
+            "評価データ\n",
+            "CATEGORY\n",
+            "b    563\n",
+            "e    528\n",
+            "t    152\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "#データの読み込み\n",
+        "import pandas as pd\n",
+        "train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/train.txt', sep=\"\\t\")\n",
+        "test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/test.txt', sep=\"\\t\")\n",
+        "valid = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/valid.txt', sep=\"\\t\")\n",
+        "# データ数の確認\n",
+        "print('学習データ')\n",
+        "print(train['CATEGORY'].value_counts())\n",
+        "print('検証データ')\n",
+        "print(valid['CATEGORY'].value_counts())\n",
+        "print('評価データ')\n",
+        "print(test['CATEGORY'].value_counts())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語の辞書を作成\n",
+        "from collections import Counter\n",
+        "words = []\n",
+        "for text in train['TITLE']:                #訓練データから文章を1つずつ取り出す\n",
+        "    for word in text.rstrip().split():     #文章を単語に分解\n",
+        "        words.append(word)                 #単語をリストに追加\n",
+        "c = Counter(words)                         #単語の出現回数を数える\n",
+        "print(c.most_common(10))                   #頻度上位10単語\n",
+        "word2id = {}                               #単語IDの辞書\n",
+        "for i, cnt in enumerate(c.most_common()):  #頻度上位10単語分繰り返す\n",
+        "    if cnt[1] > 1:                         #出現回数が1より大きい単語のみ\n",
+        "        word2id[cnt[0]] = i + 1            #辞書に単語とIDを紐付ける\n",
+        "for i, cnt in enumerate(word2id.items()):  #辞書の中身を確認\n",
+        "    if i >= 10:                            #10単語だけ表示\n",
+        "        break                              #for文を抜ける\n",
+        "    print(cnt[0], cnt[1])                  #単語とIDを表示"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BaoFH2FcaZcJ",
+        "outputId": "12b687be-da12-42ea-ff91-e1711c2801be"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[('to', 2151), ('...', 2031), ('in', 1415), ('as', 1027), ('on', 1025), ('UPDATE', 1000), ('-', 991), ('for', 969), ('of', 957), ('The', 859)]\n",
+            "to 1\n",
+            "... 2\n",
+            "in 3\n",
+            "as 4\n",
+            "on 5\n",
+            "UPDATE 6\n",
+            "- 7\n",
+            "for 8\n",
+            "of 9\n",
+            "The 10\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語のID化\n",
+        "def tokenizer(text):                                 #単語IDのリストを返す関数\n",
+        "    words = text.rstrip().split()                    #単語に分解\n",
+        "    return [word2id.get(word, 0) for word in words]  #単語のIDに変換\n",
+        "\n",
+        "sample = train.at[0, 'TITLE']                        #学習データの1つ目の文章\n",
+        "print(sample)                                        #文章を表示\n",
+        "print(tokenizer(sample))                             #文章を単語IDに変換"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d-hhnRWjagOZ",
+        "outputId": "22eb39e1-08ad-48d3-987e-65c038720d51"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Justin Bieber Under Investigation For Attempted Robbery At Dave & Buster's\n",
+            "[66, 79, 733, 2094, 21, 4933, 6674, 35, 1514, 86, 0]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# RNNの作成\n",
+        "# モデルの構築\n",
+        "import random\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.utils.data as data\n",
+        "from torchinfo import summary\n",
+        "import numpy as np\n",
+        "\n",
+        "# 乱数のシードを設定\n",
+        "# parserなどで指定\n",
+        "seed = 1234\n",
+        "\n",
+        "random.seed(seed)                                   # Python標準ライブラリの乱数のシードを設定\n",
+        "np.random.seed(seed)                                # Numpy乱数のシードを設定\n",
+        "torch.manual_seed(seed)                             # PyTorch乱数のシードを設定\n",
+        "torch.cuda.manual_seed(seed)                        # PyTorchのCUDA乱数のシードを設定\n",
+        "torch.backends.cudnn.benchmark = False              # PyTorchのCUDNNのベンチマークを使用しない  (cudnn内の非決定的な処理の固定化)\n",
+        "torch.backends.cudnn.deterministic = True           # PyTorchのCUDNNの定着を使用\n",
+        "\n",
+        "def seed_worker(worker_id):\n",
+        "    worker_seed = torch.initial_seed() % 2**32      # 乱数生成のシードの初期値を設定\n",
+        "    np.random.seed(worker_seed)                     # Numpy乱数のシードを設定\n",
+        "    random.seed(worker_seed)                        # Python標準ライブラリの乱数のシードを設定\n",
+        "\n",
+        "g = torch.Generator()                               # PyTorch乱数のシードを設定\n",
+        "g.manual_seed(seed)                                 # 乱数生成器にシードを設定"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HY0GKwcpKlfN",
+        "outputId": "6800f591-1306-4fe9-bfde-568e72762ce1"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<torch._C.Generator at 0x7df746d78d30>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 20
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x = torch.tensor([tokenizer(sample)], dtype=torch.int64)                           # 文章を単語IDに変換\n",
+        "print(x)                                                                           # 文章をIDでを表示\n",
+        "print(x.size())                                                                    # 文章のサイズを確認"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "B-8OkqkTLAXg",
+        "outputId": "49e03136-fe88-47cd-a34e-37ce148eb03a"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  66,   79,  733, 2094,   21, 4933, 6674,   35, 1514,   86,    0]])\n",
+            "torch.Size([1, 11])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ターゲットのテンソル化\n",
+        "category_dict = {'b': 0, 't': 1, 'e':2, 'm':3}\n",
+        "Y_train = torch.from_numpy(train['CATEGORY'].map(category_dict).values)\n",
+        "Y_valid = torch.from_numpy(valid['CATEGORY'].map(category_dict).values)\n",
+        "Y_test = torch.from_numpy(test['CATEGORY'].map(category_dict).values)\n",
+        "print(Y_train.size())\n",
+        "print(Y_train)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IhA2l-VwAsr_",
+        "outputId": "7f4eaf51-d2aa-4157-d525-2c179d99617f"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([10672])\n",
+            "tensor([2, 0, 2,  ..., 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class NewsDataset(data.Dataset):\n",
+        "    \"\"\"\n",
+        "    newsのDatasetクラス\n",
+        "\n",
+        "    Attributes\n",
+        "    ----------------------------\n",
+        "    X : データフレーム\n",
+        "        単語ベクトルの平均をまとめたテンソル\n",
+        "    y : テンソル\n",
+        "        カテゴリをラベル化したテンソル\n",
+        "    phase : 'train' or 'val'\n",
+        "        学習か訓練かを設定する\n",
+        "    \"\"\"\n",
+        "    def __init__(self, X, y, phase='train'):\n",
+        "        self.X = X['TITLE']\n",
+        "        self.y = y\n",
+        "        self.phase = phase\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        \"\"\"全データサイズを返す\"\"\"\n",
+        "        return len(self.y)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        \"\"\"idxに対応するテンソル形式のデータとラベルを取得\"\"\"\n",
+        "        inputs = torch.tensor(tokenizer(self.X[idx]))\n",
+        "        return inputs, self.y[idx]\n",
+        "\n",
+        "train_dataset = NewsDataset(train, Y_train, phase='train')\n",
+        "valid_dataset = NewsDataset(valid, Y_valid, phase='val')\n",
+        "test_dataset = NewsDataset(test, Y_test, phase='val')\n",
+        "# 動作確認\n",
+        "idx = 0\n",
+        "print(train_dataset.__getitem__(idx)[0].size())\n",
+        "print(train_dataset.__getitem__(idx)[1])\n",
+        "print(valid_dataset.__getitem__(idx)[0].size())\n",
+        "print(valid_dataset.__getitem__(idx)[1])\n",
+        "print(test_dataset.__getitem__(idx)[0].size())\n",
+        "print(test_dataset.__getitem__(idx)[1])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qMifdMwaAvji",
+        "outputId": "81a9ba7b-f0c5-4270-addc-b209b3aaf523"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([11])\n",
+            "tensor(2)\n",
+            "torch.Size([11])\n",
+            "tensor(3)\n",
+            "torch.Size([13])\n",
+            "tensor(2)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def collate_fn(batch):\n",
+        "    sequences = [x[0] for x in batch]\n",
+        "    labels = torch.LongTensor([x[1] for x in batch])\n",
+        "    x = torch.nn.utils.rnn.pad_sequence(sequences, batch_first=True, padding_value=PADDING_IDX)\n",
+        "    return x, labels\n",
+        "\n",
+        "# DataLoaderを作成\n",
+        "batch_size = 64\n",
+        "\n",
+        "train_dataloader = data.DataLoader(\n",
+        "            train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "valid_dataloader = data.DataLoader(\n",
+        "            valid_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "test_dataloader = data.DataLoader(\n",
+        "            test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "\n",
+        "dataloaders_dict = {'train': train_dataloader,\n",
+        "                    'val': valid_dataloader,\n",
+        "                    'test': test_dataloader,\n",
+        "                   }\n",
+        "\n",
+        "# 動作確認\n",
+        "batch_iter = iter(dataloaders_dict['train'])\n",
+        "inputs, labels = next(batch_iter)\n",
+        "print(inputs)\n",
+        "print(labels)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xRSh5D22Axsg",
+        "outputId": "2ef056d9-2c38-4f53-c486-8e50ec595c8d"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[ 1136,   890,    22,  ..., 10327, 10327, 10327],\n",
+            "        [ 9241,   853,  8128,  ..., 10327, 10327, 10327],\n",
+            "        [  211,  1843,   104,  ..., 10327, 10327, 10327],\n",
+            "        ...,\n",
+            "        [ 2886,  4097,  5178,  ..., 10327, 10327, 10327],\n",
+            "        [ 2595,    40,  8576,  ..., 10327, 10327, 10327],\n",
+            "        [    6,     0,  3373,  ..., 10327, 10327, 10327]])\n",
+            "tensor([2, 2, 0, 0, 2, 1, 0, 0, 2, 1, 1, 1, 0, 2, 0, 0, 0, 0, 1, 2, 2, 2, 0, 1,\n",
+            "        0, 0, 1, 2, 1, 2, 2, 0, 2, 2, 2, 0, 0, 2, 0, 0, 0, 3, 2, 3, 1, 2, 0, 2,\n",
+            "        0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from gensim.models import KeyedVectors\n",
+        "\n",
+        "# 学習済みモデルのロード\n",
+        "file = '/content/drive/MyDrive/Colab Notebooks/chapter09/GoogleNews-vectors-negative300.bin.gz'\n",
+        "model = KeyedVectors.load_word2vec_format(file, binary=True)\n",
+        "\n",
+        "# 学習済み単語ベクトルの取得\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "weights = np.zeros((VOCAB_SIZE, EMB_SIZE))\n",
+        "words_in_pretrained = 0\n",
+        "for i, word in enumerate(word2id.keys()):\n",
+        "    try:\n",
+        "        weights[i] = model[word]\n",
+        "        words_in_pretrained += 1\n",
+        "    except KeyError:\n",
+        "        weights[i] = np.random.normal(scale=0.1, size=(EMB_SIZE,))\n",
+        "weights = torch.from_numpy(weights.astype((np.float32)))\n",
+        "\n",
+        "print(f'学習済みベクトル利用単語数: {words_in_pretrained} / {VOCAB_SIZE}')\n",
+        "print(weights.size())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zLn_cZ71QGqD",
+        "outputId": "29eba55b-a1c1-4879-88c7-2e6005d674ed"
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習済みベクトル利用単語数: 8340 / 10328\n",
+            "torch.Size([10328, 300])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def calc_acc(net, dataloader):\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    net.eval()\n",
+        "    corrects = 0\n",
+        "    with torch.no_grad():\n",
+        "        for inputs, labels in dataloader:\n",
+        "            inputs = inputs.to(device)\n",
+        "            labels = labels.to(device)\n",
+        "            outputs = net(inputs)\n",
+        "            _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "            corrects += torch.sum(preds == labels.data).cpu()\n",
+        "    return corrects / len(dataloader.dataset)"
+      ],
+      "metadata": {
+        "id": "orK8m3eSRY11"
+      },
+      "execution_count": 26,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 学習を実行する\n",
+        "# 学習用の関数を定義\n",
+        "def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):\n",
+        "\n",
+        "    # 初期設定\n",
+        "    # GPUが使えるか確認\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    print(torch.cuda.get_device_name())\n",
+        "    print(\"使用デバイス:\", device)\n",
+        "\n",
+        "    # ネットワークをgpuへ\n",
+        "    net.to(device)\n",
+        "\n",
+        "    train_loss = []\n",
+        "    train_acc = []\n",
+        "    valid_loss = []\n",
+        "    valid_acc = []\n",
+        "\n",
+        "    # epochのループ\n",
+        "    for epoch in range(num_epochs):\n",
+        "        # epochごとの学習と検証のループ\n",
+        "        for phase in ['train', 'val']:\n",
+        "            if phase == 'train':\n",
+        "                net.train() # 訓練モード\n",
+        "            else:\n",
+        "                net.eval() # 検証モード\n",
+        "\n",
+        "            epoch_loss = 0.0 # epochの損失和\n",
+        "            epoch_corrects = 0 # epochの正解数\n",
+        "\n",
+        "            # データローダーからミニバッチを取り出すループ\n",
+        "            for inputs, labels in dataloaders_dict[phase]:\n",
+        "                # GPUが使えるならGPUにおっくる\n",
+        "                inputs = inputs.to(device)\n",
+        "                labels = labels.to(device)\n",
+        "                optimizer.zero_grad() # optimizerを初期化\n",
+        "\n",
+        "                # 順伝播計算(forward)\n",
+        "                with torch.set_grad_enabled(phase == 'train'):\n",
+        "                    outputs = net(inputs)\n",
+        "                    loss = criterion(outputs, labels) # 損失を計算\n",
+        "                    _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "\n",
+        "                    # 訓練時は逆伝播\n",
+        "                    if phase == 'train':\n",
+        "                        loss.backward()\n",
+        "                        optimizer.step()\n",
+        "\n",
+        "                    # イテレーション結果の計算\n",
+        "                    # lossの合計を更新\n",
+        "                    epoch_loss += loss.item() * inputs.size(0)\n",
+        "                    # 正解数の合計を更新\n",
+        "                    epoch_corrects += torch.sum(preds == labels.data)\n",
+        "\n",
+        "            # epochごとのlossと正解率の表示\n",
+        "            epoch_loss = epoch_loss / len(dataloaders_dict[phase].dataset)\n",
+        "            epoch_acc = epoch_corrects.double() / len(dataloaders_dict[phase].dataset)\n",
+        "            if phase == 'train':\n",
+        "                train_loss.append(epoch_loss)\n",
+        "                train_acc.append(epoch_acc.cpu())\n",
+        "            else:\n",
+        "                valid_loss.append(epoch_loss)\n",
+        "                valid_acc.append(epoch_acc.cpu())\n",
+        "\n",
+        "        print('Epoch {} / {} (train) Loss: {:.4f}, Acc: {:.4f}, (val) Loss: {:.4f}, Acc: {:.4f}'.format(epoch + 1, num_epochs, train_loss[-1], train_acc[-1], valid_loss[-1], valid_acc[-1]))\n",
+        "    return train_loss, train_acc, valid_loss, valid_acc"
+      ],
+      "metadata": {
+        "id": "T-hgB0t7Tf_h"
+      },
+      "execution_count": 27,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torch.nn import functional as F\n",
+        "\n",
+        "class CNN(nn.Module):\n",
+        "    def __init__(self, vocab_size, emb_size, padding_idx, output_size, out_channels, kernel_heights, stride, padding, emb_weights=None):\n",
+        "        super().__init__()\n",
+        "        if emb_weights != None:  # 指定があれば埋め込み層の重みをemb_weightsで初期化\n",
+        "            self.emb = nn.Embedding.from_pretrained(emb_weights, padding_idx=padding_idx)\n",
+        "        else:\n",
+        "            self.emb = nn.Embedding(vocab_size, emb_size, padding_idx=padding_idx)\n",
+        "        self.conv = nn.Conv2d(1, out_channels, (kernel_heights, emb_size), stride, (padding, 0))\n",
+        "        self.drop = nn.Dropout(0.4)\n",
+        "        self.fc = nn.Linear(out_channels, output_size)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        emb = self.emb(x).unsqueeze(1)\n",
+        "        conv = self.conv(emb)\n",
+        "        act = F.relu(conv.squeeze(3))\n",
+        "        max_pool = F.max_pool1d(act, act.size()[2])\n",
+        "        logits = self.fc(self.drop(max_pool.squeeze(2)))\n",
+        "        return logits\n",
+        "\n",
+        "# パラメータの設定\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "PADDING_IDX = len(set(word2id.values())) + 1\n",
+        "OUTPUT_SIZE = 4\n",
+        "OUT_CHANNELS = 100\n",
+        "KERNEL_HEIGHTS = 3\n",
+        "STRIDE = 1\n",
+        "PADDING = 1\n",
+        "\n",
+        "# モデルの定義\n",
+        "model = CNN(VOCAB_SIZE, EMB_SIZE, PADDING_IDX, OUTPUT_SIZE, OUT_CHANNELS, KERNEL_HEIGHTS, STRIDE, PADDING, emb_weights=weights)\n",
+        "x = torch.tensor([tokenizer(sample)], dtype=torch.int64)\n",
+        "print(x)\n",
+        "print(x.size())\n",
+        "print(nn.Softmax(dim=-1)(model(x)))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wWmrRsDCXMxQ",
+        "outputId": "272f7326-e93b-49e9-e690-12824e7737f1"
+      },
+      "execution_count": 30,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  66,   79,  733, 2094,   21, 4933, 6674,   35, 1514,   86,    0]])\n",
+            "torch.Size([1, 11])\n",
+            "tensor([[0.2729, 0.2647, 0.2208, 0.2416]], grad_fn=<SoftmaxBackward0>)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "id": "D3W_cKr_XQdh"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install torchinfo"
+      ],
+      "metadata": {
+        "id": "GJp3iMQQKqVL"
+      },
+      "execution_count": null,
+      "outputs": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/shota/chapter09/knock87.ipynb b/shota/chapter09/knock87.ipynb
new file mode 100644
index 0000000..ef76c35
--- /dev/null
+++ b/shota/chapter09/knock87.ipynb
@@ -0,0 +1,745 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u3LQlfugXBRi",
+        "outputId": "d2b7bd4c-65ce-4b91-f41b-f5d497d16ec3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データ\n",
+            "CATEGORY\n",
+            "b    4502\n",
+            "e    4223\n",
+            "t    1219\n",
+            "m     728\n",
+            "Name: count, dtype: int64\n",
+            "検証データ\n",
+            "CATEGORY\n",
+            "b    562\n",
+            "e    528\n",
+            "t    153\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n",
+            "評価データ\n",
+            "CATEGORY\n",
+            "b    563\n",
+            "e    528\n",
+            "t    152\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "#データの読み込み\n",
+        "import pandas as pd\n",
+        "train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/train.txt', sep=\"\\t\")\n",
+        "test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/test.txt', sep=\"\\t\")\n",
+        "valid = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/valid.txt', sep=\"\\t\")\n",
+        "# データ数の確認\n",
+        "print('学習データ')\n",
+        "print(train['CATEGORY'].value_counts())\n",
+        "print('検証データ')\n",
+        "print(valid['CATEGORY'].value_counts())\n",
+        "print('評価データ')\n",
+        "print(test['CATEGORY'].value_counts())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語の辞書を作成\n",
+        "from collections import Counter\n",
+        "words = []\n",
+        "for text in train['TITLE']:                #訓練データから文章を1つずつ取り出す\n",
+        "    for word in text.rstrip().split():     #文章を単語に分解\n",
+        "        words.append(word)                 #単語をリストに追加\n",
+        "c = Counter(words)                         #単語の出現回数を数える\n",
+        "print(c.most_common(10))                   #頻度上位10単語\n",
+        "word2id = {}                               #単語IDの辞書\n",
+        "for i, cnt in enumerate(c.most_common()):  #頻度上位10単語分繰り返す\n",
+        "    if cnt[1] > 1:                         #出現回数が1より大きい単語のみ\n",
+        "        word2id[cnt[0]] = i + 1            #辞書に単語とIDを紐付ける\n",
+        "for i, cnt in enumerate(word2id.items()):  #辞書の中身を確認\n",
+        "    if i >= 10:                            #10単語だけ表示\n",
+        "        break                              #for文を抜ける\n",
+        "    print(cnt[0], cnt[1])                  #単語とIDを表示"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BaoFH2FcaZcJ",
+        "outputId": "12b687be-da12-42ea-ff91-e1711c2801be"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[('to', 2151), ('...', 2031), ('in', 1415), ('as', 1027), ('on', 1025), ('UPDATE', 1000), ('-', 991), ('for', 969), ('of', 957), ('The', 859)]\n",
+            "to 1\n",
+            "... 2\n",
+            "in 3\n",
+            "as 4\n",
+            "on 5\n",
+            "UPDATE 6\n",
+            "- 7\n",
+            "for 8\n",
+            "of 9\n",
+            "The 10\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語のID化\n",
+        "def tokenizer(text):                                 #単語IDのリストを返す関数\n",
+        "    words = text.rstrip().split()                    #単語に分解\n",
+        "    return [word2id.get(word, 0) for word in words]  #単語のIDに変換\n",
+        "\n",
+        "sample = train.at[0, 'TITLE']                        #学習データの1つ目の文章\n",
+        "print(sample)                                        #文章を表示\n",
+        "print(tokenizer(sample))                             #文章を単語IDに変換"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d-hhnRWjagOZ",
+        "outputId": "22eb39e1-08ad-48d3-987e-65c038720d51"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Justin Bieber Under Investigation For Attempted Robbery At Dave & Buster's\n",
+            "[66, 79, 733, 2094, 21, 4933, 6674, 35, 1514, 86, 0]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# RNNの作成\n",
+        "# モデルの構築\n",
+        "import random\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.utils.data as data\n",
+        "from torchinfo import summary\n",
+        "import numpy as np\n",
+        "\n",
+        "# 乱数のシードを設定\n",
+        "# parserなどで指定\n",
+        "seed = 1234\n",
+        "\n",
+        "random.seed(seed)                                   # Python標準ライブラリの乱数のシードを設定\n",
+        "np.random.seed(seed)                                # Numpy乱数のシードを設定\n",
+        "torch.manual_seed(seed)                             # PyTorch乱数のシードを設定\n",
+        "torch.cuda.manual_seed(seed)                        # PyTorchのCUDA乱数のシードを設定\n",
+        "torch.backends.cudnn.benchmark = False              # PyTorchのCUDNNのベンチマークを使用しない  (cudnn内の非決定的な処理の固定化)\n",
+        "torch.backends.cudnn.deterministic = True           # PyTorchのCUDNNの定着を使用\n",
+        "\n",
+        "def seed_worker(worker_id):\n",
+        "    worker_seed = torch.initial_seed() % 2**32      # 乱数生成のシードの初期値を設定\n",
+        "    np.random.seed(worker_seed)                     # Numpy乱数のシードを設定\n",
+        "    random.seed(worker_seed)                        # Python標準ライブラリの乱数のシードを設定\n",
+        "\n",
+        "g = torch.Generator()                               # PyTorch乱数のシードを設定\n",
+        "g.manual_seed(seed)                                 # 乱数生成器にシードを設定"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HY0GKwcpKlfN",
+        "outputId": "6800f591-1306-4fe9-bfde-568e72762ce1"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<torch._C.Generator at 0x7df746d78d30>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 20
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x = torch.tensor([tokenizer(sample)], dtype=torch.int64)                           # 文章を単語IDに変換\n",
+        "print(x)                                                                           # 文章をIDでを表示\n",
+        "print(x.size())                                                                    # 文章のサイズを確認"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "B-8OkqkTLAXg",
+        "outputId": "49e03136-fe88-47cd-a34e-37ce148eb03a"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  66,   79,  733, 2094,   21, 4933, 6674,   35, 1514,   86,    0]])\n",
+            "torch.Size([1, 11])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ターゲットのテンソル化\n",
+        "category_dict = {'b': 0, 't': 1, 'e':2, 'm':3}\n",
+        "Y_train = torch.from_numpy(train['CATEGORY'].map(category_dict).values)\n",
+        "Y_valid = torch.from_numpy(valid['CATEGORY'].map(category_dict).values)\n",
+        "Y_test = torch.from_numpy(test['CATEGORY'].map(category_dict).values)\n",
+        "print(Y_train.size())\n",
+        "print(Y_train)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IhA2l-VwAsr_",
+        "outputId": "7f4eaf51-d2aa-4157-d525-2c179d99617f"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([10672])\n",
+            "tensor([2, 0, 2,  ..., 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class NewsDataset(data.Dataset):\n",
+        "    \"\"\"\n",
+        "    newsのDatasetクラス\n",
+        "\n",
+        "    Attributes\n",
+        "    ----------------------------\n",
+        "    X : データフレーム\n",
+        "        単語ベクトルの平均をまとめたテンソル\n",
+        "    y : テンソル\n",
+        "        カテゴリをラベル化したテンソル\n",
+        "    phase : 'train' or 'val'\n",
+        "        学習か訓練かを設定する\n",
+        "    \"\"\"\n",
+        "    def __init__(self, X, y, phase='train'):\n",
+        "        self.X = X['TITLE']\n",
+        "        self.y = y\n",
+        "        self.phase = phase\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        \"\"\"全データサイズを返す\"\"\"\n",
+        "        return len(self.y)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        \"\"\"idxに対応するテンソル形式のデータとラベルを取得\"\"\"\n",
+        "        inputs = torch.tensor(tokenizer(self.X[idx]))\n",
+        "        return inputs, self.y[idx]\n",
+        "\n",
+        "train_dataset = NewsDataset(train, Y_train, phase='train')\n",
+        "valid_dataset = NewsDataset(valid, Y_valid, phase='val')\n",
+        "test_dataset = NewsDataset(test, Y_test, phase='val')\n",
+        "# 動作確認\n",
+        "idx = 0\n",
+        "print(train_dataset.__getitem__(idx)[0].size())\n",
+        "print(train_dataset.__getitem__(idx)[1])\n",
+        "print(valid_dataset.__getitem__(idx)[0].size())\n",
+        "print(valid_dataset.__getitem__(idx)[1])\n",
+        "print(test_dataset.__getitem__(idx)[0].size())\n",
+        "print(test_dataset.__getitem__(idx)[1])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qMifdMwaAvji",
+        "outputId": "81a9ba7b-f0c5-4270-addc-b209b3aaf523"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([11])\n",
+            "tensor(2)\n",
+            "torch.Size([11])\n",
+            "tensor(3)\n",
+            "torch.Size([13])\n",
+            "tensor(2)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def collate_fn(batch):\n",
+        "    sequences = [x[0] for x in batch]\n",
+        "    labels = torch.LongTensor([x[1] for x in batch])\n",
+        "    x = torch.nn.utils.rnn.pad_sequence(sequences, batch_first=True, padding_value=PADDING_IDX)\n",
+        "    return x, labels\n",
+        "\n",
+        "# DataLoaderを作成\n",
+        "batch_size = 64\n",
+        "\n",
+        "train_dataloader = data.DataLoader(\n",
+        "            train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "valid_dataloader = data.DataLoader(\n",
+        "            valid_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "test_dataloader = data.DataLoader(\n",
+        "            test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "\n",
+        "dataloaders_dict = {'train': train_dataloader,\n",
+        "                    'val': valid_dataloader,\n",
+        "                    'test': test_dataloader,\n",
+        "                   }\n",
+        "\n",
+        "# 動作確認\n",
+        "batch_iter = iter(dataloaders_dict['train'])\n",
+        "inputs, labels = next(batch_iter)\n",
+        "print(inputs)\n",
+        "print(labels)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xRSh5D22Axsg",
+        "outputId": "2ef056d9-2c38-4f53-c486-8e50ec595c8d"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[ 1136,   890,    22,  ..., 10327, 10327, 10327],\n",
+            "        [ 9241,   853,  8128,  ..., 10327, 10327, 10327],\n",
+            "        [  211,  1843,   104,  ..., 10327, 10327, 10327],\n",
+            "        ...,\n",
+            "        [ 2886,  4097,  5178,  ..., 10327, 10327, 10327],\n",
+            "        [ 2595,    40,  8576,  ..., 10327, 10327, 10327],\n",
+            "        [    6,     0,  3373,  ..., 10327, 10327, 10327]])\n",
+            "tensor([2, 2, 0, 0, 2, 1, 0, 0, 2, 1, 1, 1, 0, 2, 0, 0, 0, 0, 1, 2, 2, 2, 0, 1,\n",
+            "        0, 0, 1, 2, 1, 2, 2, 0, 2, 2, 2, 0, 0, 2, 0, 0, 0, 3, 2, 3, 1, 2, 0, 2,\n",
+            "        0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from gensim.models import KeyedVectors\n",
+        "\n",
+        "# 学習済みモデルのロード\n",
+        "file = '/content/drive/MyDrive/Colab Notebooks/chapter09/GoogleNews-vectors-negative300.bin.gz'\n",
+        "model = KeyedVectors.load_word2vec_format(file, binary=True)\n",
+        "\n",
+        "# 学習済み単語ベクトルの取得\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "weights = np.zeros((VOCAB_SIZE, EMB_SIZE))\n",
+        "words_in_pretrained = 0\n",
+        "for i, word in enumerate(word2id.keys()):\n",
+        "    try:\n",
+        "        weights[i] = model[word]\n",
+        "        words_in_pretrained += 1\n",
+        "    except KeyError:\n",
+        "        weights[i] = np.random.normal(scale=0.1, size=(EMB_SIZE,))\n",
+        "weights = torch.from_numpy(weights.astype((np.float32)))\n",
+        "\n",
+        "print(f'学習済みベクトル利用単語数: {words_in_pretrained} / {VOCAB_SIZE}')\n",
+        "print(weights.size())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zLn_cZ71QGqD",
+        "outputId": "29eba55b-a1c1-4879-88c7-2e6005d674ed"
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習済みベクトル利用単語数: 8340 / 10328\n",
+            "torch.Size([10328, 300])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def calc_acc(net, dataloader):\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    net.eval()\n",
+        "    corrects = 0\n",
+        "    with torch.no_grad():\n",
+        "        for inputs, labels in dataloader:\n",
+        "            inputs = inputs.to(device)\n",
+        "            labels = labels.to(device)\n",
+        "            outputs = net(inputs)\n",
+        "            _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "            corrects += torch.sum(preds == labels.data).cpu()\n",
+        "    return corrects / len(dataloader.dataset)"
+      ],
+      "metadata": {
+        "id": "orK8m3eSRY11"
+      },
+      "execution_count": 26,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 学習を実行する\n",
+        "# 学習用の関数を定義\n",
+        "def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):\n",
+        "\n",
+        "    # 初期設定\n",
+        "    # GPUが使えるか確認\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    print(torch.cuda.get_device_name())\n",
+        "    print(\"使用デバイス:\", device)\n",
+        "\n",
+        "    # ネットワークをgpuへ\n",
+        "    net.to(device)\n",
+        "\n",
+        "    train_loss = []\n",
+        "    train_acc = []\n",
+        "    valid_loss = []\n",
+        "    valid_acc = []\n",
+        "\n",
+        "    # epochのループ\n",
+        "    for epoch in range(num_epochs):\n",
+        "        # epochごとの学習と検証のループ\n",
+        "        for phase in ['train', 'val']:\n",
+        "            if phase == 'train':\n",
+        "                net.train() # 訓練モード\n",
+        "            else:\n",
+        "                net.eval() # 検証モード\n",
+        "\n",
+        "            epoch_loss = 0.0 # epochの損失和\n",
+        "            epoch_corrects = 0 # epochの正解数\n",
+        "\n",
+        "            # データローダーからミニバッチを取り出すループ\n",
+        "            for inputs, labels in dataloaders_dict[phase]:\n",
+        "                # GPUが使えるならGPUにおっくる\n",
+        "                inputs = inputs.to(device)\n",
+        "                labels = labels.to(device)\n",
+        "                optimizer.zero_grad() # optimizerを初期化\n",
+        "\n",
+        "                # 順伝播計算(forward)\n",
+        "                with torch.set_grad_enabled(phase == 'train'):\n",
+        "                    outputs = net(inputs)\n",
+        "                    loss = criterion(outputs, labels) # 損失を計算\n",
+        "                    _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "\n",
+        "                    # 訓練時は逆伝播\n",
+        "                    if phase == 'train':\n",
+        "                        loss.backward()\n",
+        "                        optimizer.step()\n",
+        "\n",
+        "                    # イテレーション結果の計算\n",
+        "                    # lossの合計を更新\n",
+        "                    epoch_loss += loss.item() * inputs.size(0)\n",
+        "                    # 正解数の合計を更新\n",
+        "                    epoch_corrects += torch.sum(preds == labels.data)\n",
+        "\n",
+        "            # epochごとのlossと正解率の表示\n",
+        "            epoch_loss = epoch_loss / len(dataloaders_dict[phase].dataset)\n",
+        "            epoch_acc = epoch_corrects.double() / len(dataloaders_dict[phase].dataset)\n",
+        "            if phase == 'train':\n",
+        "                train_loss.append(epoch_loss)\n",
+        "                train_acc.append(epoch_acc.cpu())\n",
+        "            else:\n",
+        "                valid_loss.append(epoch_loss)\n",
+        "                valid_acc.append(epoch_acc.cpu())\n",
+        "\n",
+        "        print('Epoch {} / {} (train) Loss: {:.4f}, Acc: {:.4f}, (val) Loss: {:.4f}, Acc: {:.4f}'.format(epoch + 1, num_epochs, train_loss[-1], train_acc[-1], valid_loss[-1], valid_acc[-1]))\n",
+        "    return train_loss, train_acc, valid_loss, valid_acc"
+      ],
+      "metadata": {
+        "id": "T-hgB0t7Tf_h"
+      },
+      "execution_count": 27,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from torch.nn import functional as F\n",
+        "\n",
+        "class CNN(nn.Module):\n",
+        "    def __init__(self, vocab_size, emb_size, padding_idx, output_size, out_channels, kernel_heights, stride, padding, emb_weights=None):\n",
+        "        super().__init__()\n",
+        "        if emb_weights != None:  # 指定があれば埋め込み層の重みをemb_weightsで初期化\n",
+        "            self.emb = nn.Embedding.from_pretrained(emb_weights, padding_idx=padding_idx)\n",
+        "        else:\n",
+        "            self.emb = nn.Embedding(vocab_size, emb_size, padding_idx=padding_idx)\n",
+        "        self.conv = nn.Conv2d(1, out_channels, (kernel_heights, emb_size), stride, (padding, 0))\n",
+        "        self.drop = nn.Dropout(0.4)\n",
+        "        self.fc = nn.Linear(out_channels, output_size)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        emb = self.emb(x).unsqueeze(1)\n",
+        "        conv = self.conv(emb)\n",
+        "        act = F.relu(conv.squeeze(3))\n",
+        "        max_pool = F.max_pool1d(act, act.size()[2])\n",
+        "        logits = self.fc(self.drop(max_pool.squeeze(2)))\n",
+        "        return logits\n",
+        "\n",
+        "# パラメータの設定\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "PADDING_IDX = len(set(word2id.values())) + 1\n",
+        "OUTPUT_SIZE = 4\n",
+        "OUT_CHANNELS = 100\n",
+        "KERNEL_HEIGHTS = 3\n",
+        "STRIDE = 1\n",
+        "PADDING = 1\n",
+        "\n",
+        "# モデルの定義\n",
+        "model = CNN(VOCAB_SIZE, EMB_SIZE, PADDING_IDX, OUTPUT_SIZE, OUT_CHANNELS, KERNEL_HEIGHTS, STRIDE, PADDING, emb_weights=weights)\n",
+        "x = torch.tensor([tokenizer(sample)], dtype=torch.int64)\n",
+        "print(x)\n",
+        "print(x.size())\n",
+        "print(nn.Softmax(dim=-1)(model(x)))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wWmrRsDCXMxQ",
+        "outputId": "272f7326-e93b-49e9-e690-12824e7737f1"
+      },
+      "execution_count": 30,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  66,   79,  733, 2094,   21, 4933, 6674,   35, 1514,   86,    0]])\n",
+            "torch.Size([1, 11])\n",
+            "tensor([[0.2729, 0.2647, 0.2208, 0.2416]], grad_fn=<SoftmaxBackward0>)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# モデルの定義\n",
+        "net = CNN(VOCAB_SIZE, EMB_SIZE, PADDING_IDX, OUTPUT_SIZE, OUT_CHANNELS, KERNEL_HEIGHTS, STRIDE, PADDING, emb_weights=weights)\n",
+        "net.train()\n",
+        "\n",
+        "# 損失関数の定義\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "\n",
+        "# 最適化手法の定義\n",
+        "optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)\n",
+        "\n",
+        "num_epochs = 30\n",
+        "train_loss, train_acc, valid_loss, valid_acc = train_model(net,\n",
+        "            dataloaders_dict, criterion, optimizer, num_epochs=num_epochs)\n",
+        "\n",
+        "import matplotlib.pyplot as plt\n",
+        "fig, ax = plt.subplots(1,2, figsize=(10, 5))\n",
+        "epochs = np.arange(num_epochs)\n",
+        "ax[0].plot(epochs, train_loss, label='train')\n",
+        "ax[0].plot(epochs, valid_loss, label='valid')\n",
+        "ax[0].set_title('loss')\n",
+        "ax[0].set_xlabel('epoch')\n",
+        "ax[0].set_ylabel('loss')\n",
+        "ax[1].plot(epochs, train_acc, label='train')\n",
+        "ax[1].plot(epochs, valid_acc, label='valid')\n",
+        "ax[1].set_title('acc')\n",
+        "ax[1].set_xlabel('epoch')\n",
+        "ax[1].set_ylabel('acc')\n",
+        "ax[0].legend(loc='best')\n",
+        "ax[1].legend(loc='best')\n",
+        "plt.tight_layout()\n",
+        "plt.savefig('fig87.png')\n",
+        "plt.show()\n",
+        "\n",
+        "acc_train = calc_acc(net, train_dataloader)\n",
+        "acc_valid = calc_acc(net, valid_dataloader)\n",
+        "acc_test = calc_acc(net, test_dataloader)\n",
+        "print('学習データの正解率: {:.4f}'.format(acc_train))\n",
+        "print('検証データの正解率: {:.4f}'.format(acc_valid))\n",
+        "print('テストデータの正解率: {:.4f}'.format(acc_test))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 1000
+        },
+        "id": "YeQl8S9uaYra",
+        "outputId": "8e90e0e7-ef5a-4e31-f02e-591db45c9ab2"
+      },
+      "execution_count": 33,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Tesla T4\n",
+            "使用デバイス: cuda:0\n",
+            "Epoch 1 / 30 (train) Loss: 0.9699, Acc: 0.6132, (val) Loss: 0.7548, Acc: 0.7181\n",
+            "Epoch 2 / 30 (train) Loss: 0.6942, Acc: 0.7453, (val) Loss: 0.6485, Acc: 0.7699\n",
+            "Epoch 3 / 30 (train) Loss: 0.5403, Acc: 0.7974, (val) Loss: 0.5795, Acc: 0.7969\n",
+            "Epoch 4 / 30 (train) Loss: 0.4324, Acc: 0.8425, (val) Loss: 0.5405, Acc: 0.8043\n",
+            "Epoch 5 / 30 (train) Loss: 0.3512, Acc: 0.8739, (val) Loss: 0.5337, Acc: 0.8073\n",
+            "Epoch 6 / 30 (train) Loss: 0.2864, Acc: 0.8986, (val) Loss: 0.5201, Acc: 0.8148\n",
+            "Epoch 7 / 30 (train) Loss: 0.2615, Acc: 0.9084, (val) Loss: 0.5422, Acc: 0.8133\n",
+            "Epoch 8 / 30 (train) Loss: 0.2264, Acc: 0.9197, (val) Loss: 0.5515, Acc: 0.8141\n",
+            "Epoch 9 / 30 (train) Loss: 0.1831, Acc: 0.9343, (val) Loss: 0.5731, Acc: 0.8043\n",
+            "Epoch 10 / 30 (train) Loss: 0.1777, Acc: 0.9383, (val) Loss: 0.5723, Acc: 0.8103\n",
+            "Epoch 11 / 30 (train) Loss: 0.1577, Acc: 0.9444, (val) Loss: 0.5900, Acc: 0.8208\n",
+            "Epoch 12 / 30 (train) Loss: 0.1393, Acc: 0.9509, (val) Loss: 0.5838, Acc: 0.8238\n",
+            "Epoch 13 / 30 (train) Loss: 0.1485, Acc: 0.9488, (val) Loss: 0.6028, Acc: 0.8208\n",
+            "Epoch 14 / 30 (train) Loss: 0.1363, Acc: 0.9544, (val) Loss: 0.6228, Acc: 0.8178\n",
+            "Epoch 15 / 30 (train) Loss: 0.1179, Acc: 0.9581, (val) Loss: 0.6175, Acc: 0.8268\n",
+            "Epoch 16 / 30 (train) Loss: 0.1099, Acc: 0.9593, (val) Loss: 0.6285, Acc: 0.8216\n",
+            "Epoch 17 / 30 (train) Loss: 0.1064, Acc: 0.9622, (val) Loss: 0.6401, Acc: 0.8313\n",
+            "Epoch 18 / 30 (train) Loss: 0.1068, Acc: 0.9650, (val) Loss: 0.6614, Acc: 0.8276\n",
+            "Epoch 19 / 30 (train) Loss: 0.0943, Acc: 0.9680, (val) Loss: 0.6525, Acc: 0.8306\n",
+            "Epoch 20 / 30 (train) Loss: 0.0933, Acc: 0.9686, (val) Loss: 0.6781, Acc: 0.8276\n",
+            "Epoch 21 / 30 (train) Loss: 0.0828, Acc: 0.9709, (val) Loss: 0.6675, Acc: 0.8223\n",
+            "Epoch 22 / 30 (train) Loss: 0.0942, Acc: 0.9686, (val) Loss: 0.6967, Acc: 0.8208\n",
+            "Epoch 23 / 30 (train) Loss: 0.0848, Acc: 0.9711, (val) Loss: 0.7376, Acc: 0.8268\n",
+            "Epoch 24 / 30 (train) Loss: 0.0811, Acc: 0.9739, (val) Loss: 0.6773, Acc: 0.8231\n",
+            "Epoch 25 / 30 (train) Loss: 0.0750, Acc: 0.9743, (val) Loss: 0.6629, Acc: 0.8253\n",
+            "Epoch 26 / 30 (train) Loss: 0.0745, Acc: 0.9754, (val) Loss: 0.7008, Acc: 0.8328\n",
+            "Epoch 27 / 30 (train) Loss: 0.0715, Acc: 0.9765, (val) Loss: 0.7122, Acc: 0.8216\n",
+            "Epoch 28 / 30 (train) Loss: 0.0681, Acc: 0.9769, (val) Loss: 0.7220, Acc: 0.8253\n",
+            "Epoch 29 / 30 (train) Loss: 0.0656, Acc: 0.9776, (val) Loss: 0.7630, Acc: 0.8238\n",
+            "Epoch 30 / 30 (train) Loss: 0.0717, Acc: 0.9751, (val) Loss: 0.6984, Acc: 0.8321\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 2 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAHqCAYAAAAZLi26AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtDklEQVR4nOzdd3hUZdrH8e9MekgD0kihQ+ihKBEEBQVRFMWKoILY1oKuZl1XFPur7FoQXVFcFXvBghVFAQFFmoJ0CJ0USAPS+8y8f5wUIgFSJjkpv891zZWZM2fO3BOGzNzneZ77tjgcDgciIiIiIiIi4nRWswMQERERERERaa6UdIuIiIiIiIjUEyXdIiIiIiIiIvVESbeIiIiIiIhIPVHSLSIiIiIiIlJPlHSLiIiIiIiI1BMl3SIiIiIiIiL1REm3iIiIiIiISD1R0i0iIiIiIiJST5R0i7Rg77zzDhaLhQMHDpgdioiIiIhIs6SkW0RERERERKSeKOkWERERERERqSdKukVERERERETqiZJuEank1VdfpXfv3nh4eBAWFsZdd91FRkZGpX12797NlVdeSWhoKJ6enkRERHDttdeSmZlZvs/ixYsZNmwYAQEB+Pj4EBUVxUMPPdTAr0ZERKT5OnjwIHfeeSdRUVF4eXnRtm1brr766iprtWRkZHDffffRsWNHPDw8iIiIYPLkyaSnp5fvU1BQwOOPP0737t3x9PSkXbt2XHHFFezdu7cBX5VI8+NqdgAi0ng8/vjjPPHEE4waNYo77riDuLg4XnvtNX7//Xd+++033NzcKCoqYsyYMRQWFnL33XcTGhpKUlIS3333HRkZGfj7+7Nt2zYuueQS+vXrx5NPPomHhwd79uzht99+M/slioiINBu///47q1at4tprryUiIoIDBw7w2muvMWLECLZv3463tzcAOTk5DB8+nB07dnDTTTcxcOBA0tPT+eabb0hMTCQwMBCbzcYll1zC0qVLufbaa/n73/9OdnY2ixcvZuvWrXTp0sXkVyvSdFkcDofD7CBExBzvvPMOU6dOZf/+/bRq1YqIiAhGjBjBDz/8gNVqTISZM2cO06ZNY968eUydOpWNGzcyYMAAPvvsM6666qoqjzt79mzuu+8+0tLSCAwMbMiXJCIi0mLk5+fj5eVVaduaNWsYMmQI7733HjfccAMAjz32GE8++SQLFizg8ssvr7S/w+HAYrHw9ttvc9NNNzFr1izuu+++KvcRkdrR9HIRAWDJkiUUFRVx7733lifcALfeeit+fn4sXLgQAH9/fwB+/PFH8vLyqjxWQEAAAF9//TV2u71+AxcREWmhjk+4i4uLOXLkCF27diUgIIANGzaU3/fFF18QHR19QsINlCfTX3zxBYGBgdx9990n3UdEakdJt4gAxrowgKioqErb3d3d6dy5c/n9nTp1IjY2ljfffJPAwEDGjBnDnDlzKq3nnjBhAmeffTa33HILISEhXHvttXz66adKwEVERJwoPz+fRx99lMjISDw8PAgMDCQoKIiMjIxKn8t79+6lT58+pzzW3r17iYqKwtVVq09FnE1Jt4jU2AsvvMDmzZt56KGHyM/P55577qF3794kJiYCxpn3X375hSVLlnDDDTewefNmJkyYwOjRo7HZbCZHLyIi0jzcfffdPP3001xzzTV8+umn/PTTTyxevJi2bdvqRLdII6KkW0QA6NChAwBxcXGVthcVFbF///7y+8v07duXGTNm8Msvv/Drr7+SlJTE3Llzy++3Wq2cf/75zJo1i+3bt/P000/z888/s2zZsvp/MSIiIi3A559/zpQpU3jhhRe46qqrGD16NMOGDTuh60iXLl3YunXrKY/VpUsX4uLiKC4urseIRVomJd0iAsCoUaNwd3fn5Zdf5vj6im+99RaZmZlcfPHFAGRlZVFSUlLpsX379sVqtVJYWAjA0aNHTzh+//79Acr3ERERkbpxcXHhrzWR//vf/54wq+zKK69k06ZNfPnllycco+zxV155Jenp6bzyyisn3UdEakeLNkQEgKCgIKZPn84TTzzBhRdeyKWXXkpcXByvvvoqZ555Jtdffz0AP//8M9OmTePqq6+me/fulJSU8P777+Pi4sKVV14JwJNPPskvv/zCxRdfTIcOHUhNTeXVV18lIiKCYcOGmfkyRUREmo1LLrmE999/H39/f3r16sXq1atZsmQJbdu2rbTfP//5Tz7//HOuvvpqbrrpJgYNGsTRo0f55ptvmDt3LtHR0UyePJn33nuP2NhY1q1bx/Dhw8nNzWXJkiXceeedXHbZZSa9SpGmT0m3iJR7/PHHCQoK4pVXXuG+++6jTZs23HbbbTzzzDO4ubkBEB0dzZgxY/j2229JSkrC29ub6OhofvjhB8466ywALr30Ug4cOMC8efNIT08nMDCQc889lyeeeKK8+rmIiIjUzUsvvYSLiwsffvghBQUFnH322SxZsoQxY8ZU2s/Hx4dff/2Vxx57jC+//JJ3332X4OBgzj//fCIiIgBj1Pz777/n6aef5qOPPuKLL76gbdu2DBs2jL59+5rx8kSaDfXpFhEREREREaknWtMtIiIiIiIiUk+UdIuIiIiIiIjUEyXdIiIiIiIiIvVESbeIiIiIiIhIPVHSLSIiIiIiIlJPlHSLiIiIiIiI1JMW16fbbrdz6NAhfH19sVgsZocjIiItjMPhIDs7m7CwMKxWnfuuCX2Gi4iImWr7Gd7iku5Dhw4RGRlpdhgiItLCJSQkEBERYXYYTYo+w0VEpDGo6Wd4i0u6fX19AeMX5efnZ3I0IiLS0mRlZREZGVn+eSTVp89wERExU20/w01Nun/55Reee+451q9fz+HDh/nyyy8ZP378KR+zfPlyYmNj2bZtG5GRkcyYMYMbb7yx2s9ZNh3Nz89PH9giImIaTY+uOX2Gi4hIY1DTz3BTF5Pl5uYSHR3NnDlzqrX//v37ufjiixk5ciQbN27k3nvv5ZZbbuHHH3+s50hFREREREREas7Uke6LLrqIiy66qNr7z507l06dOvHCCy8A0LNnT1auXMmLL77ImDFj6itMERERERERkVppUmVTV69ezahRoyptGzNmDKtXrz7pYwoLC8nKyqp0EREREREREWkITaqQWnJyMiEhIZW2hYSEkJWVRX5+Pl5eXic8ZubMmTzxxBMNFaKISLNgs9koLi42O4wmy93dXe3ATKT3b924ubnh4uJidhgiIs1Gk0q6a2P69OnExsaW3y6rOCciIidyOBwkJyeTkZFhdihNmtVqpVOnTri7u5sdSoui96/zBAQEEBoaqoJ/IiJO0KSS7tDQUFJSUiptS0lJwc/Pr8pRbgAPDw88PDwaIjwRkSavLGEJDg7G29tbX7hrwW63c+jQIQ4fPkz79u31O2xAev/WncPhIC8vj9TUVADatWtnckQiIk1fk0q6hwwZwvfff19p2+LFixkyZIhJEYmINB82m608YWnbtq3Z4TRpQUFBHDp0iJKSEtzc3MwOp0XQ+9d5ygYyUlNTCQ4O1lRzEZE6MnXBWU5ODhs3bmTjxo2A0RJs48aNxMfHA8bU8MmTJ5fvf/vtt7Nv3z4eeOABdu7cyauvvsqnn37KfffdZ0b4IiLNStkaWG9vb5MjafrKppXbbDaTI2k59P51rrLfo9bGi4jUnalJ9x9//MGAAQMYMGAAALGxsQwYMIBHH30UgMOHD5cn4ACdOnVi4cKFLF68mOjoaF544QXefPNNtQsTEXEiTcmtO/0OzaPfvXPo9ygi4jymTi8fMWIEDofjpPe/8847VT7mzz//rMeoRERERERERJxD/UxERESO07FjR2bPnm12GCK1oveviEjj06QKqYmIiFRlxIgR9O/f3ynJxu+//06rVq3qHpRINen9KyLSvCnpFhGRZs/hcGCz2XB1Pf3HXlBQUANEJFJ9ev+KiDRtml4uIiJN2o033siKFSt46aWXsFgsWCwW3nnnHSwWCz/88AODBg3Cw8ODlStXsnfvXi677DJCQkLw8fHhzDPPZMmSJZWO99fpuRaLhTfffJPLL78cb29vunXrxjfffNPAr1KaK71/RUSaPyXddbAh/hgLNiSSmlVgdigiIk7ncDjIKyox5XKqIpt/9dJLLzFkyBBuvfVWDh8+zOHDh4mMjATgwQcf5N///jc7duygX79+5OTkMHbsWJYuXcqff/7JhRdeyLhx4yp1yqjKE088wTXXXMPmzZsZO3Ys1113HUePHq3T71fqn1nvYb1/RUTqzmZ3kJlXTMLRPHYczmLd/qMs3ZHCyt3pHMkpNDu8GtH08jp47OttbEnK5I3JZzC6l6fZ4YiIOFV+sY1ej/5oynNvf3IM3u7V+4jy9/fH3d0db29vQkNDAdi5cycATz75JKNHjy7ft02bNkRHR5fffuqpp/jyyy/55ptvmDZt2kmf48Ybb2TixIkAPPPMM7z88susW7eOCy+8sMavTRqOWe9hvX9FpKWw2x1k5BdzJKeQnMISikrsFNnsFBaX/iyxGdtK7BQedynblldUQnZBCdmFJWQXFBvXC4rJKSght8h2yucO8/ekd7g/fcL86RPuR59wf4J9PRply0Ml3XUQFuDJlqRMDmXkmx2KiIhU4Ywzzqh0Oycnh8cff5yFCxdy+PBhSkpKyM/PP+1IYb9+/cqvt2rVCj8/P1JTU+slZpEyev+KiBnyi2yk5xRyJLeIIzmFpOcUkp5TxJGcIo7kFnIkp6h827G8Imz26s/uqQ0PVyu+nm74erri6+lKdkEJ+9NzOZRZwKHMAhZvTynfN9DHnd5lSXiYP33C/Ylo7WV6Iq6kuw7CArwAlHSLSLPk5ebC9ifHmPbczvDXKs73338/ixcv5vnnn6dr1654eXlx1VVXUVRUdMrjuLm5VbptsViw2+1OiVHqj1nvYb1/RaSxKLHZycgv5mhuEUdziziWW8SR0p9H84oqtucVcTTH2FZQXPO/D36ervh6uuHhZsXdxYqHqxUPVxfcXY3r7qUXj/Kfxn3ebi74erric1xS7efpho+Ha+ltN9xdT1wRnV1QzI7D2WxNymTroUy2JWWxOzWb9JwiVuxKY8WutEqx9Qn3577R3TmzY5s6/T5rS0l3HYSXJd2ZWtMtIs2PxWKp9hRZs7m7u2OznXoaGsBvv/3GjTfeyOWXXw4YI4cHDhyo5+jELE3lPaz3r4icjMPhIP5oHpsSM9lxOIvsgmIKiu0UFNsoKDamb+cX2SgosVXeXmwjv9hGSS1Hod1drQT5eNDWx51AHw/atnKnrY8HgT7utPVxp22rivtae7tXmRjXJ19PNwZ3asPgThVJdH6RjZ3JWWw9lMX2Q5lsTcoiLjmbrIISVu09QuzoUxywnjX+T6JGTCPdIiKNQ8eOHVm7di0HDhzAx8fnpKN43bp1Y8GCBYwbNw6LxcIjjzyiET8xnd6/IlImLbuQTQkZbE7MYGNiJpsTM8jIK67TMS0WCPByo3Urd9q2cqe1tzttWlVcWnu708bHnTal21u3cqeVu4vpU7JrysvdhQHtWzOgfevybUUldnanZrMtKYteYX6mxaakuw6UdIuINA73338/U6ZMoVevXuTn5/P2229Xud+sWbO46aabGDp0KIGBgfzrX/8iKyurgaMVqUzvX5GWKbugmC1JmWxKMJLrTQkZVc6gdXex0jPMj77hfrTxdsfT3QVPVxc83VzwcreWX/dws+LlZlz3dHMpvW6sh3axNq0E2lncXa30DvOnd5i/qXFYHDXpa9EMZGVl4e/vT2ZmJn5+dTvbkZpdwOCnl2K1QNz/XYSbizqwiUjTVVBQwP79++nUqROenurIUBen+l0683OopTnV707vX+fS71Naksz8YnanZLMzOZuMvCK6BPnQPdSXjm1bOS1ZzSooZvuhLLYmZbLtUBZbkjLZm5bDXzMxiwW6BvkQHRlAdIQ/0ZEBRIX64uHqnFoRUje1/QzXSHcdBLbywN3FSpHNTkpWARGtvc0OSUREREREqlBQbGNPag5xydnsSskmLiWbuORsDp+kPpOHq5WuwT5EhfgSFepL91BfokJ8aefvecqp10dyCtl2KKu8wNfWQ5kcPJJX5b7hAV5ER/oTHRFAv4gA+kb44+OhFK250b9oHVitFtoFeHLwSB6HMpR0i4iIiIiYodhmJ7ewhJzCEnILbeQUlpCSVVCRYCdnc+BILierKxbm70n3UF/aeLuzNy2HXSk55Bfb2HYoi22HKi/j8PV0JSqkIgkP9vVgV0pOaZKdedIiy+EBXvQJ9ytvadU3PIAgXw9n/yqkEVLSXUdh/l6lSbfWdYuIiIiIOEtWQTEb4zPYEH+MpGP55BaVkFNoI7ew5LgE20iyi2zVKyrY2tuNqNJkuftxP/08K7fWs9sdJBzLIy7ZSNjjUozkfV9aLtkFJfxx8Bh/HDx20ufpFNiK3mF+9An3p0+YP73D/Gjdyr1Ovw9pupR011FZMbUkJd0iIiIiIrXicDjYm5bLhvhj/Bl/jA0HM9iVmn3CmufT8XC14uPhSisPV1q3cicqxIfuIb70CPWje6gPQT4e1arKbbVa6NC2FR3atuKC3qHl2wtLbOxPzy1PxnelZJOaXUjXYB/6hPnTJ9yfnu188f1LEi8tm5LuOgoPMIqLaKRbRERERKR6cgpL2JSQwYaDx9gQf4wN8Rlk5p/YGiuyjRcD27eme4hveTLt4+FCq/LrpT/dXfH2cKn3wsYeri70CPWjR6gKYUr1KemuI7UNExERERE5Obvdwb70HP6Mz2BjQgYb4jOIS846YX21h6uVfhH+DOzQmoHtWzOgfQDBvqqeL02fku46qki6qy6YICIiIiLSkhzNLWJjwjE2xmfwZ4KRaGcXlJywX3iAV2mCHcDA9q3p2c4Pd1e14JXmR0l3HYVpermIiIiItFBFJXa2H85iY/yx8gS7qvZYnm5W+oUH0L99AAMiAxjYoTUhfhrFlpZBSXcdtfM3RrqzC0vIKig+ofKhiIiIiEhzkZxZwIb4Y6wvXYu9LSmrysrhXYJa0T+ydXmSHRXqW+/rrUUaKyXdddTKw5UAbzcy8oo5lJGPX6iSbhGRpqZjx47ce++93HvvvQBYLBa+/PJLxo8fX+X+Bw4coFOnTvz555/079+/weIUqYrev1JfykaxyxLsPw8eq7IHdWtvN/pHBtA/0liHHR0RgL+3vhOLlFHS7QRh/l7lSbcqGYqINH2HDx+mdevWZochUit6/0ptpWYXsOFgBn+WjmRvScqksKTyKLbVAj1C/RjYIYBBHVozILI1Hdp6V6sNl0hLpaTbCcICvNh+OEvF1EREmonQ0NDT7yTSSOn9K39VUGwjLbuQ1OxC0rILScsp/Xnc7ZTMApKzTvwuG+DtxsD2rY0Eu3QUu5WHUgiRmtD/GCdQr24REfP873//4/HHHycxMRGrtWK94GWXXUbbtm15+OGHiY2NZc2aNeTm5tKzZ09mzpzJqFGjTnrMv07PXbduHX/729/YsWMHffr04eGHH67vlyUthN6/4kwpWQWsiEtj1d50DmUWkF6aVGcXnlg5vCoWC0SF+DKgNMke2D6AToGtNIotUkdKup1AvbpFpFlyOKD4xAq0DcLN2/j2Vw1XX301d999N8uWLeP8888H4OjRoyxatIjvv/+enJwcxo4dy9NPP42Hhwfvvfce48aNIy4ujvbt25/2+Dk5OVxyySWMHj2aDz74gP379/P3v/+9Ti9PGohZ72G9f6WBlNjsbEzIYFlcKst2prH9cNZJ93V3tRLs60GQrwdBPqU//3K7a7APvioKLOJ0SrqdQL26RaRZKs6DZ8LMee6HDoF7q2rt2rp1ay666CI++uij8qTl888/JzAwkJEjR2K1WomOji7f/6mnnuLLL7/km2++Ydq0aac9/kcffYTdbuett97C09OT3r17k5iYyB133FG71yYNx6z3sN6/Uo/Scwr5ZVcay+LS+GVXGpn5xeX3WSzQL9yfc6OC6RbsUymx9vVw1Yi1iEmUdDtBWdKdpJFuERFTXHfdddx66628+uqreHh48OGHH3LttdditVrJycnh8ccfZ+HChRw+fJiSkhLy8/OJj4+v1rF37NhBv3798PSs6Cc7ZMiQ+nop0gLp/SunYrc72JyUybKdqSyPS2VzUiYOR8X9/l5unNM9iJFRQZzTPYhAHw/zghWRKinpdoLw0qQ7OasAm92Bi1VnEUWkGXDzNkbszHruGhg3bhwOh4OFCxdy5pln8uuvv/Liiy8CcP/997N48WKef/55unbtipeXF1dddRVFRUX1Ebk0Jma9h/X+FSdIOJrHB2sO8sWGRNJzKv979w7zY0RUECOjgukfGYCr+l+LNGpKup0gyNcDV6uFEruD1OwC2vl7mR2SiEjdWSzVniJrNk9PT6644go+/PBD9uzZQ1RUFAMHDgTgt99+48Ybb+Tyyy8HjDWuBw4cqPaxe/bsyfvvv09BQUH5aOGaNWuc/hoaozlz5vDcc8+RnJxMdHQ0//3vfxk8eHCV+xYXFzNz5kzeffddkpKSiIqK4j//+Q8XXnhh+T6PP/44TzzxRKXHRUVFsXPnzvp5AU3kPaz3r5RxOBz8tucI76w6wNKdKeUj2j4ergzvFsjIqGDOjQoixM/z1AcSkUZFSbcTuFgthPp7kngsn0MZ+Uq6RURMcN1113HJJZewbds2rr/++vLt3bp1Y8GCBYwbNw6LxcIjjzyC3W4/xZEqmzRpEg8//DC33nor06dP58CBAzz//PP18RIalfnz5xMbG8vcuXOJiYlh9uzZjBkzhri4OIKDg0/Yf8aMGXzwwQe88cYb9OjRgx9//JHLL7+cVatWMWDAgPL9evfuzZIlS8pvu7rqqwjo/dvS5RaWsGBDIu+uPsie1Jzy7cO7BTJ5SEdGRAXhptFskSZL/3udpGJdt4qpiYiY4bzzzqNNmzbExcUxadKk8u2zZs2idevWDB06lHHjxjFmzJjyUcTq8PHx4dtvv2XLli0MGDCAhx9+mP/85z/18RIalVmzZnHrrbcydepUevXqxdy5c/H29mbevHlV7v/+++/z0EMPMXbsWDp37swdd9zB2LFjeeGFFyrt5+rqSmhoaPklMDCwIV5Oo6f3b9OSeCyP7zYf4s/4Y2QVFJ/+ASexPz2XJ77dxlnPLOWRr7exJzWHVu4uTB7SgSWx5/L+zTGM7hWihFukidPpZScJV9swERFTWa1WDh06cf1ux44d+fnnnyttu+uuuyrd/ut0XcfxVYqAs846i40bN55yn+akqKiI9evXM3369PJtVquVUaNGsXr16iofU1hYWKlYF4CXlxcrV66stG337t2EhYXh6enJkCFDmDlzZrVaXzV3ev82DfFH8pizbA9fbEikxF7xOwwubbfVJciHrsE+5ddD/DxOqBhutztYsTuNd1cdYHlcWvn2ToGtmDykA1cNilDbLpFmRkm3k4QFGF80lHSLiEhTl56ejs1mIyQkpNL2kJCQk66/HjNmDLNmzeKcc86hS5cuLF26lAULFmCz2cr3iYmJ4Z133iEqKorDhw/zxBNPMHz4cLZu3Yqvr+8JxywsLKSwsLD8dlbWyXsQi9Sn+CN5vLJsN19sSMJWmmz3CPXlaG4RqdmF5ZdVe49Uepyvhyudg33oEtSKrsE+uFgsfPJ7AvvTc8v3GRkVxJShHTmnWxBWFeMVaZaUdDtJmEa6RUSkBXvppZe49dZb6dGjBxaLhS5dujB16tRK09Evuuii8uv9+vUjJiaGDh068Omnn3LzzTefcMyZM2eeUHhNpCEdPJLLKz/vYcGfFcn28G6B3DuqG4M6tAEgM7+YfWk57EnNYU9aDntTc9mblsPBI7lkF5awKSGDTQkZlY7r6+HK1WdEMnlIBzoGNv5ifyJSN0q6nSTMX2u6RUSkeQgMDMTFxYWUlJRK21NSUggNDa3yMUFBQXz11VcUFBRw5MgRwsLCePDBB+ncufNJnycgIIDu3buzZ8+eKu+fPn06sbGx5bezsrKIjIysxSsSqZkD6bn89+c9fLWxItk+p3sQfz+/G4M6tK60r7+XGwPat2ZA+8rbC0tsHDySx57UHPaWJuRHc4u4oHcoVwwIp5WHvoaLtBT63+4kGukWEZHmwt3dnUGDBrF06VLGjx8PgN1uZ+nSpUybNu2Uj/X09CQ8PJzi4mK++OILrrnmmpPum5OTw969e7nhhhuqvN/DwwMPD49avw6Rmtqfnst/f97N1xsPlSfb53YP4u+jujHwL0n16Xi4utA9xJfuIScunRCRlkVJt5OUrenOzC8mt7BEZy9FRKRJi42NZcqUKZxxxhkMHjyY2bNnk5uby9SpUwGYPHky4eHhzJw5E4C1a9eSlJRE//79SUpK4vHHH8dut/PAAw+UH/P+++9n3LhxdOjQgUOHDvHYY4/h4uLCxIkTTXmNImX2peXwSunIdll9tBFRxsj2X0ewRURqSpmhk/h6uuHr6Up2QQmHM/PpGqyzmiLSNNWkB7BUrTlUhp4wYQJpaWk8+uijJCcn079/fxYtWlReXC0+Ph6rtaKNUUFBATNmzGDfvn34+PgwduxY3n//fQICAsr3SUxMZOLEiRw5coSgoCCGDRvGmjVrCAoKclrcev86R0v5Pe44nMXcFXv5dtOh8mT7vB7B3HN+N/pHBpgam4g0H0q6nSg8wIudydkkZRQo6RaRJsfd3b28bVFQUBDu7u4ntLqR03M4HKSlpWGxWHBza9ptf6ZNm3bS6eTLly+vdPvcc89l+/btpzzeJ5984qzQTqD3r3M4HA6KiopIS0vDarXi7u5udkj1Yt3+o7y2fA/LjmvZdX5psh2tZFtEnExJtxOFlSbdWtctIk2R1WqlU6dOHD58uMp+wVJ9FouFiIgIXFxczA6lxdD717m8vb1p3759pdkMTZ3d7uDnnam8tmIv6w8eA8BqgYv6tuOOc7vQJ9zf5AhFpLlS0u1E6tUtIk2du7s77du3p6SkpFJ/ZakZNzc3Jdwm0PvXOVxcXHB1dW02MwWKbXa+3XSIuSv2sislBwB3FytXDorgtnM600ktu0SkninpdqKyCuZJSrpFpAkrmxbd1KdGS8uk96+UyS+yMf/3eN74dX/5dzMfD1euO6s9N5/diWA/T5MjFJGWQkm3E4WrbZiIiIiIqTLyinhv9UHeWXWAo7lFAAT6uDP17E5cf1YH/L10QkZEGpaSbieq6NVdYHIkIiIiIi1HUYmd1fuO8NO2ZL76M4ncImN5QWQbL247pwtXD4rA001LPkTEHEq6nags6T6cmY/d7sBqbR5roUREREQam6yCYpbHpfHTtmRWxKWRXVhSfl+PUF/uGNGFi/u2w9Wl+RSDE5GmSUm3E4X4emC1QLHNQXpOodYKiYiIiDjR4cx8lmxP4aftKazZd4Rim6P8vkAfD0b3CmFs31CGdQ1sNoXgRKTpU9LtRK4uVkL9PDmUWUBSRr6SbhEREZE6cDgcxKVks3hbCot3pLA5MbPS/V2CWjG6VygX9A6hf0SAZhmKSKOkpNvJwgK8OJRZwKGMAga0NzsaERERkabH4XDw+i/7+GhtPPFH88q3WywwsH1rRvcKYXSvELoE+ZgYpYhI9SjpdrKwAC84eEwVzEVERERq6aWlu5m9ZDcA7q5WhncNZHSvEM7vGUKQr4fJ0YmI1IySbidrF2BMKVevbhEREZGam/97fHnC/eBFPbjhrA608tBXVhFpuvQXzMnCj6tgLiIiIiLVt2xnKg99uRWAaSO7cvu5XUyOSESk7tRDwcnC/NWrW0RERKSmNiVkcOeHG7DZHVw5MIJ/XNDd7JBERJxCSbeTlfXq1ppuERERkeo5kJ7LTe/8Tn6xjXO6B/HvK/uq5ZeINBtKup2sbHr5kdwiCoptJkcjIiIi0ril5xQy5e11HMktok+4H69eNxA3F31FFZHmQ3/RnMzPy5VW7i6ARrtFRERETiWvqISb3/mdg0fyiGjtxbwbz8RHRdNEpJlR0u1kFovluCnmWtctIiIiUpUSm51pH/3JpsRMWnu78e5Ngwn29TQ7LBERp1PSXQ+0rltERETk5BwOBzO+2srPO1PxdLPy1o1n0iXIx+ywRETqhZLuelCWdKtXt4iIiMiJXl66h09+T8Bqgf9OHMjA9q3NDklEpN4o6a4H4QHG1CiNdIuIiIhUNv/3eF5csguAp8b3YXSvEJMjEhGpX0q660H59PJMJd0iIiIiZZbtTOWhL7cCMG1kV66L6WByRCIi9U9Jdz1QITURERGRyjYlZHDnhxuw2R1cOTCCf1zQ3eyQREQahJLuehB+3Jpuh8NhcjQiIiIi5jp4JJeb3vmd/GIb53QP4t9X9sVisZgdlohIg1DSXQ9C/DyxWKCoxM6R3CKzwxERERExTcLRPCbPW8eR3CL6hPvx6nUDcXPRV1ARaTn0F68euLtaCfb1AFRMTURERFquTQkZXP7qbxw8kkdkGy/m3XgmPh6uZoclItKglHTXk3b+WtctIiIiLdfi7Slc+781pOcU0audH5/fPpRgX0+zwxIRaXBKuutJeHkxNY10i4iISMvy3uoD/O39P8gvtnFu9yA+vX0IIX5KuEWkZdL8nnoSpl7dIiIi0sLY7Q7+vWgn//tlHwDXnhnJU+P7aA23iLRoSrrriXp1i4iISEtSUGzjH59uYuGWwwD8c0wUd47ooirlItLiKemuJ2HlbcO0pltERESat2O5Rdz63h/8cfAYbi4Wnr86msv6h5sdlohIo2D6XJ85c+bQsWNHPD09iYmJYd26dafcf/bs2URFReHl5UVkZCT33XcfBQWNL7HVmm4RERFpCQ4eyeWK11bxx8Fj+Hm68t5NMUq4RUSOY+pI9/z584mNjWXu3LnExMQwe/ZsxowZQ1xcHMHBwSfs/9FHH/Hggw8yb948hg4dyq5du7jxxhuxWCzMmjXLhFdwcmUj3WnZhRSW2PBwdTE5IhERERHn2hB/jFve/YOjuUWEB3jxztQz6Rbia3ZYIiKNiqkj3bNmzeLWW29l6tSp9OrVi7lz5+Lt7c28efOq3H/VqlWcffbZTJo0iY4dO3LBBRcwceLE046Om6G1txuebsavNzmz8Y3Ei4iIiNTFoq3JTPzfGo7mFtE33J8v7xqqhFtEpAqmJd1FRUWsX7+eUaNGVQRjtTJq1ChWr15d5WOGDh3K+vXry5Psffv28f333zN27NgGibkmLBbLceu6NcVcREREmo+3Vu7njg/XU1hi5/wewXxy21nqwS0ichKmTS9PT0/HZrMREhJSaXtISAg7d+6s8jGTJk0iPT2dYcOG4XA4KCkp4fbbb+ehhx466fMUFhZSWFhYfjsrK8s5L6AawgO82JeWyyEVUxMREZFmoMRm5+nvd/D2bwcAuP6s9jw+rjeuagkmInJSTeov5PLly3nmmWd49dVX2bBhAwsWLGDhwoU89dRTJ33MzJkz8ff3L79ERkY2WLxh/iqmJiIiIs1DSlYBk95cW55wP3hRD566rI8SbhGR0zBtpDswMBAXFxdSUlIqbU9JSSE0NLTKxzzyyCPccMMN3HLLLQD07duX3NxcbrvtNh5++GGs1hP/6E+fPp3Y2Njy21lZWQ2WeIepgrmIiIg0A7/sSuO++Rs5kltEK3cXnr0qmov7tTM7LBGRJsG0U5Pu7u4MGjSIpUuXlm+z2+0sXbqUIUOGVPmYvLy8ExJrFxejKrjD4ajyMR4eHvj5+VW6NJSwAGNtk9Z0i4iISFNUYrPz/I9xTHl7HUdyi+jZzo/v7hmuhFtEpAZMbRkWGxvLlClTOOOMMxg8eDCzZ88mNzeXqVOnAjB58mTCw8OZOXMmAOPGjWPWrFkMGDCAmJgY9uzZwyOPPMK4cePKk+/GRL26RUREpKlKySrg7o//ZN3+o4CxfnvGxb3wdGt837lERBozU5PuCRMmkJaWxqOPPkpycjL9+/dn0aJF5cXV4uPjK41sz5gxA4vFwowZM0hKSiIoKIhx48bx9NNPm/USTqlsevnhzAIcDgcWi8XkiERERERO76/TyWde2Y9Lo8PMDktEpEkyvfLFtGnTOHjwIIWFhaxdu5aYmJjy+5YvX84777xTftvV1ZXHHnuMPXv2kJ+fT3x8PHPmzCEgIKDhA6+GUH9jenlekY3M/GKToxEREamZOXPm0LFjRzw9PYmJiSlv2VmV4uJinnzySbp06YKnpyfR0dEsWrSoTseUhney6eRKuEVEas/0pLs583RzIdDHHdC6bhERaVrmz59PbGwsjz32GBs2bCA6OpoxY8aQmppa5f4zZszg9ddf57///S/bt2/n9ttv5/LLL+fPP/+s9TGlYZVVJ39l2R4cDmM6+Zd3DqVTYCuzQxMRadKUdNezigrm6tUtIiJNx6xZs7j11luZOnUqvXr1Yu7cuXh7ezNv3rwq93///fd56KGHGDt2LJ07d+aOO+5g7NixvPDCC7U+pjScX3alMfalX1m3/yit3F14eeIA/m98X63fFhFxAiXd9Uy9ukVEpKkpKipi/fr1jBo1qnyb1Wpl1KhRrF69usrHFBYW4unpWWmbl5cXK1eurNMxs7KyKl3EuTSdXESk/inprmfq1S0iIk1Neno6NputvLBpmZCQEJKTk6t8zJgxY5g1axa7d+/GbrezePFiFixYwOHDh2t9zJkzZ+Lv719+iYyMdMKrkzJZBcVcp+nkIiL1Tkl3PVOvbhERaQleeuklunXrRo8ePXB3d2fatGlMnTq1UheSmpo+fTqZmZnll4SEBCdGLP9dupu1mk4uIlLvlHTXM/XqFhGRpiYwMBAXFxdSUlIqbU9JSSE0NLTKxwQFBfHVV1+Rm5vLwYMH2blzJz4+PnTu3LnWx/Tw8MDPz6/SRZzjcGY+764+CMArkwZqOrmISD1S0l3PVEhNRESaGnd3dwYNGsTSpUvLt9ntdpYuXcqQIUNO+VhPT0/Cw8MpKSnhiy++4LLLLqvzMcX5Xl66h6ISO4M7tmFEVJDZ4YiINGuuZgfQ3JUl3SnZBRTb7Li56DyHiIipigsgLx38I8yOpFGLjY1lypQpnHHGGQwePJjZs2eTm5vL1KlTAZg8eTLh4eHMnDkTgLVr15KUlET//v1JSkri8ccfx26388ADD1T7mNIwDqTn8ukfxlT9f14YhcViMTkiEZHmTUl3PWvbyh13VytFJXaSMwuIbONtdkgiIi1XcT68PRaSN8ON30P7GLMjarQmTJhAWloajz76KMnJyfTv359FixaVF0KLj4+vtF67oKCAGTNmsG/fPnx8fBg7dizvv/8+AQEB1T6mNIxZi3dhszsYGRXEmR3bmB2OiEizZ3E4HA6zg2hIWVlZ+Pv7k5mZ2WBrw0Y8t4wDR/KYf9tZxHRu2yDPKSIif+FwwNd3wcYPjdudzoUp3zR4GGZ8DjUX+t3V3fZDWYx9+VcAFt4zjN5h/iZHJCLSdNT2c0hzneuqpND4IncK5eu6M1VMTUTENH/MMxJuixWsrrB/BRxcZXZUIg3qhZ/iALikXzsl3CIiDURJd205HPDFLfBsZ0iLO+WuKqYmImKyhN/hh38Z10c9DgNuMK4v/7dpIYk0tPUHj7J0ZyouVguxo7ubHY6ISIuhpLu2LBbIPwZFObDrh1PuGqa2YSIi5slJhU8ng70Yel0GQ++B4bFgdSsd7V5tdoQi9c7hcPDsImOQ4OpBEXQO8jE5IhGRlkNJd11EXWT8jDt10h0e4Ako6RYRaXC2EvhsKmQfgsAouGyOcdI0oD0MuM7YZ4VGu6X5+3V3Omv3H8Xd1co953czOxwRkRZFSXdddL/Q+JmwDnLSTrqbppeLiJhkyWNwcCW4+8KED8DDt+K+YbHG2u59yyF+jWkhitQ3h8PBcz8ao9w3nNWh/HuJiIg0DCXddeEfAaH9AAfs/umku7Xz1/RyEZEGt/ULWP2KcX38qxD0lzWsrTtA/9LRbq3tlmZs0dZktiRl0srdhTtHdDE7HBGRFkdJd11FjTV+xn1/0l3CSqeXZxeWkFVQ3BBRiYi0bKk74Ou7jetn3wu9Lq16v+H/KB3tXgbxaxssPJGGYrM7eL60YvnNwzrR1sfD5IhERFoeJd11FVU6xXzvz1Bc9fRxb3dXWnu7ARrtFhGpdwWZ8Ml1UJxr9OI+75GT79u6A/SfZFzX2m5phhZsSGRvWi4B3m7cck5ns8MREWmRlHTXVbv+4NsOivPgwK8n3U0VzEXEqZLWwxvnwfZvzI6kcbHb4cvb4ehe8I+Eq+aBi+upH1M22r33Z412S7NSWGJj9pLdANxxbhf8PN1MjkhEpGVS0l1XFstxVcxPNcXcSLqTVExNROoqO8UYyU1aDwtjoTDH7Igaj5UvGH+LXTzgmvegVeDpH9O6o0a7pVn6ZF0CSRn5hPh5MGVoR7PDERFpsZR0O0P3sqR7ETgcVe4SrpFuEXEGWzF8diNkHzZu56bB6jmmhtRo7FkCPz9tXL/4eQgfWP3HHj/anbCufuITaUB5RSX89+c9ANx9Xjc83VxMjkhEpOVS0u0Mnc4BN2+jD+zhTVXuEqZe3SLiDD89AvGrwMMPRs4wtq16GXLTzY3LbMcOwhe3AA4YOAUGTq7Z41t3hOiJxnVVMpdm4O3fDpCeU0j7Nt5MODPS7HBERFo0Jd3O4OYJXc4zrsf9UOUuWtMtInW2+TNY+5px/fK5xuhsu2goyoFfnjc3NjMV58P86yH/GIQNhLHP1e44w/8BFhfYuxQSfndujCINKDOvmNdX7AUgdnR33Fz0dU9ExEz6K+wsp1nXXZF0a023iNRC8lb4prQF1jn/hB4Xg9UKox43tv3xljHa29I4HPBdLCRvBu+2MOF9cK1lS6Q2naB/6Wi31nZLE/b6L3vJKighKsSXcdFhZocjItLiKel2lm5jAIvxxS8z6YS7y9Z0J2cVUGKzN3BwItKk5R+D+ddBST50OR9GTK+4r8t5RlssWxEsn2lejGbIToZlT8Omj8BihaveBv+Iuh1z+P3GaPeeJZD4h3PiFGlAqdkFvP3bAQDuHxOFi9VibkAiIqKk22l8giBysHF914lTzIN8PHBzsWCzO0jNLmzg4ESkybLb4Ytb4dgBCOgAV74J1r8URCob7d70CaRsa+gIG47DYYz4//Kc0S7thSjjOhi/g87n1v052nTS2m5p0ub8vIf8YhsD2gcwqmew2eGIiAhKup2rfIr5iUm31Woh1F/F1ESkhlb8G/YsBldPmPABeLc5cZ/wgdBrPOCApU82dIT1q6QI9i6D7x+A2f1g7tnw8/8Z7dIAws+Asc/D0Huc95znlK7t3rNYo93SpCQczeOjdfEA/HNMFBaLRrlFRBoDV7MDaFa6XwRLHof9vxh9cz18Kt0d5u9FwtF8DmVqXbeIVEPcD7DiP8b1cS9Du34n3/e8R2DHt7BrERxcDR2GNEyM9SHvqDG9O+4H42dhVsV9rp7QeaRxkrP7GPANdf7zt+lsjHZv/MAY7b7+c+c/h0g9mL1kN8U2B8O6BjK0SzV61IuISINQ0u1MQVHQuhMc22/0eu11aaW71atbRKrtyF5YcJtxffDfIHrCqfcP7AoDb4D178CSx+CmH6EpjXJlp8C2L2Hnd3BwFThsFfe1CoaoCyFqrLF+3d27/uM55x+w6ePS0e71EDGo/p9TpA72pGbz5Z+JgLGWW0REGg8l3c5ksRhfCtfMMUZo/pJ0q22YiFRLYQ58cp0xwht5Flzwf9V73LkPwqb5kLDW+BvUY2z9xllXBVlGkr35U9i/AhzHFZkM7mWMZkeNNdqAWRt4NVSbzhB9LWz80Jjif91nDfv8IjX0xi/7sTvggl4h9I8MMDscERE5jpJuZ4u60Ei6d/8IdlulgkftArSmW0ROw+EwWoOl7QCfELjmXXB1r95j/drBWbfDyheNtd3dx5xYdM1sJYWwezFs+cyYCl9y3HKb8DOgz5VGst2mk3kxlhn+D6M43e6fNNotjVpmXjFfbzI6p9x2TmeToxERkb9S0u1s7YeApz/kHYHE36H9WeV3lY10J6lXt4iczOo5sG0BWF3hmvdqvmb57Hvhj7eNpH3zfOg/qV7CrBG7HQ7+ZiTa27+CgsyK+9p2g37XQN+rjNHlxqRtF+g3wWhJtuI/cN2nZkckUqXPNyRSUGynR6gvgzq0NjscERH5CyXdzubiBt0uML5cxn1fKenWmm4ROaX9v8DiR43rF/670t+PavMKgOGxxnGWPQO9rwA3T6eGWS0OByRvgS2fwpYvIPtQxX2+7YwR7b5XQ7voxr32/Jz7jZMXu380KqaHa7RbGheHw8GHaw4CcP1ZHVSxXESkEVLLsPrQ/ULjZ9yiSpvblbYMy8wvJqewpKGjEpHGLDMRPptqFBCLnghn3lL7Yw2+DXzDIDMB/njLeTFWV95ReOsCeH04rPqvkXB7+MOAG2DyN3DfNhjzNIT1b9wJN5SOdl9jXF/xrLmxiFRh1d4j7EvPxcfDlfEDws0OR0REqqCkuz50HWVMDU2PMyoQl/L1dMPP05hccFij3SJSprgA5t8AeekQ2hcuebFuyaibF4x40Lj+y/OVp3PXt5Ii47UkrgMXD+h5qdFf/P5dcNkr0PncxrfO/HTO+SdYrMYa9KQNZkcjUsn7q41R7isGhuPjoQmMIiKNkZLu+uAVAB3ONq7H/VDprop13Uq6RQQoyoPPpsChDeAZYCSobl51P27/6yCwO+QfNUabG4LDAd/+HQ6uBHdfuG0ZTHgfeo4zZ4q7s5St7QbYu9TcWESOczgzn8U7UgBjarmIiDROSrrrS9RFxs9dlaeYl63rTjympFukxcs7Cu+PN/5OuHrC1e9A647OObaLK5z3iHF99RzISXXOcU9l5Syj6JjFaryWkN71/5wNZcR0uG25Meot0kh8vC4Bm91BTKc2dA/xNTscERE5CSXd9aVsXffBVcYX61LdSj8Utx3KMiMqEWksMhPh7YuMntqe/jD5a+gy0rnP0XOc0YarOK/+1yNv+9JoUwZw0bPQbVT9Pl9Da90BwgaYHYVIuWKbnY/XxQNwwxCNcouINGZKuutLm04Q3MsoirRnSfnm6Ah/ADYnZpgUmIiYLi3OKDSWttMoeHbTj7WrVH46FguMety4vv5tOLrP+c8BkPgHfHm7cT3mDhh8a/08j4iU+2lbCmnZhQT5enBBrxq2FhQRkQalpLs+lVcxr1jXHR0ZAMDO5GwKim0mBCUipkpYB/PGQFaSseb65p8guGf9PV+n4UZxR3sJ/Py0849/7CB8fC2UFEC3MUZVchGpd++vOQDAxDMjcXfV1zkRkcZMf6XrU9RY4+eeJUZFX4y2YYE+HtjsDk0xF2lpdv0I714K+ceMad83/QgBkfX/vOc/Zvzc+jkc3uS84xZkwkcTIDcNQvrCVW81vcrkIk3Q7pRs1uw7iovVwsSY9maHIyIip6Gkuz6FD4JWQVCYBQd/A8BisdA/0phivikhw8TgRKRB/fkhfDwRSvKh2wUw5RvwbtMwz92uH/S5yri+5AnnHNNWYvQVT9sBPqEw6RPwUCEnkYbwwRqjTdionsG083dCtwMREalXSrrrk9UK3ccY14+rYh4dEQDAJq3rFmncNn0Cn99kJMz5x2p3DIcDVr4IX99p1HiIngjXfgTurZwb6+mc9zBYXY2WV3uX1e1YDgf88IBxLDdvI+H2j3BOnCJySrmFJXyxIQmAG87qaG4wIiJSLUq661vZFPO4740vqkC/0nXdmxMzTQpKRE6ppBC+vRe+/Bts/cJImJ/rBh9cBX9+UP0E3G6HHx+CJY8bt4feA+NfAxe3+or85Np0hkFTjesfXGmMUieur92x1s6FP94CLHDFG6rqLdKAvtqYRE5hCZ0DWzG0S1uzwxERkWpQ0l3fOo8w+u9mxEPqdqCigvn+9Fwy8opMDE5ETpB1GN65xKj2jQX6XQtBPcFeDHsWw9d3wXNdjcR1w/uVWgJWUlIEX94Ga141bl/wNFzwlFFR3CwjH4Iu5xsj7tsWwJvnwVtjYPs3YK9mYce4H2DRdOP66Ceh5yX1F6+IVOJwOHh/tTG1/LqzOmC1mvj3REREqs3V7ACaPfdWRuK9a5HxZTWkNwHe7nRo683BI3lsTszknO5BZkcpIgDxa+DTyZCTAh7+cOWb0P0C4760ONj+NWz7ClK3GQUS9yyB7+6FTudC7/HQ4xJjnXZhDnx6A+z92ZjSfdmrED3BxBdWyrsN3LAAkrfA6ldhy2eQsMa4BHSAs+6AAdeffG324c3w+c2AAwbdCEPvbsjoRVq89QePsTM5G083K1cN1JIOEZGmQiPdDaGq1mGl67rVr1ukEXA4YN0b8M7FRsId3AtuW1aRcAMERcG5D8Cdq2DaHzByBoT0MVpx7V0K39xtjIC/fzm8M9ZIuN28YeL8xpFwHy+0L1z+Gty3FYbfD15tIOMgLHoQZvWCHx+GjITKj8k6bFQqL841TiSOfd7cUXuRFuj90gJql0WH4+9twjIVERGpFSXdDaEs6U76A7JTgIp+3RsTtK5bxFTFBcaU8e/vNxLo3pfDzYuhbZeTPyawG5z7T7jjN5i2Hs6bYbTMctiMZPvwJiORnfItdBvVcK+lpnxD4fxH4L5tcMmL0Lab0W1h9SvwUnTFuu+iXPh4AmQfgsAouPpdc9ali7Rg6TmFfL/lMAA3DOlgcjQiIlITml7eEPzaQdhAOLQBdv8IAyeXr+velJiBw+HAohEjkYaXkWBMAz/0J1isMOpxo9hZTf4/BnaFc/5pXI7she1fQepOY1Q8sFt9Re5c7t5wxk0w8EZj3frqV2D/L8a6720LjNaHuWngHQjXfQpeAWZHLNLizP89gWKbg/6RAfQJ9zc7HBERqQGNdDeUqIuMn6VTzHuH+eNitZCWXUhyVoGJgYk0MccOwvwb4PVzYNFDxrrqoryaH2f/L/C/c42E26s1XL8Azv573aZMt+0Cw/8BV77RdBLu45W1OZzyLfztV6O9mdXNSLhdPIxWZ607mh2lNKA5c+bQsWNHPD09iYmJYd26dafcf/bs2URFReHl5UVkZCT33XcfBQUVn3GPP/44Foul0qVHjx71/TKaPJvdwUdr4wG44SyNcouINDUa6W4oURfBsqeN/rhFeXi5e9M9xJcdh7PYlJBBO38vsyMUadzsdqNN1eLHjHXFYEzjXjPHSAg7DDEqc3c5D0J6nzx5djiMiuI/PWJMBw/tCxM+hNb6IltJu35w+Vxj9H/zpxA+CNrHmB2VNKD58+cTGxvL3LlziYmJYfbs2YwZM4a4uDiCg4NP2P+jjz7iwQcfZN68eQwdOpRdu3Zx4403YrFYmDVrVvl+vXv3ZsmSJeW3XV31VeR0lselkpSRT4C3Gxf3a2d2OCIiUkP6pGsoIX3APxIyE2D/Coi6iP6R/kbSnZjJhX30ISpyUkf2wjf3wMGVxu32Q2HgZDj4m7GGOisJ9i03LosfAZ8QI/nuch50Hgk+pR0CivLg23uMqt0A/SbAJbON6dVSNd9QOPses6MQE8yaNYtbb72VqVON/u5z585l4cKFzJs3jwcffPCE/VetWsXZZ5/NpEmTAOjYsSMTJ05k7dq1lfZzdXUlNDS0/l9AM1JWQG3CGZF4urmYHI2IiNSUku6GYrEYBdV+f8OYYh51EdERAXy8LoFNCRlmRyfSONltsPZ1WPoklOSDWytj5PXMW4yp0P0nGiPX6buM5Hvvz3BgpVGBfNPHxgUgtJ+RgO9ZCilbwOICY56BmL+pArdIFYqKili/fj3Tp08v32a1Whk1ahSrV6+u8jFDhw7lgw8+YN26dQwePJh9+/bx/fffc8MNN1Tab/fu3YSFheHp6cmQIUOYOXMm7du3r/KYhYWFFBYWlt/OyspywqtrWg4eyWXFrjQsFpgUU/XvSUREGjcl3Q0p6iIj6d61COx2+pW2DduSmInd7sBq1Zd/kXLpu42q4gmlo2SdzoFL/3vimmKLxWjnFRRl9JkuKTT6bZcl4cmbKy5gFAW7+h3oOKwhX41Ik5Keno7NZiMkJKTS9pCQEHbu3FnlYyZNmkR6ejrDhg3D4XBQUlLC7bffzkMPPVS+T0xMDO+88w5RUVEcPnyYJ554guHDh7N161Z8fU/sDz9z5kyeeOIJ5764JuajtfE4HDAiKogObVuZHY6IiNSCku6G1HEYuPsao3CH/qR7uwF4ulnJLixhX3ouXYN9zI5QxHy2EqN69rJnwFZo/J+54EkYNLV6o9KuHtD5XOMy+gnISTWmne/9GYrzYMxM8A+v95ch0tIsX76cZ555hldffZWYmBj27NnD3//+d5566ikeeeQRAC666KLy/fv160dMTAwdOnTg008/5eabbz7hmNOnTyc2Nrb8dlZWFpGRkfX/YhqJgmIb8/9IAOD6GNWdEBFpqpR0NyRXD6Nn77Yv4c/3cI0YRJ8wf/44eIxNCRlKukVSthuj24c2GLe7nA/jXoKAOnzJ9gmGftcYFxGplsDAQFxcXEhJSam0PSUl5aTrsR955BFuuOEGbrnlFgD69u1Lbm4ut912Gw8//DBW64kNUwICAujevTt79uyp8pgeHh54eHjU8dU0XQs3HyYjr5jwAC9G9jixeJ2IiDQNahnW0M681fi58WPITiE6MgCAzYkZpoUkYjpbMax4zmgDdmgDePjDZXPg+i/qlnCLSK24u7szaNAgli5dWr7NbrezdOlShgwZUuVj8vLyTkisXVyMol8Oh6PKx+Tk5LB3717atVMx0aqUFVCbFNMeFy1BExFpsjTS3dA6DIWIMyHxd1j7GtGRtwGwMTHT5MBETHLoT6Myedma6+4XwiUvgl+YuXGJtHCxsbFMmTKFM844g8GDBzN79mxyc3PLq5lPnjyZ8PBwZs6cCcC4ceOYNWsWAwYMKJ9e/sgjjzBu3Ljy5Pv+++9n3LhxdOjQgUOHDvHYY4/h4uLCxIkTTXudjdWWxEw2JmTg5mJhwpk6+Sgi0pQp6W5oFgsMuw8+mQS/v0X/KX8DYMehLIpK7Li7avKBtADZKbD1c9g83+i1DeDVGi56FvperYriIo3AhAkTSEtL49FHHyU5OZn+/fuzaNGi8uJq8fHxlUa2Z8yYgcViYcaMGSQlJREUFMS4ceN4+umny/dJTExk4sSJHDlyhKCgIIYNG8aaNWsICgpq8NfX2H1QOso9tm87An1a7hR7EZHmwOI42ZyvZiorKwt/f38yMzPx8/MzJwi7HV49C9LjcIx6ggE/9yIjr5hvpp1dXtFcpNkpyoUd3xmJ9r5l4LAb262u0Gu80cLLN+SUhxBpDhrF51AT1VJ+d5l5xcTMXEJBsZ3Pbx/CGR3bmB2SiIhQ+88hjXSbwWqFs/8OX9+JZc2rDAqfx9LdmWxKyFDSLc2LrQT2rzAS7R3fQXFuxX0Rg43iZr2vgFZtzYtRRKSR+WJDIgXFdnqE+jKoQ2uzwxERkTpS0m2WvlfDsqchK4lrg1eylL5sSszkBrPjEqkrh8NYn71pvjGFPOe46setO0H0tcb7v20X82IUEWnEftyWDMCEMyOxaLmNiEiTp6TbLK7uMOQu+PEhzk79CCtPsykhw+yoRGrv2AHY+gVs/hTSdlZs92oDfa6EfhMg4gyt1xYROYWsgmL+OHgMgPN7aMmNiEhzoKTbTAOnwIpn8c45yIXWdfyQdhY5hSX4eOifRZqIzETY9pWRbJf11gZw8YCoi4xR7S7nGyeZRETktH7bnY7N7qBLUCvat/U2OxwREXECZXdm8vCBwbfBL89yj8dCvs+PYUtiJkO6aH2rONmxg+DmDa0C6z7SnJ0C27+CrQsgYU3FdosVOg6HvldBr8vA079uzyMi0gIti0sFYERUsMmRiIiIsyjpNlvM32DVf+lRspezrVvZlNhTSbc4T2Yi/PAv2PmdcdurDQT1gKCoyj99Q0+djOcegR1fG4n2wd8qKo9jMXrP977cSLR99CVRRKS2HA4Hy+LSABippFtEpNlQ0m22VoEwcDKse53bXb7l48TRZkckzYGtBNbOhWXPGBXDLVajwFn+UYhfZVyO5+FfmoAfl4y37gQJa42p4/uWg8NWsX/EmUbV8d7jwS+sIV+ZiEizte1QFmnZhXi7u3BmJ1UtFxFpLpR0NwZD7sLx+5sMd9nKOwfXA4PMjkiassQ/4Nt7IWWLcTvyLLjkRWjTCdJ3Q1qcUegsbadx/eg+KMyExHXG5WTaRZcm2pdD6w4N8lJERFqS5aVTy8/uGoiHq4vJ0YiIiLMo6W4MWnegpNcVuG37jCvyPyMtewpBvh5mRyVNTX4GLH0S/pgHOMCrNYx+Evpfb/SGB2jXz7gcr6QQjuytSMLLk/G90LarkWj3uUItvkRE6tny0qnlI6KCTI5EREScSUl3I+F2zn2w7TMusv7Omh0bCRocY3ZI0lQ4HMYU8EXTIdcYJSF6ElzwlLF84XRcPSCkl3H563HV3ktEpEFk5BWxId5oFaYiaiJiqpRt4BcOXgFmR9JsWM0OQEqF9Ga7zxCsFgc+6181OxppKo7shfcvhy9uNhLutt1gyndw+WvVS7hPRQm3iEiD+WV3OnYHRIX4Eh7gZXY4ItISHdkLH02A14bCq2fB4c1mR+Qce5fBZzeC3XbaXeuL6Un3nDlz6NixI56ensTExLBu3SnWlAIZGRncddddtGvXDg8PD7p3787333/fQNHWr/hetwHQM2UhZCebHI00aiWFsOJZeHUI7Ftm9MUeOQPu+A06DTc7OhERqaHlO0tbhfXQ1HJpIrIOwbd/h6/ugm1fGsvcpGkqyISfZsCcGNi1yNiWfRjevgh2/WRubHWRewS+vB3eH2+8R9e/bVoopk4vnz9/PrGxscydO5eYmBhmz57NmDFjiIuLIzj4xKlVRUVFjB49muDgYD7//HPCw8M5ePAgAQEBDR98PQjrdx5/rOnOGdZdOFa/iuWCJ80OSRqj/b/Ad7FwZLdxu8t5MPZ5rbkWEWmi7HYHK3apVZg0IbuXwJe3Qd4R4/bGD8DiApEx0G00dLsAQnrXftZcSSEc3gTxa4xOKglrwVYMkYON52h/FoQNBHdv572mlshug40fGjWBco2/QXQdDSMeNLbtXwEfT4Cxz8GZt5gba004HLD5U/hxeul71AKDb4N+E0wLyeJwOBxmPXlMTAxnnnkmr7zyCgB2u53IyEjuvvtuHnzwwRP2nzt3Ls899xw7d+7Ezc2tVs+ZlZWFv78/mZmZ+Pn51Sl+ZysqsXP348/wuutz2N18sMZu01oKqZB1CBY/Cls+M263CoYLZ0KfKzUVXKQJacyfQ41dc/3dbUrI4LI5v+Hr4cqGR0fj5mL6RESRqtlKYNnTsHKWcTu0L3Q6F3YvhvS4yvv6hlUk4J3PBQ/fkx837ygkrIOENUainbQBbIWnjsXqanRWiTzLSMLbnwU+OmlVbQdXwQ//guTSKeRtu8GYZ6D7BcbtkiL47j7jhArA0Lth1JMVxXkbq6P7YWEs7P3ZuB3cC8a9DJFnOuXwtf0cMm2ku6ioiPXr1zN9+vTybVarlVGjRrF69eoqH/PNN98wZMgQ7rrrLr7++muCgoKYNGkS//rXv3Bxqbq1RmFhIYWFFf9ps7KynPtCnMjd1UpK6LnsSv2I7sVJRhXq4bFmhyVmKymCNa8a08mLcwELnHETnP+oTsqIiDQDy0pbhQ3rFqiEWxqvrEPw+U0QX/o9/YybjSTNzRPGPA3HDhjJ9+7Fxqy87EOw4V3jYnWDDkOMBLzbBUbCHL+mNMlee2LCDuDd1hjVLhvZdnEzEvP41cZjcpIhab1xWTPHeEzrTsa+ZY8JjGr8SWJDy0gwBnG2LTBue/jDiH/BmbeCq3vFfq7ucNkr0LojLPs/WPVfyIiHy18Ht0ZYd8JWYnxfXvYMlOQbSy9H/AuG3mO8d0xmWtKdnp6OzWYjJCSk0vaQkBB27txZ5WP27dvHzz//zHXXXcf333/Pnj17uPPOOykuLuaxxx6r8jEzZ87kiSeecHr89aVfZGvmHhrHLPe5sOY1OOtO44+ZtEy7l8Cif8GRPcbtiMHGFJ+w/qaGJSIizrMsTlPLxYkcDkjfDQGRzkuOjp9O7u4Ll75kzLQ7XuuOMPhW41KcDwd+g90/GZdj+41EfP8vxtrhqrTtBu1jKkau23Y9cSZf+CA46w7jNWYcNJLvssQ9dbvxPMf2w6aPjf1bBcOA62DgFGjTyTm/C2ewlRitWVt3NLrINISiXPjtJeNSUgBYYNCNcN6MkxfftVjg3H9C6w7w9V2w/Wvj5MvET+pesNeZDv0J39xTMWrfcTiMe6lRLb1sUi3D7HY7wcHB/O9//8PFxYVBgwaRlJTEc889d9Kke/r06cTGVowWZ2VlERkZ2VAh11h0RAD/Wj2U6dYvCMpNhU0fGaOa0rIc3Q8/PgxxC43brYKNntv9JuiMrYhIM5KeU8jmxAwAzlV/bqmr3CPw3d9hx7fgGQD9J8GgqRDUvXbHs5XA8mfg1xeM26F94ep3T5/MuHlBt1HGhWeNqthlCfiBlcY+YQMrkuzIGGjVtvpxWSxGwtq6I0SXrtPNz4DEP46bor7e6Oyy8kXj0uU84zt19wvNG/ksyoU/P4DVrxijxm6toPOI0mn4o8E/wvnPWdZadvGjkJVkbOswzFii2K5f9Y7R7xrwC4NProPE3+HN8+G6zyGwm/PjrYmiXGNke82r4LAb7/kxT0P/6xrd0kvTku7AwEBcXFxISUmptD0lJYXQ0NAqH9OuXTvc3NwqTSXv2bMnycnJFBUV4e7ufsJjPDw88PBooDNIThAdGUAJrvyv5CIetr4Hv71snJ2zVj19XpqZojz4bTasnG2sZbK6QsztcO4D4OlvdnQiIuJkv+xKw+GA3mF+hPhpZpvUwa4f4etpRqIJUJBhJCNrXjWSrDOmQs9x1R9ZzToEn98M8auM28dPJ6+ptl2g7R3GKHVJIWCpPJXZGbwCjkv0MQqv7VpkLNfc+3PFxScUBk42LgENNBCXmw7r/mdc8o8Z2ywuxrLBuIUVgyzBvSrWwUfG1O7kQEmhMdMhdbtx2bcCDm0w7vNvD2P+D3peWvOktOMwuGUJfHiVsZTgzVFw7UfQ8eyax1iQabTx2rMECrPAL8I44eAfbvz0i4BWQaceaNq9xFhznhlv3O5zlXEioZGu6zct6XZ3d2fQoEEsXbqU8ePHA8ZI9tKlS5k2bVqVjzn77LP56KOPsNvtWEv/EXbt2kW7du2qTLibos6BrfD1cOWDwhH8y/8bXI/tN6Zy9LnC7NDkZHLS4JdnjSlTbboYRT3KLr6h1fuj5nAYZ6V/fAgyE4xtnc6Fi56F4B71G7+IiJhmeenU8hEa5W5aCjIhJxXadDZ/YKQwB356GNa/Y9wO6gHjXzOmgv/xNuz6AQ6uNC7ebY1RwEE3nnq0es8SWHCa6eS11VDTqV3cjJMMPcfB0X2w/l1jlDkn2fje9uvzRnI7aKqR6NbHv+PR/cao9p8flE7pxhidH3o3RE8yOtHs/slYB5/4e0Wi/NtL4OEHXUYaMXYdZXynPJ7dZiS/qdshdQekbDN+HtkDjr/0o3bzNupEDZlWtyUHgd3glqXw8bVGvO+Ph8tehX5Xn/pxDocRW9lrTVgD9pJTP8bFHfxKk3D/iIrrfuGw5dOKwsL+kXDxrIoCcI2UqdXL58+fz5QpU3j99dcZPHgws2fP5tNPP2Xnzp2EhIQwefJkwsPDmTlzJgAJCQn07t2bKVOmcPfdd7N7925uuukm7rnnHh5++OFqPWdTqHw66Y01rNp7hO/6/EqfPa9BaD/42y+NbppEi1eUC6tfNUami3Kq3qdVsDF15/hEPKBD5X/LtDj44QHYt9y47RcBFz5Tu7OQItLoNYXPocaquf3ubHYHA59aTGZ+MZ/fPoQzOrYxOySpisNhnBCPX1PRwiplG+AAdx+IOKN0HXIMRJx56irdzpawzkiOj+03bp91F5z/SOXEKjMJ/nzfSDqzD1Vs7zzCmG4dNbZiRLW208mbipIi2PmtcTLiwK8V2/0iYNAUGHAD+LWr+/Mc+tOYrbr9K2PaM0C7/jDsXuP7XVUJft5RYyR+92LYs7iiHVuZ0H7Q6Rxjv9TtxvfHkvyqn9/T3xg1D+4FwT2hxyXOeV1livON992Ob4zbI2fAOfdX/t5amGO0HCtLtMumtpcJ7G6cUPCPMO7LTDTeq5mJxomRst/byVisEHMHjHwIPHyc99pOo7afQ6Ym3QCvvPIKzz33HMnJyfTv35+XX36ZmJgYAEaMGEHHjh155513yvdfvXo19913Hxs3biQ8PJybb775lNXL/6opfGD/+4edzF2xl5sH+vLI7glQnAfXL4Cu55sdmkBFT8Nlz0D2YWNbu/5w9j2QnWL0lTy8yajEWdUfDE9/4w9nu2iwFRnTnuwlRpXFs/8Ow+5T30mRZqwpfA41Vs3td7f+4FGufG01/l5urJ8xCldVLm8cbCWQsqVyka7jk9Uyrp4Vo5dlLFYI6VO5gnZ9rNMtKYIV/zbWKjvsRtI4/lWjNdfJ2EqMBOiPecZINqUpgE8IDLjeSL5/esQ508mbgvTdxuyAjR9WnvLdZaSREJaPskYa055bBZ96urPDYSTNv71kJJtlupxvfL/rdE71B1PsdiNx3/2TkYAnbaD83+t4rp4QFAXBvY3kOrgXhPQC33b1P3Bjt8OSR42q5gD9r4eh00pPHPxktCSzFVWOtdM5FSP3pypsZys2vmOXJ+IJxyXmicaMjVGPQ/jAen2JVWmySXdDawof2Iu2Hub2DzbQs50fP3RfCGtfM96kU741O7SWzeEwztQtfhTSdhjbAtrD+Y9B7ytO/ENclGeciTy8sSIRT91R+Q9QmaixxgdbY6qsKSL1oil8DjVWze139/yPcbyybA/josP478QBZofTchUXGFOvy5LsxPWlLTqPU6kndGkbq1ZBxud6WWKesMYojvVXfhHHVeWOMZLyukxlTt1hjDKWVWrudy1c9J+atRE9drC0ndf7FWvAyzh7OnljV1xgjNj+Ma+iHVpVrG5GMbGyJLx8ynOkkbSv/i8kbzH2tbgYv7+z7zFmC9RVThrsXWrMsvAJNRLskN7GVHWzlzf8/iZ8/8+qB5pad6xoE9dxWONsNVZDSrqrqSl8YB/OzGfIzJ9xsVrYdl9vPF8baIyE3rLUmMIkDe/Qn8bZ37KpSJ4BRnGzM2+p2dqkkiJI21mRhOemGlOZuo2ul7BFpPFpCp9DjVVz+91d/PKvbDuUxaxrorliYD2MhsrppcXBJ5MqWnOW8fCHyMEVyXL4oOrNQss6VDEFPX6NkYT9dX1tbaek2+3GQMySJ4xiq16t4ZLZ0Ht8dV/tiWzFsHMhrH/bWObW3KaT11TqDqNGT2ZCxVTnrCRj1PV0053BWDs9cAoMudMYmGkpdv1k9HC3FUKHs0sT7dFVt31r4pR0V1NT+MB2OBwMfmYpadmFxhqvPx8y+g227WZUDazJmUypm2MH4eenKoo1uHhAzN+MYhRerc2NTUSapKbwOdRYNaffXWpWAYOfWQrAHzNGEejTdDqtNBtxP8AXt0JRNngHGlNey5LsoB7OadFZmGO0ripLwhN/N6o1H686U9IzEuCrOypO/ncdDZe9cmJxrbrIPWJ8xzR75LQxshVDdnJFEl4pKU801jj3m2AMxni30NoMBVnGe8e9ldmR1Kvafg41qT7dLYXFYiE6IoAlO1LYmJDBGaOeMM66HdltnEWa9Cm46J+uXuUdNYqIrPtfxXTwfhPgvBkt68yliIjUi+W7jKrl0RH+Srgbmt1ufMYvexpwQPuhcM174FMPFeQ9fIx11mVrre02Y+lZ+Wj4WqPlUfJm47Luf8Z+x09Jt1qN0e3CLGMkdczTRsVtZ48g1qRPdkvj4ma0F2uoFmNNkWfTPhFa35S5NVLREf4s2ZHC5sRMGN4ZJn4Mb40x1nMsftSobi2nlrYLvrvXWJ9jdTNaD7i4lV7cK/+0/mVb0nqjvyUYrbtGPwlh/U18MSIi0pwsjzPW0Y6Iapw9ZZutwhz46najTScYI5NjZjq/Z/TJWF2MKdyhfWHwrca2qqakZyXC1kTY+kXFYyPOhMtfb7lTv0WaMCXdjVR0ZAAAmxIzjA3touHy1+CzG2HNHKN388DJZoXXuNltRk/En5821paA8bPsenUF9zaS7a7nN7v1KCIiYp5im51fd6UDMLKHku4Gc3S/sX47dbtxsv3iF4w2UWbzC4M+VxgXOHFKekY8RE+As+/TTEeRJkr/cxupfhH+ABw8kkdGXhEB3u7Q+3Kj4MfymfBdrFGcoMNQkyNtZNJ3w1d3QuI643bXUaXtLryNaeL2EuOnrchYn1P+s7jydq/WRgEIrWsSEREnW3/wGNmFJbRt5U6/cH9zgynINCotN2CfW1PsXWYMXBRkGC2yrnnfmL7dGP11SrqINHlKuhupAG93Orb15sCRPDYlZnJu99J1Ruc8YFRW3P4VzL8ebl0GrTuYGmujYLfBmlfh5/8zemZ6+BnJ9oDrNUotIiKNyvI4Yz33Od2DsFpN+ozKSYWlT8KfHwAOoytHVa2Qym77tjOWYJ2O3WasPS7IMn4WZhvXi3KgXX8I7FrPL+wvHA5YPQcWP2JUnw4bCNd+aIwui4g0ECXdjVh0ZICRdCdkVCTdViuMfw2O7TdaTn08EW7+sXqtJpqr9D3w9Z3GNCyALufDpS+fWPlTRESkEahYz10PhbtOp6QQ1s6FFc8ZVbvLFGQYl5QtVT/OYjX6A/uHGwk5VE6qyxLtv/a3Pp7VDS74P6MLSEOcEC/Oh2//DpvnG7ejJ8ElL4KbZ/0/t4jIcZR0N2L9IgL4euMhNpet6y7j7g3XfgxvjITUbbDgNpjwoXNaWzQldpvxxWHpk8botruvUdFz4GSNbouISKN0KCOfncnZWC1wTrcGTLodDti1CH58CI7uM7aFDYAL/2PUiclMOq4VUmLldkiZSWAvhuxDxoXfT/98rp7GrDMPX6Oqsb3EKBC26F9G26vL5tRvC9TMRPjkOji80Zg+P+ZpiLld3w9ExBRKuhux/pHGOq+NCZk4HA4sx39Q+IfDtR/B22Mh7nujl/Sox0yK1ARH9hprtxPWGLc7j4RL/6tWDiIi0qiVTS0f0L41rVs1UMXs1J3w43TY+7Nx2ycEzn8MoidWnLD39IeQXlU/3m6H3LTKSbjVpXJS7eFX8dPD78Rq4A6H0Q7rx4dh53dGAn712xA+yPmv9+Aq+HSyEbNXG7j6Ha2PFhFTKeluxHqH+eNitZCeU8jhzALCArwq7xBxhpFofnkbrJwFwb2g39XmBNtQ7PbjRrfzwd3HmKo26EadvRYRkUZvWenU8pENMbU87ygs/zf8/iY4bEZLzCF3wfB/1GxZmtUKviHGhVomyRaLMa084kyjoFnGQaMVqjOnmxflwe9vGN8R7CUQ0sdYv926Y92PLSJSB0q6GzFPNxeiQnzZfjiLTQkZJybdYLSQSNsBK1+Er++CNp0hoh7OGjcGaXHw7b0Qv8q43XlE6eh2ezOjEhERqZbCEhur9hitwuq1P7etBNa/DcuehvxjxrYel8AFTxnfE8wUPhD+9gt8M83ole2M6ea5R4xke+3rkH/U2Nb7cuOY7q2cFrqISG0p6W7koiMD2H44i42JGVzUt13VO533qDF1bNcP8MlEo6K5f3jDBlofSgqNKWK7F8OexZC+y9ju7mN8cRg0VaPbIiLSZPxx4Bi5RTaCfD3o1c6vfp5k33L44UHjhDwYs+AunGmcqG4svAKMll11nW5+7IBRmXzD+8bsNzBGtYfdBwOn6DuCiDQaSrobuegIfz5eB5sTMk++k9UKV74Bb10Aqdvhk0kw9Qej4FpTkxFfmmQvgX0rKldBtbgYvbMvelZt0kREpMlZtrO0armzW4VlJBgdPLZ+YdR5AfBqDSMfNk5QuzTCr3t1mW5+eBP89hJs+9JoAwZGO7Kz/w49L22cr1dEWjT9VWrkoiMDANiSlInN7sDlZB/SHr4w8WN44zyjUufXd8JVbzf+s7wlRRC/Gnb/ZCTaaTsr3+8TAl1HG8l25xH1W+lURESkHpWv5+5Rh6nlthJI2Wok2fFrjJ9ZSRX3W1xg8K1w7r/Au00dI24A1Z1u7nAYo/i/vQT7llVs73K+kWx3Oqfxf+cRkRZLSXcj1y3YBy83F3IKS9iXlkO3kFMUPmnd0Ziu9d5lxtnf4F5w7gMNFmu1ORzG2fhtXxofoEU5FfdZrBAZA11HGYl2aD99iIqISJOXcDSPvWm5uFgtDOsWWP0HFmRB4u8VSXbS+sqfm2Ak2u2iof1ZxrTq4B7ODb6+nWq6eWg0bP/KSLaTNxv7W1ygzxUw9B5o18/MyEVEqkVJdyPn6mKlT7gfvx84xqbEzFMn3QAdz4aLX4Bv7zEKqBzdD5GDjTVSwb3Mn3KVdQi+ngZ7l1ZsaxVsJNhdR0GXkcaUOBERkWZkeeko96AOrfHzdDv1zmlxRsXxg6shdVvFFOoyHv4QeSZEngXtY4zP+KZeMOxk0819Q43e4QBu3jBwMpx1p5aZiUiTYq3Ng959910WLlxYfvuBBx4gICCAoUOHcvDgQacFJ4b+pVPM1+47Ur0HDJoCMXcY1zd9BN/dC68Ph5kRMO9C4yzy1gVw7KAx6txQtnwOr55lJNyunnDOP+G2FfCPOBj/qnHWWgm3iEitXXnllfznP/85Yfuzzz7L1VfXvKXknDlz6NixI56ensTExLBu3bpT7j979myioqLw8vIiMjKS++67j4KCgjods7lYVtqfe+SpqpbnHYUf/gWvDjFGfVO2GAl3QHvoew1cPAvuWAX/OgDXfwHn/tOYVt3UE+7jlU037zkO7MVGwu3d1lifft82uOg/SrhFpMmp1bDnM888w2uvvQbA6tWrmTNnDi+++CLfffcd9913HwsWLHBqkC3dud2DeePX/SyLS8Nud1Sv+MqFM42R4/hVkPgHHPoTCrOM9dPxqyv2axVknCEPP8P4oAsf6PzEN+8oLPwHbCt9X4QNhMtfh6Duzn0eEZEW7pdffuHxxx8/YftFF13ECy+8UKNjzZ8/n9jYWObOnUtMTAyzZ89mzJgxxMXFERx8YuL40Ucf8eCDDzJv3jyGDh3Krl27uPHGG7FYLMyaNatWx2wuCoptrNprtAob2aOK/txVtfiKGgv9rjFGs/1O0r2kuSqbbr7lMyjOh75XN83isCIipWqVdCckJNC1a1cAvvrqK6688kpuu+02zj77bEaMGOHM+AQY3KkNPh6upOcUsikxgwHtq5EUWyzQbZRxAbDb4chuYy1Y0nojEU/ZCrlpsGuRcSnTcbhRhCXq4rpPR9+92JhOnpNsrME6918w/B/mT3MXEWmGcnJycHd3P2G7m5sbWVlZNTrWrFmzuPXWW5k6dSoAc+fOZeHChcybN48HH3zwhP1XrVrF2WefzaRJkwDo2LEjEydOZO3atbU+ZnOxZt8RCorttPP3JOqvy8T2LYdF043uIwBBPY0T511GNnicjYrFYpx0EBFpBmo1vdzHx4cjR4ypzj/99BOjR48GwNPTk/z8fOdFJwC4u1o5p7tRdOXn0nYjNWa1QlAU9J9krPn+2wqYngQ3L4EL/22cRW7T2dj3wK/w6WR4qR/88jzkpNX8+Qpz4Nt74cOrjIQ7sDvcsgRG/EsJt4hIPenbty/z588/Yfsnn3xCr169qn2coqIi1q9fz6hRo8q3Wa1WRo0axerVq6t8zNChQ1m/fn35dPF9+/bx/fffM3bs2Fofs7lYXjq1fERUMJay4qBH98En1xnFT1O3G7PMxj4Pt69Uwi0i0szUKvsZPXo0t9xyCwMGDGDXrl3lH6jbtm2jY8eOzoxPSp3fI4TvtySzZEcq/7ggyjkHdfMsLcRyZsW2zET4421Y/47RguTnp2DFf6D3FTD4NogYdPrjxq+BL/8Gxw4Yt8+6E85/FNy8nBO3iIhU6ZFHHuGKK65g7969nHfeeQAsXbqUjz/+mM8++6zax0lPT8dmsxESElJpe0hICDt37qzyMZMmTSI9PZ1hw4bhcDgoKSnh9ttv56GHHqr1MQsLCyksLCy/XdPR+sairIjaiKggKMyGX1+A1XPAVmTMAjvzFhjxYNNo8SUiIjVWq5HuOXPmMGTIENLS0vjiiy9o27YtAOvXr2fixIlODVAMI6KCsFhgx+EsDmXU42wC/wg4/xGI3W6suw4fZHwp2PwJvHme0Qd80ydQUnjiY0sKYcnj8PZFRsLtHwlTvjWmySnhFhGpd+PGjeOrr75iz5493HnnnfzjH/8gMTGRJUuWMH78+Hp97uXLl/PMM8/w6quvsmHDBhYsWMDChQt56qmnan3MmTNn4u/vX36JjIx0YsQNY396LgeO5OHu4uDcvJ/gv4Ng5YvGZ2vnkXDHbzD2WSXcIiLNmMXhaMjy1ebLysrC39+fzMxM/Pz8zA6nRq58bRXrDx7jqfF9uOGsBqzcmbgefn/D6K1tKzK2eQfCoBvhjJvAPxyStxqj2ylbjfv7X2ck257+DReniEgT0BQ+h4qKivD29ubzzz+vlKxPmTKFjIwMvv766xMeM3z4cM466yyee+658m0ffPABt912Gzk5OZSUlNT4mFWNdEdGRjbq391fzVu5n+8WfsVzPh/RpXiXsbFNZxjzDHS/0Fi7LCIiTUJtP8NrNdK9aNEiVq5cWX57zpw59O/fn0mTJnHs2LHaHFKq4bweRmXXn3ekNOwTRwyCy+fCfdvhvEfALxzy0uHX52F2X3hvPPxvhJFwewfChA+NFmBKuEVEGtTvv/9eqXBZmbVr1/LHH39U+zju7u4MGjSIpUuXlm+z2+0sXbqUIUOGVPmYvLw8rNbKXytcXFwAcDgctTqmh4cHfn5+lS5Njfv6/7HA43Ej4Xb3hdFPwZ1rIOoiJdwiIi1ErZLuf/7zn+XrqrZs2cI//vEPxo4dy/79+4mNjXVqgFJhVE9jHdxve4+QV1TS8AH4BME598PfN8M17xlVzh022LfM6KUZNdb4ItHzkoaPTUREuOuuu0hISDhhe1JSEnfddVeNjhUbG8sbb7zBu+++y44dO7jjjjvIzc0trzw+efJkpk+fXr7/uHHjeO211/jkk0/Yv38/ixcv5pFHHmHcuHHlyffpjtnclOQe47KjbwNwrPtVcM8GOPsecPUwOTIREWlItSqktn///vIqqF988QWXXHIJzzzzDBs2bCgvqibO1z3Eh/AAL5Iy8vltzxFG9wo5/YPqg4sr9LrMuKRsh00fQWg/owK6ztqLiJhm+/btDBw48ITtAwYMYPv27TU61oQJE0hLS+PRRx8lOTmZ/v37s2jRovJCaPHx8ZVGtmfMmIHFYmHGjBkkJSURFBTEuHHjePrpp6t9zOYmbel/aWfJZzeRdJnwPyg9+SAiIi1LrZJud3d38vLyAFiyZAmTJ08GoE2bNk22smhTYLFYGNUzmHdXH2TpjhTzku7jhfSCC/7P7ChERARjOnZKSgqdO3eutP3w4cO4utb8I3/atGlMmzatyvuWL19e6barqyuPPfYYjz32WK2P2awU5hCw5S0AlgdPppsSbhGRFqtW08uHDRtGbGwsTz31FOvWrePiiy8GYNeuXURERDg1QKns/NIp5j/vTMVub1E18ERE5DQuuOACpk+fTmZmZvm2jIwMHnroIUaPHm1iZC3Q+nfwKs5gvz0El75XmB2NiIiYqFZJ9yuvvIKrqyuff/45r732GuHh4QD88MMPXHjhhU4NUCqL6dyGVu4upGYXsvVQ5ukfICIiLcbzzz9PQkICHTp0YOTIkYwcOZJOnTqRnJzMCy+8YHZ4LUdxAY5VLwPwmu1SYroEmRyQiIiYqVbTy9u3b8933313wvYXX3yxzgHJqXm4ujC8WxCLtiWzdEcq/SICzA5JREQaifDwcDZv3syHH37Ipk2b8PLyYurUqUycOBE3Nzezw2s5Nn6AJSeFJEdblriNZGZo06u6LiIizlOrpBvAZrPx1VdfsWPHDgB69+7NpZdeWl6hVOrPeT2DjaR7Zwr3je5udjgiItKItGrVimHDhtG+fXuKiooAYyYawKWXXmpmaC2DrRhWvgTA6yWXMLB7CC5WFRkVEWnJapV079mzh7Fjx5KUlERUVBQAM2fOJDIykoULF9KlSxenBimVjYwKxmKBrUlZJGcWEOrvaXZIIiLSCOzbt4/LL7+cLVu2YLFYcDgcWI7rKmGz2UyMroXY8hlkxpNpbc1820j+2bmN2RGJiIjJarWm+5577qFLly4kJCSwYcMGNmzYQHx8PJ06deKee+5xdozyF0G+HkSXTiv/eWequcGIiEij8fe//51OnTqRmpqKt7c3W7duZcWKFZxxxhknVBuXemC3wa+zAHjTNpZC3Dmrc1uTgxIREbPVKulesWIFzz77LG3aVJy9bdu2Lf/+979ZsWKF04KTkxvVMxiAn3emmByJiIg0FqtXr+bJJ58kMDAQq9WKi4sLw4YNY+bMmTop3hC2fw1HdlPi4c+8wvPw83SlZzut5xYRaelqlXR7eHiQnZ19wvacnBzc3d3rHJSc3nk9jNZhK/ekU1Cs6YIiImJMH/f19QUgMDCQQ4cOAdChQwfi4uLMDK35czjKR7k3hl1LLl4M7tRW67lFRKR2Sfcll1zCbbfdxtq1a3E4HDgcDtasWcPtt9+uIi0NpGc7X8L8PSkotrNqb7rZ4YiISCPQp08fNm3aBEBMTAzPPvssv/32G08++SSdO3c2ObpmbtePkLIF3H14t2QMAGdpPbeIiFDLpPvll1+mS5cuDBkyBE9PTzw9PRk6dChdu3Zl9uzZTg5RqmKxWDivdIr5kh1a1y0iIjBjxgzsdjsATz75JPv372f48OF8//33vPzyyyZH14w5HPDLcwDYB93E8vgSAK3nFhERoJbVywMCAvj666/Zs2dPecuwnj170rVrV6cGJ6d2fs8QPlgTz887UnGMr1yhVkREWp4xY8aUX+/atSs7d+7k6NGjtG7dWp8R9Wn/Ckj6A1w92dlpMtnLduGr9dwiIlKq2kl3bGzsKe9ftmxZ+fVZs2bVPiKptiGd2+Ll5kJyVgHbDmXRJ9zf7JBERKSROb7oqdSTX543fg6cwspkYxJhTKc2Ws8tIiJADZLuP//8s1r76Ux6w/F0c2FYt0AWb09h6Y5UJd0iIiINLWEdHPgVrG5w9j2s/fIwoKnlIiJSodpJ9/Ej2dJ4jOoZzOLtKfy8M4W/j+pmdjgiIiItS9kod/S12HzDWbd/G6CkW0REKtSqkJo0HiOjjGJqmxIzSc0qMDkaERGRFuTwJtj9I1isMOw+th/KIruwROu5RUSkEiXdTVywnyfREca08mVxqmIuIiLSYH59wfjZ+wpo24U1+44AMLij1nOLiEgFJd3NwHk9QgC1DhMREWkwaXGw/Rvj+vB/AJQn3ZpaLiIix1PS3QycX9qve+XudAqKbSZHIyIi0gKsfBFwQI9LIKQXNruDdfuPAkq6RUSkMiXdzUDvMD9C/TzJL7axuvQsu4iIiNSTYwdg86fG9dJR7h2HS9dze7jSK0zruUVEpIKS7mbAYrFwXulo98+aYi4iIlK/Vs4Ghw26nAfhA4GKqeWD1Z9bRET+Qkl3MzGqNOleuiMFh8NhcjQiIiLNVNYh2PihcX34/eWby5LumM5tzIhKREQaMSXdzcTQLoF4ulk5lFnAzuRss8MRERFpnla9ArYiaD8UOp4NgM3uYK3Wc4uIyEko6W4mPN1cGNY1EDBGu0VERMTJco/A+reN6+f8o3zzjsNZZBeUrudWf24REfkLJd3NSFnrsKU7ta5bRETE6da8CsV50K4/dDm/YnPp1PIzO7XB1UVfrUREpDJ9MjQj5/Uw1nVvTMggPafQ5GhERESamS2lFcuH3QuWimJpa/aVTS3Xem4RETmRku5mJNTfkz7hfjgcsEyj3SIiIs5z7CBkxIPFBbqOKt9s9Oc2Rrq1nltERKqipLuZOb9sirlah4mIiDjPwd+Mn+EDwcO3fPOOw1lkFZTgo/XcIiJyEkq6m5nzS1uH/bo7jcISm8nRiIiINBMHVho/Ow6rtLl8PXfH1lrPLSIiVdKnQzPTJ8yfYF8PcotsrC1dYyYiIiJ1tP9X4+cJSbdahYmIyKkp6W5mrFZL+Wj3z1rXLSIiUnfHDkJmPFhdIfKs8s1azy0iItWhpLsZKmsdtmRHCg6Hw+RoREREmriyqeVhA8HDp3zzzuSK9dy9w7SeW0REqqakuxka1jUQD1cricfy2ZWSY3Y4IiIiTduBU08t13puERE5FX1CNENe7i4M7WJMc1uyI8XkaERERJowh+O0RdRiNLVcREROQUl3MzW6VygAX29M0hRzERGR2so4CJkJxnru9hXrue12B+v2q4iaiIicnpLuZuqS6HZ4ulnZlZLDhvhjZocjIiLSNJVVLQ8fBO6tyjfvSM4iM7+YVu4u9NF6bhEROQUl3c2Un6cbl/QLA+DjdQkmRyMiItJEnXRqeel67k5ttJ5bREROSZ8SzdjEwe0B+G7zITLzi02ORkREpImptJ57eKW71u5TqzAREakeJd3N2MD2AUSF+FJQbOfrjUlmhyMiItK0HDsAWYlgdYPIweWb7XYHa7WeW0REqklJdzNmsVi4dnAkAB+tjVdBNRERkZo4UPV67p3J2VrPLSIi1aaku5m7fEA4Hq5WdiZnsykx0+xwREREmo7TtAo7o6PWc4uIyOnpk6KZC/B2Z2zfdgB8si7e5GhERKQpmTNnDh07dsTT05OYmBjWrVt30n1HjBiBxWI54XLxxReX73PjjTeecP+FF17YEC+l5o5fz92p8nruNVrPLSIiNaCkuwUoK6j2zaZD5BSWmByNiIg0BfPnzyc2NpbHHnuMDRs2EB0dzZgxY0hNTa1y/wULFnD48OHyy9atW3FxceHqq6+utN+FF15Yab+PP/64IV5OzR3dB1lJxnruiMrrudcdKFvP3cas6EREpAlpFEl3Tc6kH++TTz7BYrEwfvz4+g2wiTuzY2u6BLUir8jGNxsPmR2OiIg0AbNmzeLWW29l6tSp9OrVi7lz5+Lt7c28efOq3L9NmzaEhoaWXxYvXoy3t/cJSbeHh0el/Vq3bt0QL6fmyka5I84Ad+/yzXEp2WTkla7nDvc3KTgREWlKTE+6a3omvcyBAwe4//77GT58+Cn3E6OgWtlo98eaYi4iIqdRVFTE+vXrGTVqVPk2q9XKqFGjWL16dbWO8dZbb3HttdfSqlWrStuXL19OcHAwUVFR3HHHHRw5cuSkxygsLCQrK6vSpcGcpFXY8eu53bSeW0REqsH0T4uankkHsNlsXHfddTzxxBN07ty5AaNtuq4YGIG7i5UtSZlsTVJBNRERObn09HRsNhshISGVtoeEhJCcnHzax69bt46tW7dyyy23VNp+4YUX8t5777F06VL+85//sGLFCi666CJsNluVx5k5cyb+/v7ll8jIyNq/qJpwOCoql5+kiFqMppaLiEg1mZp01/ZM+pNPPklwcDA333zzaZ/D1LPkjUibVu6M6RMKaLRbRETq11tvvUXfvn0ZPHhwpe3XXnstl156KX379mX8+PF89913/P777yxfvrzK40yfPp3MzMzyS0JCQgNEj7GeO/swuLhDxJnlm9WfW0REasPUpLs2Z9JXrlzJW2+9xRtvvFGt5zDtLHkjNPFM47V/vfEQuSqoJiIiJxEYGIiLiwspKSmVtqekpBAaGnrKx+bm5vLJJ59U68R4586dCQwMZM+ePVXe7+HhgZ+fX6VLgyjvz131em5vdxf6aj23iIhUk+nTy2siOzubG264gTfeeIPAwMBqPca0s+SN0Fmd29KxrTc5hSUs3HzY7HBERKSRcnd3Z9CgQSxdurR8m91uZ+nSpQwZMuSUj/3ss88oLCzk+uuvP+3zJCYmcuTIEdq1a1fnmJ3qNK3CtJ5bRERqwtXMJ6/pmfS9e/dy4MABxo0bV77NbrcD4OrqSlxcHF26dKn0GA8PDzw8POoh+qbHarVw7eD2/PuHnXy0Lp5rzmy5o/4iInJqsbGxTJkyhTPOOIPBgwcze/ZscnNzmTp1KgCTJ08mPDycmTNnVnrcW2+9xfjx42nbtvL065ycHJ544gmuvPJKQkND2bt3Lw888ABdu3ZlzJgxDfa6TsvhgP1Vr+deu0+twkREpOZMTbqPP5Ne1var7Ez6tGnTTti/R48ebNmypdK2GTNmkJ2dzUsvvdSip45X15UDI3j+xzg2JmSw43AWPds10FQ9ERFpUiZMmEBaWhqPPvooycnJ9O/fn0WLFpUvCYuPj8dqrTzaGxcXx8qVK/npp59OOJ6LiwubN2/m3XffJSMjg7CwMC644AKeeuqpxnVy/MheyEk+YT03wN60HAD6hQeYEJiIiDRVpibdULMz6Z6envTp06fS4wMCAgBO2C5VC/L14ILeIXy/JZlP1sXzxGX6vYmISNWmTZtW5UlwoMriZ1FRUTgcjir39/Ly4scff3RmePWjbD13xGBw86p0V2p2IQAhfo3oJIGIiDR6pifdtTmTLnVz7Znt+X5LMgv+TOLBi3ri5e5idkgiIiKNw0lahRUU28jMLwYg2NezoaMSEZEmzPSkG2p+Jv1477zzjvMDauaGdQ0korUXicfy+X7LYa4cFGF2SCIiIuZzOCqKqP0l6U4rHeV2d7Xi59Uovj6JiEgToSHkFshqtXBtaRE19ewWEREpdWQP5KSAi8cJ67mPn1pusVjMiE5ERJooJd0t1NVnROJitfDHwWPsTsk2OxwRERHz7f/F+Bk5GNwqTyFPzSoANLVcRERqTkl3CxXi58l5PYIB+Hhdy+1dLiIiUu4kU8uhYqQ72FdF1EREpGaUdLdgkwa3B2DBn4kUFNtMjkZERMREp1jPDZCaXTbSraRbRERqRkl3C3ZO9yDC/D3JyCvmx23JZocjIiJinvTdkJsKrp4QfsYJd6dmlY50+2l6uYiI1IyS7hbMxWrhmtKCah+tVUE1ERFpwQ6UrueOOPOE9dxQMb08SCPdIiJSQ0q6W7hrzojEaoG1+4+yLy3H7HBERETMUT61fHiVd1dUL9dIt4iI1IyS7hYuLMCLEVFGQbVPfldBNRERaYGOX8/d6SRJd5bWdIuISO0o6RYmlhZU+3x9IoUlKqgmIiItTFoc5KaVrucedMLdxTY7R3KLACXdIiJSc0q6hZFRQYT4eXA0t4jF21PMDkdERKRhHfjV+Bk5GFxPTKrTc4yp5a5WC6293RsyMhERaQaUdAuuLlauOcMoqPbxOhVUExGRFuZ067mzKoqoWa2WhopKRESaCSXdAhgF1SwW+G3PEQ4eyTU7HBERkYZRqT/3qYuoaWq5iIjUhpJuASCyjTfDuwUB8PE6FVQTEZEWIm0n5KWDqxeED6xyl5SyImqqXC4iIrWgpFvKTSotqPbR2oNkFRSbHI2IiEgDKBvlPsl6btBIt4iI1I2Sbik3ulcIXYN9yCoo4Z3fDpgdjoiISP0rK6J2klZhAGnZZe3CNNItIiI1p6RbyrlYLdxzfjcA3vx1n0a7RUSkebPbT7ueGyoKqQX7aaRbRERqTkm3VHJx33Z0CWpFVkEJ72q0W0REmrO0nZB3xFjPHVb1em7Q9HIREakbJd1SSaXR7pX7ydZot4iINFdlo9ztY8D15P23UzW9XERE6kBJt5zgkn5hdAlqRWZ+Me+uOmB2OCIiIvXjwC/Gz1NMLbfZHaSVjnSHaHq5iIjUgpJuOYFGu0VEpNmz2+HAb8b1UyTdR3ILsTvAaoG2Pkq6RUSk5pR0S5Uu6RdG56BWZOQV897qg2aHIyIi4lxpOyD/KLh5Q9iAk+5WVkStrY8HLlZLQ0UnIiLNiJJuqZKL1cLd53UF4I1f95FTWGJyRCIiIk60v7RVWPuzTrmeO01F1EREpI6UdMtJjesXRudAY7Rba7tFRKRZKevP3XHYKXerKKKmpFtERGpHSbeclKuLlWmlo91varRbRESaC7sdDp5+PTcc16NblctFRKSWlHTLKV0aHUanwFYcyyvmvdUHzA5HRESk7uwlcMHTMOD6U67nBkgpHelW5XIREaktJd1ySq4uVqaNLF3b/cs+cjXaLSIiTZ2rOwy4Di6bAy5up9y1bKQ7yE8j3SIiUjtKuuW0LusfRse23hzLK+b9NapkLiIiLUeqCqmJiEgdKemW0zLWdht9u/+n0W4REWlBVL1cRETqSkm3VMv4/mF0aOvN0dwiPtBot4iItAAOh6Oiermml4uISC0p6ZZqOX5t9/9+2UdekUa7RUSkeTuWV0yxzQFAkI9GukVEpHaUdEu1XT4gnPZtvDmi0W4REWkByka527Ryx91VX5lERKR29Aki1XZ83+7XV2i0W0REmreKHt0a5RYRkdpT0i01cvmAcCLbeHEkt4gP18SbHY6IiEi9KatcHqSkW0RE6kBJt9SIm4uVu0calcxf/2Uv+UU2kyMSERGpH+VF1HxVRE1ERGpPSbfU2OUDjdHu9JwiPlyrtd0iItI8lU8v99NIt4iI1J6Sbqkxt+Mqmc9dsU+j3SIi0ixVjHQr6RYRkdpT0i21csXACCJae5GeU6jRbhERaZbKRrpD1KNbRETqQEm31Mrxo92v/7KPgmKNdouINDdz5syhY8eOeHp6EhMTw7p1606674gRI7BYLCdcLr744vJ9HA4Hjz76KO3atcPLy4tRo0axe/fuhngptVJWSE0j3SIiUhdKuqXWrhgYQXiAF2nZherbLSLSzMyfP5/Y2Fgee+wxNmzYQHR0NGPGjCE1NbXK/RcsWMDhw4fLL1u3bsXFxYWrr766fJ9nn32Wl19+mblz57J27VpatWrFmDFjKCgoaKiXVW0Oh0OF1ERExCmUdEutubtW9O3+9w87mbdyPw6Hw+SoRETEGWbNmsWtt97K1KlT6dWrF3PnzsXb25t58+ZVuX+bNm0IDQ0tvyxevBhvb+/ypNvhcDB79mxmzJjBZZddRr9+/Xjvvfc4dOgQX331VQO+surJLiyhoNgOqJCaiIjUjZJuqZOrB0VwaXQYJXYHT363nWkf/0lOYYnZYYmISB0UFRWxfv16Ro0aVb7NarUyatQoVq9eXa1jvPXWW1x77bW0atUKgP3795OcnFzpmP7+/sTExFT7mA0pNcsY5fb1dMXTzcXkaEREpClT0i114upi5aVr+/P4uF64Wi0s3HyYy15Zye6UbLNDExGRWkpPT8dmsxESElJpe0hICMnJyad9/Lp169i6dSu33HJL+bayx9XkmIWFhWRlZVW6NJTydmFazy0iInWkpFvqzGKxcOPZnZj/t7MI9fNkb1oul835jW82HTI7NBERMcFbb71F3759GTx4cJ2OM3PmTPz9/csvkZGRTorw9MqKqKlyuYiI1JWSbnGaQR3a8N09wxjapS15RTbu+fhPHv9mG0UldrNDExGRGggMDMTFxYWUlJRK21NSUggNDT3lY3Nzc/nkk0+4+eabK20ve1xNjjl9+nQyMzPLLwkJCTV9KbWmHt0iIuIsSrrFqQJ9PHj/5hjuGtkFgHdWHeDa/63mcGa+yZGJiEh1ubu7M2jQIJYuXVq+zW63s3TpUoYMGXLKx3722WcUFhZy/fXXV9reqVMnQkNDKx0zKyuLtWvXnvSYHh4e+Pn5Vbo0lPLp5RrpFhGROlLSLU7nYrXwzzE9eHPyGfh6urIhPoNLXl7Jqj3pZocmIiLVFBsbyxtvvMG7777Ljh07uOOOO8jNzWXq1KkATJ48menTp5/wuLfeeovx48fTtm3bStstFgv33nsv//d//8c333zDli1bmDx5MmFhYYwfP74hXlKNqEe3iIg4i6vZAUjzNapXCN/dPYw7PtjA9sNZXP/WWu4fE8Xt53TBarWYHZ6IiJzChAkTSEtL49FHHyU5OZn+/fuzaNGi8kJo8fHxWK2Vz93HxcWxcuVKfvrppyqP+cADD5Cbm8ttt91GRkYGw4YNY9GiRXh6Nr7R5JTS6uVBSrpFRKSOLI4W1lg5KysLf39/MjMzG3SaWktWUGzjka+28tn6RABG9QzhhWui8fdyMzkyEZGGp8+h2mvI3915zy9nX3oun9x2Fmd1bnv6B4iISLNX288hTS+Xeufp5sJzV0fz7yv64u5qZcmOFMb9dyXbDmWaHZqIiEiVNL1cREScRUm3NJhrB7fni9uHEtHai/ijeUx4fQ1bk5R4i4hI45JXVEJOYQmgQmoiIlJ3SrqlQfWN8Oe7u4cxuGMbcgpLuPHtdexPzzU7LBERkXJllcu93V3w8VD5GxERqRsl3dLgArzdefPGM+jVzo/0nCJueGttecEaERERs2lquYiIOJOSbjGFn6cb7940mI5tvUk8ls/kt9aRmVdsdlgiIiLlJ4KDfTW1XERE6k5Jt5gmyNeD92+OIdjXg7iUbG5693fyi2xmhyUiIi1c+Ui3n0a6RUSk7pR0i6ki23jz3s2D8fN0Zf3BY9zx4XqKbXazwxIRkRYsNVsj3SIi4jxKusV0PUL9eHvqmXi6WVkel8Y/P9uE3d6i2seLiEgjkpalkW4REXEeJd3SKAzq0IbXrhuEq9XCVxsP8eR323E4lHiLiEjDUyE1ERFxJiXd0miM7BHM81dHA/DOqgO88vMekyMSEZGWSIXURETEmZR0S6MyfkA4j43rBcALi3fxwZqDJkckIiItjQqpiYiIMynplkZn6tmduPu8rgA88vVWFm4+bHJEIiLSUhQU28jMN1pYhmikW0REnEBJtzRKsaO7MymmPQ4H3Dv/T37dnWZ2SCIi0gKklY5yu7ta8fNyNTkaERFpDpR0S6NksVh46rI+jO0bSrHNwd/eX8/GhAyzwxIRkWbu+CJqFovF5GhERKQ5UNItjZaL1cKLE/ozrGsgeUU2pr69jj2p2WaHJSIizVhaeY9urecWERHnUNItjZqHqwuv3zCI6Ah/juUVM/mtdRzNLTI7LBERaaZSynp0az23iIg4iZJuafRaebjy9tTBdApsxaHMAu7/bBN2u3p4i4iI86WWjXSrcrmIiDiJkm5pEtq0cmfOpIG4u1r5eWcqb67cZ3ZIIiLSDKWWjnSH+GmkW0REnENJtzQZvcL8ePQSo4f3s4vi2BB/zOSIRESkuSkrpBakNd0iIuIkSrqlSbkupj0X92tHid3B3R/9SWZesdkhiYhIM3J89XIRERFnUNItTYrFYmHmFX1p38abpIx8/vn5JhwOre8WERHnqKherunlIiLiHEq6pcnx83RjzqSBuLlY+Gl7Cu+sOmB2SCIi0gwU2+yk5xgdMlRITUREnKVRJN1z5syhY8eOeHp6EhMTw7p160667xtvvMHw4cNp3bo1rVu3ZtSoUafcX5qnvhH+PDS2JwDPfL+DzYkZ5gYkIiJNXnqOMbXc1Wqhjbe7ydGIiEhzYXrSPX/+fGJjY3nsscfYsGED0dHRjBkzhtTU1Cr3X758ORMnTmTZsmWsXr2ayMhILrjgApKSkho4cjHbjUM7ckGvEIptDqZ99CdZBVrfLSIitVdWuTzI1wOr1WJyNCIi0lyYnnTPmjWLW2+9lalTp9KrVy/mzp2Lt7c38+bNq3L/Dz/8kDvvvJP+/fvTo0cP3nzzTex2O0uXLm3gyMVsFouF566KJjzAi/ijeUxfsEXru0VEpNZURE1EROqDqUl3UdH/t3fvYVFd997AvzPDXECYQWRmGBAFRcAbmBClRBNNxKinTc2lDbmcRxt7kjeGtFZjjtq80Vx6xJqYN01jY2NPanJOq0YbaxKNuRghjaJG1HiJgAgJIAzDRWa4zsDMev/AGTsVo8HZbIHv53n2w7Bnzea3l/vxx4+19touFBQUIDMz07dPqVQiMzMT+fn5V3WM1tZWdHR0ICIiQqow6TpmCFHj9w/egCClAjuPV+Ovh8rlDomIiPoo24VF1IxcRI2IiAJI1qK7rq4ObrcbZrPZb7/ZbIbVar2qYyxduhTR0dF+hfs/czqdcDgcfhv1LzcOG4z/nJUEAHju/a/xdRX/jYmI6PuruTC9nIuoERFRIMk+vfxarF69Gps3b8b27duh03X/V+mcnBwYDAbfFhsb28tRUm/4jykjcHuyCa5OD5746xG0ODvlDomIiPqYi48LY9FNRESBI2vRHRkZCZVKhZqaGr/9NTU1iIqK+s7PvvTSS1i9ejU+/vhjpKSkXLbd8uXLYbfbfVtFRUVAYqfri1KpwEs/TUWUXofSuhb837+f5P3dRET0vXgXUuMzuomIKJBkLbo1Gg3S0tL8FkHzLoqWkZFx2c+tWbMGL7zwAnbv3o2bbrrpO3+GVquFXq/326h/ihikwe8fvAEqpQLbj57D1oJKuUMiIqI+xLuQmpnTy4mIKIBkn16+ePFibNiwAW+99RZOnz6NBQsWoKWlBQ8//DAAYO7cuVi+fLmv/W9/+1s888wzePPNNxEXFwer1Qqr1Yrm5ma5ToGuIxPjIrB4RiIAYMWOkyiuaZI5IiIi6itsvunlHOkmIqLAkb3ozsrKwksvvYQVK1ZgwoQJOHbsGHbv3u1bXK28vBzV1dW+9q+//jpcLhd+8pOfwGKx+LaXXnpJrlOg68yCqSNxy6hItHd4kP2XI2hzueUOiYiIrnNuj0BdswsAF1IjIqLAUogBduOrw+GAwWCA3W7nVPN+rLbJiX979R+obXLih+MtmHdzHEaZQjF4kEbu0IhogGMe6jkp+87W1I5J/7UHCgVw5jezEaSSfVyCiIiuMz3NQ0ESxkQkG2OYFr+7fwIe+tNB7DxRjZ0numZLRIZqMcoUikRzKBLMYUg0hWKUOQwRLMaJiAY07yJqQwZpWXATEVFAseimfuvmkZH4w4M34p3DFSiuaca5xjbUNTtR1+xEfmm9X9vIUA0STKFINIdhlCkUKUPDkRobLk/gRETU62qbvCuXc2o5EREFFotu6tdmj7dg9ngLAKDF2Ymztc0ormnGGVsTzlz4WtHQhrpmF+qaG3CgtMH32Vljo7Dyx2NgMQTLFT4REfUS7yJqXLmciIgCjUU3DRiDtEFIGRqOlKHhfvtbXZ04a2tBcU0TztiaUVzThLziWuw+ZcU/ztRiycwkzM2Ig0qpkCdwIiKSHJ/RTUREUmHRTQNeiCYI44caMH6owbfvdLUDv95+AkfLG/Hc+1/j3SPnsOru8X5tiIio/6jxPi6MI91ERBRgXCmEqBujLXr87bGb8V93j0OYLggnztkxZ90XePa9U2hq75A7PCIiCrCLI90suomIKLBYdBNdhlKpwEPpw7Hnyan4cWo0PALYuP8bzHj5c+w+WY0B9rQ9IqJ+zXZhITUjp5cTEVGAsegmugJTmA6vPnAD3p4/CcMiQmB1tOOx/z2C/3jrMCrPt8odHhGRZNatW4e4uDjodDqkp6fj0KFD39m+sbER2dnZsFgs0Gq1SExMxK5du3zvP/vss1AoFH5bcnKy1KdxVXyrl3N6ORERBRiLbqKrdGuiER8vuhVP3JYAtUqBPYU2zHj5c7zx+Vl0uD1yh0dEFFBbtmzB4sWLsXLlShw5cgSpqamYOXMmbDZbt+1dLhdmzJiBb775Btu2bUNRURE2bNiAmJgYv3Zjx45FdXW1b/viiy9643S+kxDCV3Sb9RzpJiKiwOJCakTfg06twpKZSZgzIRpPbz+JQ980YNWuwq6F1u4ZjxuHDZY7RCKigHj55ZfxyCOP4OGHHwYArF+/Hjt37sSbb76JZcuWXdL+zTffRENDA/bv3w+1Wg0AiIuLu6RdUFAQoqKiJI39+2ps7YDrwh9PjaEc6SYiosDiSDdRD4wyh2Hzoz/AmntTEB6iRqG1Cfe+vh9Ltn4Fm6Nd7vCIiK6Jy+VCQUEBMjMzffuUSiUyMzORn5/f7Wfee+89ZGRkIDs7G2azGePGjcOqVavgdrv92p05cwbR0dEYMWIEHnroIZSXl182DqfTCYfD4bdJwbty+eAQNTRB/NWIiIgCi5mFqIeUSgXumxiLPYun4t4bh0IIYFtBJaa9lIt1e0vQ3uG+8kGIiK5DdXV1cLvdMJvNfvvNZjOsVmu3nyktLcW2bdvgdruxa9cuPPPMM1i7di1+85vf+Nqkp6dj48aN2L17N15//XWUlZXhlltuQVNTU7fHzMnJgcFg8G2xsbGBO8l/wmd0ExGRlFh0E12jIaFarL0vFe8+fjMmxIaj1eXGix8VYfraPHxwvIqrnBPRgODxeGAymfDGG28gLS0NWVlZePrpp7F+/Xpfm9mzZ+OnP/0pUlJSMHPmTOzatQuNjY145513uj3m8uXLYbfbfVtFRYUksdu4iBoREUmIRTdRgNw4bDDeXXAzfnf/BFgMOpxrbMMTfz2K+/6Yj+OVjdd8fCEESmub8d5XVaho4KrpRCSdyMhIqFQq1NTU+O2vqam57P3YFosFiYmJUKlUvn2jR4+G1WqFy+Xq9jPh4eFITExESUlJt+9rtVro9Xq/TQq2C9PLjXxGNxERSYBFN1EAKZUKzJkQg8+enIZfZY6CTq3El9+cx49f24clW79Czfe837u9w429RTas3HESU1/Mxe1r8/DLTUdxy5q9eHDDAWw/Wok2F6exE1FgaTQapKWlYc+ePb59Ho8He/bsQUZGRrefmTx5MkpKSuDxXHyaQ3FxMSwWCzQaTbefaW5uxtmzZ2GxWAJ7At+Td3o5Vy4nIiIpcPVyIgkEa1T4VWYisibGYs3uImw/eg7bCiqx60Q1Hp82Ev9xywjo1KpuP/tNXQtyi2zILa5F/tl6ODsv/gKrVikw0hiKQmsT9p+tx/6z9VihPYUfpVrwk7RY3DgsHAqFordOk4j6scWLF2PevHm46aabMGnSJLzyyitoaWnxrWY+d+5cxMTEICcnBwCwYMECvPbaa1i4cCF+8Ytf4MyZM1i1ahV++ctf+o65ZMkS3HnnnRg+fDiqqqqwcuVKqFQqPPDAA7Kco5fvGd0c6SYiIgmw6CaSkMUQjP+XNQFzM4bj+Q++xtHyRrz0cTE2HarAstnJ+FGKBc5ODw6WNWBvoQ15xbUoq2vxO0ZMeDCmJhkxLdGImxMiEaoNQuX5Vvyt4By2HalARUMbNh2qwKZDFRhhHISfpA3FvTcO5YgNEV2TrKws1NbWYsWKFbBarZgwYQJ2797tW1ytvLwcSuXFCXOxsbH46KOPsGjRIqSkpCAmJgYLFy7E0qVLfW0qKyvxwAMPoL6+HkajEVOmTMGBAwdgNBp7/fz+mXcWEhdSIyIiKSjEAFvlyeFwwGAwwG63S3ZvGFF3hBB476sqrP6wENX2rl/wRhgHoaqxDe0dF0ezg5QKTIyLwG3JRkxLMmGUKfSyo9cej8DBsgZsLajAhyesaLuwYrpSAdyaaMRP02KROcYEbVD3o+pE1PuYh3pOqr67dc1elDe0YutjGZgYFxGw4xIRUf/S0zzEkW6iXqJQdN3vfceYKLzxeSnW551FaW3XqHaUXofbko2YmmjC5IQhCNOpr+qYSqUCGSOHIGPkEDz34w7sOlGNrYcrcfjb88gtqkVuUS3CQ9SYkxqN+VPiMXzIIClPkYiozxFC+BZS4/RyIiKSAotuol4WrFFhYeYoZE2MRX5pHUZb9Egyh13zvdhhOjWyJg5D1sRhKK1txraCSvztSCVqHE68lf8t/nqoHPMnxyP79gTor7KoJyLq75qcnb7ZRpxeTkREUuDq5UQyiTLocPcNQ5EcpQ/44mcjjKH4z1nJ2L9sOjY+PBG3jIpEh1vgj5+X4rYXc/HXg+VwewbUnSVERN3yrlwepgtCsIa34hARUeCx6Cbqx1RKBaYlmfD2/En4888mYoRxEOpbXPj19hP44av/wP6zdXKHSEQkK5uDU8uJiEhaLLqJBgCFQoHbkk346Fe3YsWPxkCvC0KhtQkPbjiI//M/h/FtfcuVD0JE1A/ZfI8L49RyIiKSBotuogFErVJi/pR45D11G+ZlDIdKqcBHp2ow4+XPkbPrNJraO+QOkYioV/kWUdNzpJuIiKTBoptoABo8SIPn5ozD7oW34NZEI1xuT9f93i/lYtMh3u9NRAOH955uTi8nIiKpsOgmGsBGmcPw1sMTffd71zW7sPzdE/jR779A/tl6ucMjIpKcd3q5Wc/p5UREJA0+MoxogPPe7z1lVCT+J/9bvPJpMU5XO/DAhgMYF6NHxoghSI8fgonxETAE81FjRNS/eKeXGznSTUREEmHRTUQALt7vffcNMXjl02L878FynDznwMlzDmz4RxkUCmCMRY/0+CFIHxGB9PgIhIdo5A6biOiaXJxezpFuIiKSBotuIvLjvd87+7YE5JfW40BpAw6W1qO0rgWnqhw4VeXAm/vKAADJUWH4wYghSI+PwKT4CAwJ5UgREfUtvtXLuZAaERFJhEU3EXXLpNdhzoQYzJkQA6DrWbYHyxpwoLQeB8saUGJrRqG1CYXWJmzc/w0AINEcitEWPaL0Opj1OlgMOpgNOkTpdTCFaRGk4jISRHT9aHV1otnZCYALqRERkXRYdBPRVTHpdbgzNRp3pkYDAGqbnDhU1oCDZfU4UFqP4ppm39YdpQKIDNV2FeJ6HaIMFza9DoO0QfB4BNxCwO0R8AgBjwdwC+Hb7/F43wM8QsCs1yFztBnBGlVvdgMR9SPeqeXBahVCtfyViIiIpMEMQ0Q9YgzT4ocpFvwwxQIAqG924stvzqO8oQXV9nbUONphtXdttiYnOj0Ctibnhamc9oDEEKYNwo8nRCNrYizGxxigUCgCclwiGhgurlyu5f8fREQkGRbdRBQQQ0K1mDUuqtv3PB6BuhYnauxOVNvbugpyR7uvOG/v8ECpAJQKBVTKrk2pUECpgO+1b5+ya3/Bt+dReb4NfzlYjr8cLEdyVBjuuykWd98Qg8GDuMAbEV2Zd+VyLqJGRERSYtFNRJJTKhUwhelgCtNh/FBDQI7p8Qjkl9Zjy5cV2H3KikJrE57/4Gus/rAQM8aakXVTLKYkREKp5OgVEXWv5sL0ciMXUSMiIgmx6CaiPkmpVGByQiQmJ0TC3tqBHV+dw5YvK3CqyoGdx6ux83g1YsKD8ZO0ofjpTUMxdHCI3CET0XXm4kg3i24iIpIOi24i6vMMIWrMzYjD3Iw4nDxnxzuHK/D3o+dwrrENv9tzBq9+dgaTR0Zi5rgo6HVB0AapoFMrL/2qVkEXdPFrb6227mjvwMlKO5ItekRwajxRr6nlM7qJiKgXsOgmon5lXIwB42IM+PW/jcZHp6x453AF9pXU44uSOnxRUve9jqVSKjA4RIPbkoyYPT4KkxMioQ0KzGrp7R1u7C20YcexKnxWZIOr0wOFApgQG47bkky4PdmEsdF6Lu5EJCHfM7o50k1ERBJi0U1E/ZJOrfI9Z7yioRVbCypx8pwdzk432js8aO9ww9l56VdXp8d3DLdHoK7Zia0FldhaUIkwbRBuH23C7HFRmJpo+t6PK+t0e5BfWo8dx6rw0Ukrmi48HxjoWg2+tsmJo+WNOFreiJc/KYYpTItpSUbcnmzC5IRIhOnUAesfIro4vdys50g3ERFJh0U3EfV7sREhWDwj8araejwCLndXEd7e4UFpbTN2n7Ji90krbE1O7DhWhR3HqhCsVmFakhGzxkXh9mTTZQtiIQSOVTRix7EqfHC8GnXNTt97MeHBuDM1GnMmRCM5KgxWRztyi2qxt9CGL0rqYGty4p3DlXjncCXUKgUmxkXg9mQTpiWZMNI4iKPgRNfIu5CaiQupERGRhBRCCCF3EL3J4XDAYDDAbrdDr9fLHQ4R9REej8DRivP48IQVH5604lxjm+89jUqJKaMiMWtcFO4YY0Z4iAZnapqw41gV3vuqCuUNrb62g0PU+GGKBXMmxCBt2ODLrq7u7HTjUFkD9hbWYm+RDWV1LX7vD4sIwbQkI5KiwhBtCIYlXIfo8GDoORp+3WMe6rlA9l17hxvJz+wGABxbMQPhIVxPgYiIvltP8xCLbiKi70kIgVNVDnx4shofnrSitPZiQaxSKjB0cDC+rb9YaIdoVLhjjBlzJsRgyqhIqHuwQFtZXQv2Ftqwt8iGg6UNcLk93bYL1QYhOlwHiyEY0eHBiDboYAkPRnS4DtGGYEQZdNCpA3NfOvUM81DPBbLvKhpaccuavdAEKVH0wizOHCEioivqaR7i9HIiou9JoVD4FmxbckcSztiaL4yAV6PQ2oRv61sRpFRgWpIRP54Qg8zRJoRoru2/2/jIQYifEo/5U+LR4uzE/rP12FdSh8rzrahqbEeVvQ2NrR1odnaiuKYZxTXNlz3WsIgQjLHoMdqix5jori3aoGPRQQOKdxE1Y6iW1z4REUmKRTcR0TVQKBRINIch0RyGhZmj8E1dC4prmjAxLgKDJXr81yBtEGaMMWPGGLPf/lZXJ6oa21Ftb0N1YzvONbah2t7mK8qrGtvQ3uFBeUMryhtasfuU1fdZQ7DavxC36JFgCoUmqHcem0bU22q9z+jm/dxERCQxFt1ERAEUFzkIcZGDZPnZIZogJJhCkWAK7fZ9IQQaWlwosjbh62oHvq5y4OtqB0pszbC3dSC/tB75pfW+9mqVAqNMYRht0SMyTIMgpQIqpfLCVwXUKv/vfV8v7A/TBcEYqoVJr8WQQVqoLnP/OpEcvCPdZj6jm4iIJMaim4hogFAoFBgSqsXNCVrcnBDp2+/sdONMTbNfIX662oGm9s6ufdWOa/7ZSgUQMUgLY5gWprCur8Ywra8oN4ZeeE+vQ6j2+ktNjvYOnK5yINEcJtkMBupdNQ6OdBMRUe+4/n6zISKiXqUNUvnuUfcSQqDyfBu+rnagsLoJzc4OdLgF3B6BTo+A2+O58LXr+06355/eE+hwe+Bo60RtsxP1zU54BFDX7ERdsxOnq787nlBtEMx6LaIMOpj1XVuU96uh63VkqAZBPViQ7kqEELA1OXGqyo5T57r+4HCqyuFbgf61B2/Aj1KiA/5zqffZvI8LC2PRTURE0mLRTUREl1AoFIiNCEFsRAhmjo26pmN1uj1oaHWhtskJW5MTtd1tzU7YHO1ocbnR7OxEc20nzta2XPaYSgVgDNMiSq+DMUyHiEFqDB6kweAQDSJCNBg8SNO1L0SDiEEa6HXqSx7P5vEIlNW34OuqrsL6VJUdp6sdqGt2dfszY8KD4ezoftV46nu808tNnF5OREQSY9FNRESSClIpYQrTwRSmw9grtG12dqLG0Y4aezusjq7N+7rG4USNox22JifcHnHheycA+xVjUCqA8BANBoeoETFIA7dHoNDahFaXu9u2CaZQjLHoMTbagLHRXQvMcVp5/+JbvZzTy4mISGIsuomI6LoRqg1CqDEUI43dLwYHAG6PQH2zs6sot7ejttmJxtYOnG9xoaHVdeFr1/fnW1xocnbCI4CGFhcaWlx+I+g6tbJrxfYLBfaYaD2So8L4LPMBwLd6OaeXExGRxFh0ExFRn6JSKmDS62DS65Ay9MrtXZ0eNLa5cL6lAw0tLpxvdcEjBJKjwhAfGcpV1Qeo39w1HjWOdgyLCJE7FCIi6udYdBMRUb+mCbo4vZ3Ia9a4a1urgIiI6GoFfulXIiIiIiIiIgLAopuIiIiIiIhIMiy6iYiIiIiIiCTCopuIiIiIiIhIIiy6iYiIiIiIiCTCopuIiIiIiIhIIiy6iYiIqFvr1q1DXFwcdDod0tPTcejQoe9s39jYiOzsbFgsFmi1WiQmJmLXrl3XdEwiIqK+jkU3ERERXWLLli1YvHgxVq5ciSNHjiA1NRUzZ86EzWbrtr3L5cKMGTPwzTffYNu2bSgqKsKGDRsQExPT42MSERH1BwohhJA7iN7kcDhgMBhgt9uh1+vlDoeIiAaYvpKH0tPTMXHiRLz22msAAI/Hg9jYWPziF7/AsmXLLmm/fv16vPjiiygsLIRarQ7IMf9VX+k7IiLqn3qahzjSTURERH5cLhcKCgqQmZnp26dUKpGZmYn8/PxuP/Pee+8hIyMD2dnZMJvNGDduHFatWgW3293jYxIREfUHQXIHQERERNeXuro6uN1umM1mv/1msxmFhYXdfqa0tBSfffYZHnroIezatQslJSV4/PHH0dHRgZUrV/bomE6nE06n0/e9w+G4xjMjIiLqfRzpJiIiomvm8XhgMpnwxhtvIC0tDVlZWXj66aexfv36Hh8zJycHBoPBt8XGxgYwYiIiot7BopuIiIj8REZGQqVSoaamxm9/TU0NoqKiuv2MxWJBYmIiVCqVb9/o0aNhtVrhcrl6dMzly5fDbrf7toqKims8MyIiot7HopuIiIj8aDQapKWlYc+ePb59Ho8He/bsQUZGRrefmTx5MkpKSuDxeHz7iouLYbFYoNFoenRMrVYLvV7vtxEREfU1LLqJiIjoEosXL8aGDRvw1ltv4fTp01iwYAFaWlrw8MMPAwDmzp2L5cuX+9ovWLAADQ0NWLhwIYqLi7Fz506sWrUK2dnZV31MIiKi/mjALaTmfUIaF2MhIiI5ePPP9f7EzqysLNTW1mLFihWwWq2YMGECdu/e7VsIrby8HErlxb/dx8bG4qOPPsKiRYuQkpKCmJgYLFy4EEuXLr3qY14JczgREcmppzl8wD2nu7KykguxEBGR7CoqKjB06FC5w+hTmMOJiOh68H1z+IAruj0eD6qqqhAWFgaFQnFNx3I4HIiNjUVFRcWAvs+M/cA+8GI/sA+82A+X7wMhBJqamhAdHe03UkxXxhweeOwH9oEX+4F94MV+CHwOH3DTy5VKZcBHFri4Sxf2A/vAi/3APvBiP3TfBwaDQaZo+jbmcOmwH9gHXuwH9oEX+yFwOZx/YiciIiIiIiKSCItuIiIiIiIiIomw6L4GWq0WK1euhFarlTsUWbEf2Ade7Af2gRf7gX1wveO/Txf2A/vAi/3APvBiPwS+DwbcQmpEREREREREvYUj3UREREREREQSYdFNREREREREJBEW3UREREREREQSYdF9DdatW4e4uDjodDqkp6fj0KFDcofUa5599lkoFAq/LTk5We6wJPf555/jzjvvRHR0NBQKBf7+97/7vS+EwIoVK2CxWBAcHIzMzEycOXNGnmAldKV++NnPfnbJ9TFr1ix5gpVITk4OJk6ciLCwMJhMJtx1110oKirya9Pe3o7s7GwMGTIEoaGhuPfee1FTUyNTxIF3NX0wbdq0S66Fxx57TKaIpfH6668jJSXF9yzPjIwMfPjhh773+/t10FcxhzOHD8QczvzdhTmcOdyrt3I4i+4e2rJlCxYvXoyVK1fiyJEjSE1NxcyZM2Gz2eQOrdeMHTsW1dXVvu2LL76QOyTJtbS0IDU1FevWrev2/TVr1uDVV1/F+vXrcfDgQQwaNAgzZ85Ee3t7L0cqrSv1AwDMmjXL7/rYtGlTL0Yovby8PGRnZ+PAgQP45JNP0NHRgTvuuAMtLS2+NosWLcL777+PrVu3Ii8vD1VVVbjnnntkjDqwrqYPAOCRRx7xuxbWrFkjU8TSGDp0KFavXo2CggIcPnwYt99+O+bMmYNTp04B6P/XQV/EHM4c3p2BkMOZv7swhzOHe/VaDhfUI5MmTRLZ2dm+791ut4iOjhY5OTkyRtV7Vq5cKVJTU+UOQ1YAxPbt233fezweERUVJV588UXfvsbGRqHVasWmTZtkiLB3/Gs/CCHEvHnzxJw5c2SJRy42m00AEHl5eUKIrn97tVottm7d6mtz+vRpAUDk5+fLFaak/rUPhBBi6tSpYuHChfIFJZPBgweLP/3pTwPyOugLmMOZw5nDmb//GXM4c/g/kyKHc6S7B1wuFwoKCpCZmenbp1QqkZmZifz8fBkj611nzpxBdHQ0RowYgYceegjl5eVyhySrsrIyWK1Wv+vCYDAgPT19QF0XXrm5uTCZTEhKSsKCBQtQX18vd0iSstvtAICIiAgAQEFBATo6Ovyuh+TkZAwbNqzfXg//2gdef/nLXxAZGYlx48Zh+fLlaG1tlSO8XuF2u7F582a0tLQgIyNjQF4H1zvm8C7M4f6Ywy8aaPkbYA4HmMMBaXN4UKCDHQjq6urgdrthNpv99pvNZhQWFsoUVe9KT0/Hxo0bkZSUhOrqajz33HO45ZZbcPLkSYSFhckdniysVisAdHtdeN8bKGbNmoV77rkH8fHxOHv2LH79619j9uzZyM/Ph0qlkju8gPN4PPjVr36FyZMnY9y4cQC6rgeNRoPw8HC/tv31euiuDwDgwQcfxPDhwxEdHY3jx49j6dKlKCoqwrvvvitjtIF34sQJZGRkoL29HaGhodi+fTvGjBmDY8eODajroC9gDmcO7w5zeJeBlr8B5nCAObw3cjiLbuqR2bNn+16npKQgPT0dw4cPxzvvvIOf//znMkZG14P777/f93r8+PFISUnByJEjkZubi+nTp8sYmTSys7Nx8uTJAXFP5OVcrg8effRR3+vx48fDYrFg+vTpOHv2LEaOHNnbYUomKSkJx44dg91ux7Zt2zBv3jzk5eXJHRZRt5jD6XIGWv4GmMMB5vDeyOGcXt4DkZGRUKlUl6xcV1NTg6ioKJmikld4eDgSExNRUlIidyiy8f7b87q41IgRIxAZGdkvr48nnngCH3zwAfbu3YuhQ4f69kdFRcHlcqGxsdGvfX+8Hi7XB91JT08HgH53LWg0GiQkJCAtLQ05OTlITU3F7373uwF1HfQVzOGXYg5nDr+c/py/AeZwgDkc6J0czqK7BzQaDdLS0rBnzx7fPo/Hgz179iAjI0PGyOTT3NyMs2fPwmKxyB2KbOLj4xEVFeV3XTgcDhw8eHDAXhdelZWVqK+v71fXhxACTzzxBLZv347PPvsM8fHxfu+npaVBrVb7XQ9FRUUoLy/vN9fDlfqgO8eOHQOAfnUtdMfj8cDpdA6I66CvYQ6/FHM4c/jl9Mf8DTCHA8zh30WSHB7Ild4Gks2bNwutVis2btwovv76a/Hoo4+K8PBwYbVa5Q6tVzz55JMiNzdXlJWViX379onMzEwRGRkpbDab3KFJqqmpSRw9elQcPXpUABAvv/yyOHr0qPj222+FEEKsXr1ahIeHix07dojjx4+LOXPmiPj4eNHW1iZz5IH1Xf3Q1NQklixZIvLz80VZWZn49NNPxY033ihGjRol2tvb5Q49YBYsWCAMBoPIzc0V1dXVvq21tdXX5rHHHhPDhg0Tn332mTh8+LDIyMgQGRkZMkYdWFfqg5KSEvH888+Lw4cPi7KyMrFjxw4xYsQIceutt8oceWAtW7ZM5OXlibKyMnH8+HGxbNkyoVAoxMcffyyE6P/XQV/EHM4cPlBzOPN3F+Zw5nCv3srhLLqvwe9//3sxbNgwodFoxKRJk8SBAwfkDqnXZGVlCYvFIjQajYiJiRFZWVmipKRE7rAkt3fvXgHgkm3evHlCiK5HjjzzzDPCbDYLrVYrpk+fLoqKiuQNWgLf1Q+tra3ijjvuEEajUajVajF8+HDxyCOP9LtfZrs7fwDiz3/+s69NW1ubePzxx8XgwYNFSEiIuPvuu0V1dbV8QQfYlfqgvLxc3HrrrSIiIkJotVqRkJAgnnrqKWG32+UNPMDmz58vhg8fLjQajTAajWL69Om+ZC1E/78O+irmcObwgZjDmb+7MIczh3v1Vg5XCCHE9xsbJyIiIiIiIqKrwXu6iYiIiIiIiCTCopuIiIiIiIhIIiy6iYiIiIiIiCTCopuIiIiIiIhIIiy6iYiIiIiIiCTCopuIiIiIiIhIIiy6iYiIiIiIiCTCopuIiIiIiIhIIiy6iahX5ObmQqFQoLGxUe5QiIiI6HtgDie6Niy6iYiIiIiIiCTCopuIiIiIiIhIIiy6iQYIj8eDnJwcxMfHIzg4GKmpqdi2bRuAi9PGdu7ciZSUFOh0OvzgBz/AyZMn/Y7xt7/9DWPHjoVWq0VcXBzWrl3r977T6cTSpUsRGxsLrVaLhIQE/Pd//7dfm4KCAtx0000ICQnBzTffjKKiImlPnIiIqI9jDifq21h0Ew0QOTk5ePvtt7F+/XqcOnUKixYtwr//+78jLy/P1+app57C2rVr8eWXX8JoNOLOO+9ER0cHgK5Ee9999+H+++/HiRMn8Oyzz+KZZ57Bxo0bfZ+fO3cuNm3ahFdffRWnT5/GH//4R4SGhvrF8fTTT2Pt2rU4fPgwgoKCMH/+/F45fyIior6KOZyojxNE1O+1t7eLkJAQsX//fr/9P//5z8UDDzwg9u7dKwCIzZs3+96rr68XwcHBYsuWLUIIIR588EExY8YMv88/9dRTYsyYMUIIIYqKigQA8cknn3Qbg/dnfPrpp759O3fuFABEW1tbQM6TiIiov2EOJ+r7ONJNNACUlJSgtbUVM2bMQGhoqG97++23cfbsWV+7jIwM3+uIiAgkJSXh9OnTAIDTp09j8uTJfsedPHkyzpw5A7fbjWPHjkGlUmHq1KnfGUtKSorvtcViAQDYbLZrPkciIqL+iDmcqO8LkjsAIpJec3MzAGDnzp2IiYnxe0+r1fol7Z4KDg6+qnZqtdr3WqFQAOi6V42IiIguxRxO1PdxpJtoABgzZgy0Wi3Ky8uRkJDgt8XGxvraHThwwPf6/PnzKC4uxujRowEAo0ePxr59+/yOu2/fPiQmJkKlUmH8+PHweDx+95cRERHRtWEOJ+r7ONJNNACEhYVhyZIlWLRoETweD6ZMmQK73Y59+/ZBr9dj+PDhAIDnn38eQ4YMgdlsxtNPP43IyEjcddddAIAnn3wSEydOxAsvvICsrCzk5+fjtddewx/+8AcAQFxcHObNm4f58+fj1VdfRWpqKr799lvYbDbcd999cp06ERFRn8YcTtQPyH1TORH1Do/HI1555RWRlJQk1Gq1MBqNYubMmSIvL8+3QMr7778vxo4dKzQajZg0aZL46quv/I6xbds2MWbMGKFWq8WwYcPEiy++6Pd+W1ubWLRokbBYLEKj0YiEhATx5ptvCiEuLsJy/vx5X/ujR48KAKKsrEzq0yciIuqzmMOJ+jaFEELIWfQTkfxyc3Nx22234fz58wgPD5c7HCIiIrpKzOFE1z/e001EREREREQkERbdRERERERERBLh9HIiIiIiIiIiiXCkm4iIiIiIiEgiLLqJiIiIiIiIJMKim4iIiIiIiEgiLLqJiIiIiIiIJMKim4iIiIiIiEgiLLqJiIiIiIiIJMKim4iIiIiIiEgiLLqJiIiIiIiIJMKim4iIiIiIiEgi/x+I0839B4c0cAAAAABJRU5ErkJggg==\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データの正解率: 0.9985\n",
+            "検証データの正解率: 0.8321\n",
+            "テストデータの正解率: 0.8403\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "D3W_cKr_XQdh",
+        "outputId": "b7c171e7-df83-4cd2-f06f-28773961d08b"
+      },
+      "execution_count": 34,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install torchinfo"
+      ],
+      "metadata": {
+        "id": "GJp3iMQQKqVL",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6b85c896-568c-4403-bf59-d84567bfe03e"
+      },
+      "execution_count": 35,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: torchinfo in /usr/local/lib/python3.10/dist-packages (1.8.0)\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/shota/chapter09/knock88.ipynb b/shota/chapter09/knock88.ipynb
new file mode 100644
index 0000000..0939a56
--- /dev/null
+++ b/shota/chapter09/knock88.ipynb
@@ -0,0 +1,741 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU"
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u3LQlfugXBRi",
+        "outputId": "d2b7bd4c-65ce-4b91-f41b-f5d497d16ec3"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データ\n",
+            "CATEGORY\n",
+            "b    4502\n",
+            "e    4223\n",
+            "t    1219\n",
+            "m     728\n",
+            "Name: count, dtype: int64\n",
+            "検証データ\n",
+            "CATEGORY\n",
+            "b    562\n",
+            "e    528\n",
+            "t    153\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n",
+            "評価データ\n",
+            "CATEGORY\n",
+            "b    563\n",
+            "e    528\n",
+            "t    152\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "#データの読み込み\n",
+        "import pandas as pd\n",
+        "train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/train.txt', sep=\"\\t\")\n",
+        "test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/test.txt', sep=\"\\t\")\n",
+        "valid = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/valid.txt', sep=\"\\t\")\n",
+        "# データ数の確認\n",
+        "print('学習データ')\n",
+        "print(train['CATEGORY'].value_counts())\n",
+        "print('検証データ')\n",
+        "print(valid['CATEGORY'].value_counts())\n",
+        "print('評価データ')\n",
+        "print(test['CATEGORY'].value_counts())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語の辞書を作成\n",
+        "from collections import Counter\n",
+        "words = []\n",
+        "for text in train['TITLE']:                #訓練データから文章を1つずつ取り出す\n",
+        "    for word in text.rstrip().split():     #文章を単語に分解\n",
+        "        words.append(word)                 #単語をリストに追加\n",
+        "c = Counter(words)                         #単語の出現回数を数える\n",
+        "print(c.most_common(10))                   #頻度上位10単語\n",
+        "word2id = {}                               #単語IDの辞書\n",
+        "for i, cnt in enumerate(c.most_common()):  #頻度上位10単語分繰り返す\n",
+        "    if cnt[1] > 1:                         #出現回数が1より大きい単語のみ\n",
+        "        word2id[cnt[0]] = i + 1            #辞書に単語とIDを紐付ける\n",
+        "for i, cnt in enumerate(word2id.items()):  #辞書の中身を確認\n",
+        "    if i >= 10:                            #10単語だけ表示\n",
+        "        break                              #for文を抜ける\n",
+        "    print(cnt[0], cnt[1])                  #単語とIDを表示"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "BaoFH2FcaZcJ",
+        "outputId": "12b687be-da12-42ea-ff91-e1711c2801be"
+      },
+      "execution_count": 9,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "[('to', 2151), ('...', 2031), ('in', 1415), ('as', 1027), ('on', 1025), ('UPDATE', 1000), ('-', 991), ('for', 969), ('of', 957), ('The', 859)]\n",
+            "to 1\n",
+            "... 2\n",
+            "in 3\n",
+            "as 4\n",
+            "on 5\n",
+            "UPDATE 6\n",
+            "- 7\n",
+            "for 8\n",
+            "of 9\n",
+            "The 10\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 単語のID化\n",
+        "def tokenizer(text):                                 #単語IDのリストを返す関数\n",
+        "    words = text.rstrip().split()                    #単語に分解\n",
+        "    return [word2id.get(word, 0) for word in words]  #単語のIDに変換\n",
+        "\n",
+        "sample = train.at[0, 'TITLE']                        #学習データの1つ目の文章\n",
+        "print(sample)                                        #文章を表示\n",
+        "print(tokenizer(sample))                             #文章を単語IDに変換"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d-hhnRWjagOZ",
+        "outputId": "22eb39e1-08ad-48d3-987e-65c038720d51"
+      },
+      "execution_count": 10,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Justin Bieber Under Investigation For Attempted Robbery At Dave & Buster's\n",
+            "[66, 79, 733, 2094, 21, 4933, 6674, 35, 1514, 86, 0]\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# RNNの作成\n",
+        "# モデルの構築\n",
+        "import random\n",
+        "import torch\n",
+        "from torch import nn\n",
+        "import torch.utils.data as data\n",
+        "from torchinfo import summary\n",
+        "import numpy as np\n",
+        "\n",
+        "# 乱数のシードを設定\n",
+        "# parserなどで指定\n",
+        "seed = 1234\n",
+        "\n",
+        "random.seed(seed)                                   # Python標準ライブラリの乱数のシードを設定\n",
+        "np.random.seed(seed)                                # Numpy乱数のシードを設定\n",
+        "torch.manual_seed(seed)                             # PyTorch乱数のシードを設定\n",
+        "torch.cuda.manual_seed(seed)                        # PyTorchのCUDA乱数のシードを設定\n",
+        "torch.backends.cudnn.benchmark = False              # PyTorchのCUDNNのベンチマークを使用しない  (cudnn内の非決定的な処理の固定化)\n",
+        "torch.backends.cudnn.deterministic = True           # PyTorchのCUDNNの定着を使用\n",
+        "\n",
+        "def seed_worker(worker_id):\n",
+        "    worker_seed = torch.initial_seed() % 2**32      # 乱数生成のシードの初期値を設定\n",
+        "    np.random.seed(worker_seed)                     # Numpy乱数のシードを設定\n",
+        "    random.seed(worker_seed)                        # Python標準ライブラリの乱数のシードを設定\n",
+        "\n",
+        "g = torch.Generator()                               # PyTorch乱数のシードを設定\n",
+        "g.manual_seed(seed)                                 # 乱数生成器にシードを設定"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "HY0GKwcpKlfN",
+        "outputId": "6800f591-1306-4fe9-bfde-568e72762ce1"
+      },
+      "execution_count": 20,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<torch._C.Generator at 0x7df746d78d30>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 20
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "x = torch.tensor([tokenizer(sample)], dtype=torch.int64)                           # 文章を単語IDに変換\n",
+        "print(x)                                                                           # 文章をIDでを表示\n",
+        "print(x.size())                                                                    # 文章のサイズを確認"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "B-8OkqkTLAXg",
+        "outputId": "49e03136-fe88-47cd-a34e-37ce148eb03a"
+      },
+      "execution_count": 21,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  66,   79,  733, 2094,   21, 4933, 6674,   35, 1514,   86,    0]])\n",
+            "torch.Size([1, 11])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# ターゲットのテンソル化\n",
+        "category_dict = {'b': 0, 't': 1, 'e':2, 'm':3}\n",
+        "Y_train = torch.from_numpy(train['CATEGORY'].map(category_dict).values)\n",
+        "Y_valid = torch.from_numpy(valid['CATEGORY'].map(category_dict).values)\n",
+        "Y_test = torch.from_numpy(test['CATEGORY'].map(category_dict).values)\n",
+        "print(Y_train.size())\n",
+        "print(Y_train)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "IhA2l-VwAsr_",
+        "outputId": "7f4eaf51-d2aa-4157-d525-2c179d99617f"
+      },
+      "execution_count": 22,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([10672])\n",
+            "tensor([2, 0, 2,  ..., 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class NewsDataset(data.Dataset):\n",
+        "    \"\"\"\n",
+        "    newsのDatasetクラス\n",
+        "\n",
+        "    Attributes\n",
+        "    ----------------------------\n",
+        "    X : データフレーム\n",
+        "        単語ベクトルの平均をまとめたテンソル\n",
+        "    y : テンソル\n",
+        "        カテゴリをラベル化したテンソル\n",
+        "    phase : 'train' or 'val'\n",
+        "        学習か訓練かを設定する\n",
+        "    \"\"\"\n",
+        "    def __init__(self, X, y, phase='train'):\n",
+        "        self.X = X['TITLE']\n",
+        "        self.y = y\n",
+        "        self.phase = phase\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        \"\"\"全データサイズを返す\"\"\"\n",
+        "        return len(self.y)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        \"\"\"idxに対応するテンソル形式のデータとラベルを取得\"\"\"\n",
+        "        inputs = torch.tensor(tokenizer(self.X[idx]))\n",
+        "        return inputs, self.y[idx]\n",
+        "\n",
+        "train_dataset = NewsDataset(train, Y_train, phase='train')\n",
+        "valid_dataset = NewsDataset(valid, Y_valid, phase='val')\n",
+        "test_dataset = NewsDataset(test, Y_test, phase='val')\n",
+        "# 動作確認\n",
+        "idx = 0\n",
+        "print(train_dataset.__getitem__(idx)[0].size())\n",
+        "print(train_dataset.__getitem__(idx)[1])\n",
+        "print(valid_dataset.__getitem__(idx)[0].size())\n",
+        "print(valid_dataset.__getitem__(idx)[1])\n",
+        "print(test_dataset.__getitem__(idx)[0].size())\n",
+        "print(test_dataset.__getitem__(idx)[1])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "qMifdMwaAvji",
+        "outputId": "81a9ba7b-f0c5-4270-addc-b209b3aaf523"
+      },
+      "execution_count": 23,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([11])\n",
+            "tensor(2)\n",
+            "torch.Size([11])\n",
+            "tensor(3)\n",
+            "torch.Size([13])\n",
+            "tensor(2)\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def collate_fn(batch):\n",
+        "    sequences = [x[0] for x in batch]\n",
+        "    labels = torch.LongTensor([x[1] for x in batch])\n",
+        "    x = torch.nn.utils.rnn.pad_sequence(sequences, batch_first=True, padding_value=PADDING_IDX)\n",
+        "    return x, labels\n",
+        "\n",
+        "# DataLoaderを作成\n",
+        "batch_size = 64\n",
+        "\n",
+        "train_dataloader = data.DataLoader(\n",
+        "            train_dataset, batch_size=batch_size, shuffle=True, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "valid_dataloader = data.DataLoader(\n",
+        "            valid_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "test_dataloader = data.DataLoader(\n",
+        "            test_dataset, batch_size=batch_size, shuffle=False, collate_fn=collate_fn, worker_init_fn=seed_worker, generator=g)\n",
+        "\n",
+        "dataloaders_dict = {'train': train_dataloader,\n",
+        "                    'val': valid_dataloader,\n",
+        "                    'test': test_dataloader,\n",
+        "                   }\n",
+        "\n",
+        "# 動作確認\n",
+        "batch_iter = iter(dataloaders_dict['train'])\n",
+        "inputs, labels = next(batch_iter)\n",
+        "print(inputs)\n",
+        "print(labels)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xRSh5D22Axsg",
+        "outputId": "2ef056d9-2c38-4f53-c486-8e50ec595c8d"
+      },
+      "execution_count": 24,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[ 1136,   890,    22,  ..., 10327, 10327, 10327],\n",
+            "        [ 9241,   853,  8128,  ..., 10327, 10327, 10327],\n",
+            "        [  211,  1843,   104,  ..., 10327, 10327, 10327],\n",
+            "        ...,\n",
+            "        [ 2886,  4097,  5178,  ..., 10327, 10327, 10327],\n",
+            "        [ 2595,    40,  8576,  ..., 10327, 10327, 10327],\n",
+            "        [    6,     0,  3373,  ..., 10327, 10327, 10327]])\n",
+            "tensor([2, 2, 0, 0, 2, 1, 0, 0, 2, 1, 1, 1, 0, 2, 0, 0, 0, 0, 1, 2, 2, 2, 0, 1,\n",
+            "        0, 0, 1, 2, 1, 2, 2, 0, 2, 2, 2, 0, 0, 2, 0, 0, 0, 3, 2, 3, 1, 2, 0, 2,\n",
+            "        0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from gensim.models import KeyedVectors\n",
+        "\n",
+        "# 学習済みモデルのロード\n",
+        "file = '/content/drive/MyDrive/Colab Notebooks/chapter09/GoogleNews-vectors-negative300.bin.gz'\n",
+        "model = KeyedVectors.load_word2vec_format(file, binary=True)\n",
+        "\n",
+        "# 学習済み単語ベクトルの取得\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "weights = np.zeros((VOCAB_SIZE, EMB_SIZE))\n",
+        "words_in_pretrained = 0\n",
+        "for i, word in enumerate(word2id.keys()):\n",
+        "    try:\n",
+        "        weights[i] = model[word]\n",
+        "        words_in_pretrained += 1\n",
+        "    except KeyError:\n",
+        "        weights[i] = np.random.normal(scale=0.1, size=(EMB_SIZE,))\n",
+        "weights = torch.from_numpy(weights.astype((np.float32)))\n",
+        "\n",
+        "print(f'学習済みベクトル利用単語数: {words_in_pretrained} / {VOCAB_SIZE}')\n",
+        "print(weights.size())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "zLn_cZ71QGqD",
+        "outputId": "29eba55b-a1c1-4879-88c7-2e6005d674ed"
+      },
+      "execution_count": 25,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習済みベクトル利用単語数: 8340 / 10328\n",
+            "torch.Size([10328, 300])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def calc_acc(net, dataloader):\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    net.eval()\n",
+        "    corrects = 0\n",
+        "    with torch.no_grad():\n",
+        "        for inputs, labels in dataloader:\n",
+        "            inputs = inputs.to(device)\n",
+        "            labels = labels.to(device)\n",
+        "            outputs = net(inputs)\n",
+        "            _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "            corrects += torch.sum(preds == labels.data).cpu()\n",
+        "    return corrects / len(dataloader.dataset)"
+      ],
+      "metadata": {
+        "id": "orK8m3eSRY11"
+      },
+      "execution_count": 26,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 学習を実行する\n",
+        "# 学習用の関数を定義\n",
+        "def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):\n",
+        "\n",
+        "    # 初期設定\n",
+        "    # GPUが使えるか確認\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    print(torch.cuda.get_device_name())\n",
+        "    print(\"使用デバイス:\", device)\n",
+        "\n",
+        "    # ネットワークをgpuへ\n",
+        "    net.to(device)\n",
+        "\n",
+        "    train_loss = []\n",
+        "    train_acc = []\n",
+        "    valid_loss = []\n",
+        "    valid_acc = []\n",
+        "\n",
+        "    # epochのループ\n",
+        "    for epoch in range(num_epochs):\n",
+        "        # epochごとの学習と検証のループ\n",
+        "        for phase in ['train', 'val']:\n",
+        "            if phase == 'train':\n",
+        "                net.train() # 訓練モード\n",
+        "            else:\n",
+        "                net.eval() # 検証モード\n",
+        "\n",
+        "            epoch_loss = 0.0 # epochの損失和\n",
+        "            epoch_corrects = 0 # epochの正解数\n",
+        "\n",
+        "            # データローダーからミニバッチを取り出すループ\n",
+        "            for inputs, labels in dataloaders_dict[phase]:\n",
+        "                # GPUが使えるならGPUにおっくる\n",
+        "                inputs = inputs.to(device)\n",
+        "                labels = labels.to(device)\n",
+        "                optimizer.zero_grad() # optimizerを初期化\n",
+        "\n",
+        "                # 順伝播計算(forward)\n",
+        "                with torch.set_grad_enabled(phase == 'train'):\n",
+        "                    outputs = net(inputs)\n",
+        "                    loss = criterion(outputs, labels) # 損失を計算\n",
+        "                    _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "\n",
+        "                    # 訓練時は逆伝播\n",
+        "                    if phase == 'train':\n",
+        "                        loss.backward()\n",
+        "                        optimizer.step()\n",
+        "\n",
+        "                    # イテレーション結果の計算\n",
+        "                    # lossの合計を更新\n",
+        "                    epoch_loss += loss.item() * inputs.size(0)\n",
+        "                    # 正解数の合計を更新\n",
+        "                    epoch_corrects += torch.sum(preds == labels.data)\n",
+        "\n",
+        "            # epochごとのlossと正解率の表示\n",
+        "            epoch_loss = epoch_loss / len(dataloaders_dict[phase].dataset)\n",
+        "            epoch_acc = epoch_corrects.double() / len(dataloaders_dict[phase].dataset)\n",
+        "            if phase == 'train':\n",
+        "                train_loss.append(epoch_loss)\n",
+        "                train_acc.append(epoch_acc.cpu())\n",
+        "            else:\n",
+        "                valid_loss.append(epoch_loss)\n",
+        "                valid_acc.append(epoch_acc.cpu())\n",
+        "\n",
+        "        print('Epoch {} / {} (train) Loss: {:.4f}, Acc: {:.4f}, (val) Loss: {:.4f}, Acc: {:.4f}'.format(epoch + 1, num_epochs, train_loss[-1], train_acc[-1], valid_loss[-1], valid_acc[-1]))\n",
+        "    return train_loss, train_acc, valid_loss, valid_acc"
+      ],
+      "metadata": {
+        "id": "T-hgB0t7Tf_h"
+      },
+      "execution_count": 27,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "class CNN(nn.Module):\n",
+        "    def __init__(self, vocab_size, emb_size, padding_idx, output_size, out_channels, kernel_heights, stride, padding, emb_weights=None):\n",
+        "        super().__init__()\n",
+        "        if emb_weights != None:  # 指定があれば埋め込み層の重みをemb_weightsで初期化\n",
+        "            self.emb = nn.Embedding.from_pretrained(emb_weights, padding_idx=padding_idx)\n",
+        "        else:\n",
+        "            self.emb = nn.Embedding(vocab_size, emb_size, padding_idx=padding_idx)\n",
+        "        self.conv = nn.Conv2d(1, out_channels, (kernel_heights, emb_size), stride, (padding, 0))\n",
+        "        self.drop = nn.Dropout(0.4)\n",
+        "        self.fc = nn.Linear(out_channels, output_size)\n",
+        "\n",
+        "    def forward(self, x):\n",
+        "        emb = self.emb(x).unsqueeze(1)\n",
+        "        conv = self.conv(emb)\n",
+        "        act = F.relu(conv.squeeze(3))\n",
+        "        max_pool = F.max_pool1d(act, act.size()[2])\n",
+        "        logits = self.fc(self.drop(max_pool.squeeze(2)))\n",
+        "        return logits\n",
+        "\n",
+        "# パラメータの設定\n",
+        "VOCAB_SIZE = len(set(word2id.values())) + 2\n",
+        "EMB_SIZE = 300\n",
+        "PADDING_IDX = len(set(word2id.values())) + 1\n",
+        "OUTPUT_SIZE = 4\n",
+        "OUT_CHANNELS = 500\n",
+        "KERNEL_HEIGHTS = 2\n",
+        "STRIDE = 1\n",
+        "PADDING = 1\n",
+        "\n",
+        "# モデルの定義\n",
+        "net = CNN(VOCAB_SIZE, EMB_SIZE, PADDING_IDX, OUTPUT_SIZE, OUT_CHANNELS, KERNEL_HEIGHTS, STRIDE, PADDING, emb_weights=weights)\n",
+        "net.train()\n",
+        "\n",
+        "# 損失関数の定義\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "\n",
+        "# 最適化手法の定義\n",
+        "optimizer = torch.optim.Adam(net.parameters(), lr=0.0005)\n",
+        "\n",
+        "num_epochs = 30\n",
+        "train_loss, train_acc, valid_loss, valid_acc = train_model(net,\n",
+        "            dataloaders_dict, criterion, optimizer, num_epochs=num_epochs)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wWmrRsDCXMxQ",
+        "outputId": "1264484a-2b5f-40b4-e406-1926fc97ecd3"
+      },
+      "execution_count": 36,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Tesla T4\n",
+            "使用デバイス: cuda:0\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/torch/autograd/graph.py:744: UserWarning: Plan failed with a cudnnException: CUDNN_BACKEND_EXECUTION_PLAN_DESCRIPTOR: cudnnFinalize Descriptor Failed cudnn_status: CUDNN_STATUS_NOT_SUPPORTED (Triggered internally at ../aten/src/ATen/native/cudnn/Conv_v8.cpp:919.)\n",
+            "  return Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1 / 30 (train) Loss: 1.0401, Acc: 0.6104, (val) Loss: 0.8848, Acc: 0.6942\n",
+            "Epoch 2 / 30 (train) Loss: 0.7863, Acc: 0.7233, (val) Loss: 0.7199, Acc: 0.7459\n",
+            "Epoch 3 / 30 (train) Loss: 0.6295, Acc: 0.7732, (val) Loss: 0.6333, Acc: 0.7781\n",
+            "Epoch 4 / 30 (train) Loss: 0.5102, Acc: 0.8246, (val) Loss: 0.5731, Acc: 0.8006\n",
+            "Epoch 5 / 30 (train) Loss: 0.4176, Acc: 0.8620, (val) Loss: 0.5390, Acc: 0.8066\n",
+            "Epoch 6 / 30 (train) Loss: 0.3471, Acc: 0.8890, (val) Loss: 0.5067, Acc: 0.8186\n",
+            "Epoch 7 / 30 (train) Loss: 0.2826, Acc: 0.9174, (val) Loss: 0.4826, Acc: 0.8216\n",
+            "Epoch 8 / 30 (train) Loss: 0.2420, Acc: 0.9339, (val) Loss: 0.4710, Acc: 0.8283\n",
+            "Epoch 9 / 30 (train) Loss: 0.2017, Acc: 0.9483, (val) Loss: 0.4600, Acc: 0.8321\n",
+            "Epoch 10 / 30 (train) Loss: 0.1681, Acc: 0.9600, (val) Loss: 0.4504, Acc: 0.8351\n",
+            "Epoch 11 / 30 (train) Loss: 0.1437, Acc: 0.9673, (val) Loss: 0.4496, Acc: 0.8426\n",
+            "Epoch 12 / 30 (train) Loss: 0.1218, Acc: 0.9747, (val) Loss: 0.4425, Acc: 0.8486\n",
+            "Epoch 13 / 30 (train) Loss: 0.1013, Acc: 0.9814, (val) Loss: 0.4503, Acc: 0.8448\n",
+            "Epoch 14 / 30 (train) Loss: 0.0871, Acc: 0.9849, (val) Loss: 0.4471, Acc: 0.8478\n",
+            "Epoch 15 / 30 (train) Loss: 0.0773, Acc: 0.9869, (val) Loss: 0.4417, Acc: 0.8426\n",
+            "Epoch 16 / 30 (train) Loss: 0.0685, Acc: 0.9888, (val) Loss: 0.4487, Acc: 0.8471\n",
+            "Epoch 17 / 30 (train) Loss: 0.0577, Acc: 0.9926, (val) Loss: 0.4469, Acc: 0.8508\n",
+            "Epoch 18 / 30 (train) Loss: 0.0508, Acc: 0.9937, (val) Loss: 0.4524, Acc: 0.8501\n",
+            "Epoch 19 / 30 (train) Loss: 0.0464, Acc: 0.9940, (val) Loss: 0.4536, Acc: 0.8508\n",
+            "Epoch 20 / 30 (train) Loss: 0.0399, Acc: 0.9953, (val) Loss: 0.4577, Acc: 0.8538\n",
+            "Epoch 21 / 30 (train) Loss: 0.0398, Acc: 0.9956, (val) Loss: 0.4652, Acc: 0.8531\n",
+            "Epoch 22 / 30 (train) Loss: 0.0341, Acc: 0.9961, (val) Loss: 0.4595, Acc: 0.8546\n",
+            "Epoch 23 / 30 (train) Loss: 0.0322, Acc: 0.9956, (val) Loss: 0.4674, Acc: 0.8568\n",
+            "Epoch 24 / 30 (train) Loss: 0.0287, Acc: 0.9963, (val) Loss: 0.4767, Acc: 0.8508\n",
+            "Epoch 25 / 30 (train) Loss: 0.0276, Acc: 0.9962, (val) Loss: 0.4809, Acc: 0.8546\n",
+            "Epoch 26 / 30 (train) Loss: 0.0266, Acc: 0.9963, (val) Loss: 0.4698, Acc: 0.8576\n",
+            "Epoch 27 / 30 (train) Loss: 0.0244, Acc: 0.9970, (val) Loss: 0.4829, Acc: 0.8576\n",
+            "Epoch 28 / 30 (train) Loss: 0.0224, Acc: 0.9971, (val) Loss: 0.4897, Acc: 0.8561\n",
+            "Epoch 29 / 30 (train) Loss: 0.0224, Acc: 0.9971, (val) Loss: 0.5027, Acc: 0.8568\n",
+            "Epoch 30 / 30 (train) Loss: 0.0204, Acc: 0.9980, (val) Loss: 0.5165, Acc: 0.8516\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "fig, ax = plt.subplots(1,2, figsize=(10, 5))\n",
+        "epochs = np.arange(num_epochs)\n",
+        "ax[0].plot(epochs, train_loss, label='train')\n",
+        "ax[0].plot(epochs, valid_loss, label='valid')\n",
+        "ax[0].set_title('loss')\n",
+        "ax[0].set_xlabel('epoch')\n",
+        "ax[0].set_ylabel('loss')\n",
+        "ax[1].plot(epochs, train_acc, label='train')\n",
+        "ax[1].plot(epochs, valid_acc, label='valid')\n",
+        "ax[1].set_title('acc')\n",
+        "ax[1].set_xlabel('epoch')\n",
+        "ax[1].set_ylabel('acc')\n",
+        "ax[0].legend(loc='best')\n",
+        "ax[1].legend(loc='best')\n",
+        "plt.tight_layout()\n",
+        "plt.savefig('fig87.png')\n",
+        "plt.show()\n",
+        "\n",
+        "acc_train = calc_acc(net, train_dataloader)\n",
+        "acc_valid = calc_acc(net, valid_dataloader)\n",
+        "acc_test = calc_acc(net, test_dataloader)\n",
+        "print('学習データの正解率: {:.4f}'.format(acc_train))\n",
+        "print('検証データの正解率: {:.4f}'.format(acc_valid))\n",
+        "print('テストデータの正解率: {:.4f}'.format(acc_test))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 559
+        },
+        "id": "YeQl8S9uaYra",
+        "outputId": "5c8743a9-1820-4899-9aaf-027004cafaf2"
+      },
+      "execution_count": 37,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データの正解率: 0.9991\n",
+            "検証データの正解率: 0.8516\n",
+            "テストデータの正解率: 0.8658\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "D3W_cKr_XQdh",
+        "outputId": "b7c171e7-df83-4cd2-f06f-28773961d08b"
+      },
+      "execution_count": 34,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install torchinfo"
+      ],
+      "metadata": {
+        "id": "GJp3iMQQKqVL",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "6b85c896-568c-4403-bf59-d84567bfe03e"
+      },
+      "execution_count": 35,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: torchinfo in /usr/local/lib/python3.10/dist-packages (1.8.0)\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/shota/chapter09/knock89.ipynb b/shota/chapter09/knock89.ipynb
new file mode 100644
index 0000000..4271ab2
--- /dev/null
+++ b/shota/chapter09/knock89.ipynb
@@ -0,0 +1,2423 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "T4"
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    },
+    "accelerator": "GPU",
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "9f6b953d57a64314a6745158dd35eb03": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_fb9cb42d8b4346789e3878388da6b249",
+              "IPY_MODEL_97cc5a96765e4a8d88edc276ba8d660e",
+              "IPY_MODEL_86da61bd877a4b93b47c4fa50a98c3a4"
+            ],
+            "layout": "IPY_MODEL_291bc56f6007473f92cc3ffff6c9a9c3"
+          }
+        },
+        "fb9cb42d8b4346789e3878388da6b249": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4d38cf22ddab48d296c54385a45ed8a2",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2465c3759bb844c4a29ebcabbe070ee7",
+            "value": "tokenizer_config.json: 100%"
+          }
+        },
+        "97cc5a96765e4a8d88edc276ba8d660e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_e4533a31eb19415f8c387bdd438c8860",
+            "max": 48,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_24fca98aefc845a0a8f852f0cc7f6ded",
+            "value": 48
+          }
+        },
+        "86da61bd877a4b93b47c4fa50a98c3a4": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_da317ce5b4094a329faebf540fd999f1",
+            "placeholder": "​",
+            "style": "IPY_MODEL_f68d3d5818cb4594b571db74af3ae95a",
+            "value": " 48.0/48.0 [00:00&lt;00:00, 798B/s]"
+          }
+        },
+        "291bc56f6007473f92cc3ffff6c9a9c3": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4d38cf22ddab48d296c54385a45ed8a2": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2465c3759bb844c4a29ebcabbe070ee7": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "e4533a31eb19415f8c387bdd438c8860": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "24fca98aefc845a0a8f852f0cc7f6ded": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "da317ce5b4094a329faebf540fd999f1": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f68d3d5818cb4594b571db74af3ae95a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "15f7ba799cd0434291e31b44068d95af": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_2e4d6071fb87459f80f417e6a9301508",
+              "IPY_MODEL_cb7f9ab068524581a75e7a82627fd23a",
+              "IPY_MODEL_648ff1e56d3b440a852995883f62c445"
+            ],
+            "layout": "IPY_MODEL_0006c546adca4c1189b3b67f2c36fc1b"
+          }
+        },
+        "2e4d6071fb87459f80f417e6a9301508": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9daad2e5691645768071d92dfed0c784",
+            "placeholder": "​",
+            "style": "IPY_MODEL_0713655aaff54de68d344fe97060d426",
+            "value": "vocab.txt: 100%"
+          }
+        },
+        "cb7f9ab068524581a75e7a82627fd23a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_1adc9e3830394315a7fa50a6f5695d96",
+            "max": 231508,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_8346610178c74353bb3f6a59d22f4805",
+            "value": 231508
+          }
+        },
+        "648ff1e56d3b440a852995883f62c445": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_7d56ccbb0a684068a59168d4c541ff9c",
+            "placeholder": "​",
+            "style": "IPY_MODEL_e1c07574b96743b8b8389fd28bbf1c17",
+            "value": " 232k/232k [00:00&lt;00:00, 4.99MB/s]"
+          }
+        },
+        "0006c546adca4c1189b3b67f2c36fc1b": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9daad2e5691645768071d92dfed0c784": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "0713655aaff54de68d344fe97060d426": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "1adc9e3830394315a7fa50a6f5695d96": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "8346610178c74353bb3f6a59d22f4805": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "7d56ccbb0a684068a59168d4c541ff9c": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "e1c07574b96743b8b8389fd28bbf1c17": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "f57c52aa284e4250a0bcee30d6d84487": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_3980a0a6288143afa97c2d2b5a65074d",
+              "IPY_MODEL_2cbd6d1c77e0406386f8a2b16455b948",
+              "IPY_MODEL_109b206270ff467ead91048552520e39"
+            ],
+            "layout": "IPY_MODEL_79a2a2f6d999445baca555e53713f0f8"
+          }
+        },
+        "3980a0a6288143afa97c2d2b5a65074d": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_88146d86eea14eba9fed6d676b733a93",
+            "placeholder": "​",
+            "style": "IPY_MODEL_08372744e3ce4c36b555eefda43fe3e6",
+            "value": "tokenizer.json: 100%"
+          }
+        },
+        "2cbd6d1c77e0406386f8a2b16455b948": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_eea84f8807cf43b48bd617344dcb5eee",
+            "max": 466062,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_1c6ae3efca054fbe8254cef989ea562a",
+            "value": 466062
+          }
+        },
+        "109b206270ff467ead91048552520e39": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_400415e19d9043789abd0849129cdb19",
+            "placeholder": "​",
+            "style": "IPY_MODEL_3c72ec49060d4415a957462e4c007189",
+            "value": " 466k/466k [00:00&lt;00:00, 8.02MB/s]"
+          }
+        },
+        "79a2a2f6d999445baca555e53713f0f8": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "88146d86eea14eba9fed6d676b733a93": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "08372744e3ce4c36b555eefda43fe3e6": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "eea84f8807cf43b48bd617344dcb5eee": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "1c6ae3efca054fbe8254cef989ea562a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "400415e19d9043789abd0849129cdb19": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "3c72ec49060d4415a957462e4c007189": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "904a7075d1df4c8ca4dfc53da83010eb": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_46fdb70c3e3b48f4ab5604072390de16",
+              "IPY_MODEL_d99bfdfaaaad482daa7c2f4af5e56e84",
+              "IPY_MODEL_d4cf66a1ca1a466d8358ce65aeb5a04e"
+            ],
+            "layout": "IPY_MODEL_8e9f953ba632411eaf57ddcc9e112ed7"
+          }
+        },
+        "46fdb70c3e3b48f4ab5604072390de16": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_ec62a42aa6954771bae5e02f3dd64ffe",
+            "placeholder": "​",
+            "style": "IPY_MODEL_7e69bd39109146c1aa8a9722c7b4361c",
+            "value": "config.json: 100%"
+          }
+        },
+        "d99bfdfaaaad482daa7c2f4af5e56e84": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_c4ac2c4bce1147c089721a1637140dff",
+            "max": 570,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_ff9ea2ccbf90411083fa58d2da395e3a",
+            "value": 570
+          }
+        },
+        "d4cf66a1ca1a466d8358ce65aeb5a04e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_4d7df12b08034e7dbb5e15fad37e279e",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2f4f87a0908d49b9b19bb9d143558372",
+            "value": " 570/570 [00:00&lt;00:00, 10.8kB/s]"
+          }
+        },
+        "8e9f953ba632411eaf57ddcc9e112ed7": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ec62a42aa6954771bae5e02f3dd64ffe": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "7e69bd39109146c1aa8a9722c7b4361c": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "c4ac2c4bce1147c089721a1637140dff": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "ff9ea2ccbf90411083fa58d2da395e3a": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "4d7df12b08034e7dbb5e15fad37e279e": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2f4f87a0908d49b9b19bb9d143558372": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "5355fbd4e6ce40d991d58840c91d7645": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HBoxModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HBoxModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HBoxView",
+            "box_style": "",
+            "children": [
+              "IPY_MODEL_33f8eef647d14bccb306f30f4056fd28",
+              "IPY_MODEL_46919043957c490896dc259ae76020a8",
+              "IPY_MODEL_20da727e862c4a28b7b2cd0421ae7ad5"
+            ],
+            "layout": "IPY_MODEL_6ea0c4b89bae428a8dfa5282559a5a4f"
+          }
+        },
+        "33f8eef647d14bccb306f30f4056fd28": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_9ae1b401042046889490b9afc7862849",
+            "placeholder": "​",
+            "style": "IPY_MODEL_2bf50af7ac6945579679217da95a37b0",
+            "value": "model.safetensors: 100%"
+          }
+        },
+        "46919043957c490896dc259ae76020a8": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "FloatProgressModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "FloatProgressModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "ProgressView",
+            "bar_style": "success",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_73a541b996374260a9397b49d70b334a",
+            "max": 440449768,
+            "min": 0,
+            "orientation": "horizontal",
+            "style": "IPY_MODEL_f80bd65f09e74216ae2cb5ed410e7e8b",
+            "value": 440449768
+          }
+        },
+        "20da727e862c4a28b7b2cd0421ae7ad5": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "HTMLModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_dom_classes": [],
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "HTMLModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/controls",
+            "_view_module_version": "1.5.0",
+            "_view_name": "HTMLView",
+            "description": "",
+            "description_tooltip": null,
+            "layout": "IPY_MODEL_eccc4d49279e488abfcafacddf86c7ab",
+            "placeholder": "​",
+            "style": "IPY_MODEL_4ddc963ac5594e6fb868a3e98a89ac4e",
+            "value": " 440M/440M [00:07&lt;00:00, 56.5MB/s]"
+          }
+        },
+        "6ea0c4b89bae428a8dfa5282559a5a4f": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "9ae1b401042046889490b9afc7862849": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "2bf50af7ac6945579679217da95a37b0": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        },
+        "73a541b996374260a9397b49d70b334a": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "f80bd65f09e74216ae2cb5ed410e7e8b": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "ProgressStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "ProgressStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "bar_color": null,
+            "description_width": ""
+          }
+        },
+        "eccc4d49279e488abfcafacddf86c7ab": {
+          "model_module": "@jupyter-widgets/base",
+          "model_name": "LayoutModel",
+          "model_module_version": "1.2.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/base",
+            "_model_module_version": "1.2.0",
+            "_model_name": "LayoutModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "LayoutView",
+            "align_content": null,
+            "align_items": null,
+            "align_self": null,
+            "border": null,
+            "bottom": null,
+            "display": null,
+            "flex": null,
+            "flex_flow": null,
+            "grid_area": null,
+            "grid_auto_columns": null,
+            "grid_auto_flow": null,
+            "grid_auto_rows": null,
+            "grid_column": null,
+            "grid_gap": null,
+            "grid_row": null,
+            "grid_template_areas": null,
+            "grid_template_columns": null,
+            "grid_template_rows": null,
+            "height": null,
+            "justify_content": null,
+            "justify_items": null,
+            "left": null,
+            "margin": null,
+            "max_height": null,
+            "max_width": null,
+            "min_height": null,
+            "min_width": null,
+            "object_fit": null,
+            "object_position": null,
+            "order": null,
+            "overflow": null,
+            "overflow_x": null,
+            "overflow_y": null,
+            "padding": null,
+            "right": null,
+            "top": null,
+            "visibility": null,
+            "width": null
+          }
+        },
+        "4ddc963ac5594e6fb868a3e98a89ac4e": {
+          "model_module": "@jupyter-widgets/controls",
+          "model_name": "DescriptionStyleModel",
+          "model_module_version": "1.5.0",
+          "state": {
+            "_model_module": "@jupyter-widgets/controls",
+            "_model_module_version": "1.5.0",
+            "_model_name": "DescriptionStyleModel",
+            "_view_count": null,
+            "_view_module": "@jupyter-widgets/base",
+            "_view_module_version": "1.2.0",
+            "_view_name": "StyleView",
+            "description_width": ""
+          }
+        }
+      }
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "code",
+      "source": [
+        "# データのロード\n",
+        "import pandas as pd\n",
+        "import re\n",
+        "import numpy as np\n",
+        "import random\n",
+        "import transformers\n",
+        "import torch\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "from transformers import BertTokenizer, BertModel\n",
+        "from torch import optim\n",
+        "from torch import cuda\n",
+        "from torch import nn\n",
+        "from matplotlib import pyplot as plt"
+      ],
+      "metadata": {
+        "id": "ZT7t_xZmILt3"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u3LQlfugXBRi",
+        "outputId": "74e22d7c-b5bd-452e-97b0-ea822c781d6c"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データ\n",
+            "CATEGORY\n",
+            "b    4502\n",
+            "e    4223\n",
+            "t    1219\n",
+            "m     728\n",
+            "Name: count, dtype: int64\n",
+            "検証データ\n",
+            "CATEGORY\n",
+            "b    562\n",
+            "e    528\n",
+            "t    153\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n",
+            "評価データ\n",
+            "CATEGORY\n",
+            "b    563\n",
+            "e    528\n",
+            "t    152\n",
+            "m     91\n",
+            "Name: count, dtype: int64\n"
+          ]
+        }
+      ],
+      "source": [
+        "#データの読み込み\n",
+        "import pandas as pd\n",
+        "train = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/train.txt', sep=\"\\t\")\n",
+        "test = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/test.txt', sep=\"\\t\")\n",
+        "valid = pd.read_csv('/content/drive/MyDrive/Colab Notebooks/chapter09/valid.txt', sep=\"\\t\")\n",
+        "# データ数の確認\n",
+        "print('学習データ')\n",
+        "print(train['CATEGORY'].value_counts())\n",
+        "print('検証データ')\n",
+        "print(valid['CATEGORY'].value_counts())\n",
+        "print('評価データ')\n",
+        "print(test['CATEGORY'].value_counts())\n",
+        "\n",
+        "\n",
+        "# ターゲットのテンソル化\n",
+        "category_dict = {'b': 0, 't': 1, 'e':2, 'm':3}\n",
+        "Y_train = torch.from_numpy(train['CATEGORY'].map(category_dict).values)\n",
+        "Y_valid = torch.from_numpy(valid['CATEGORY'].map(category_dict).values)\n",
+        "Y_test = torch.from_numpy(test['CATEGORY'].map(category_dict).values)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#BERTのデータセットを作成\n",
+        "class BERTDataSet(Dataset):\n",
+        "\n",
+        "    def __init__(self, X, y, phase):\n",
+        "        self.X = X['TITLE']\n",
+        "        self.y = y\n",
+        "        self.tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')\n",
+        "        self.phase = phase\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.y)\n",
+        "\n",
+        "    def __getitem__(self,idx):\n",
+        "        sentence = self.X[idx]\n",
+        "        sentence = str(sentence)\n",
+        "        sentence = \" \".join(sentence.split())\n",
+        "\n",
+        "        bert_sens = self.tokenizer.encode_plus(\n",
+        "                                sentence,\n",
+        "                                add_special_tokens = True, # [CLS],[SEP]\n",
+        "                                max_length = 20,\n",
+        "                                pad_to_max_length = True, # add padding to blank\n",
+        "                                truncation=True)\n",
+        "\n",
+        "        ids = torch.tensor(bert_sens['input_ids'], dtype=torch.long)\n",
+        "        mask = torch.tensor(bert_sens['attention_mask'], dtype=torch.long)\n",
+        "        labels = self.y[idx]\n",
+        "\n",
+        "        return {\n",
+        "                'ids': ids,\n",
+        "                'mask': mask,\n",
+        "                'labels': labels,\n",
+        "                }\n",
+        "\n",
+        "train_dataset = BERTDataSet(train, Y_train, phase='train')\n",
+        "valid_dataset = BERTDataSet(valid, Y_valid, phase='val')\n",
+        "test_dataset = BERTDataSet(test, Y_test, phase='val')\n",
+        "\n",
+        "# 動作確認\n",
+        "train_dataset[0]"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 423,
+          "referenced_widgets": [
+            "9f6b953d57a64314a6745158dd35eb03",
+            "fb9cb42d8b4346789e3878388da6b249",
+            "97cc5a96765e4a8d88edc276ba8d660e",
+            "86da61bd877a4b93b47c4fa50a98c3a4",
+            "291bc56f6007473f92cc3ffff6c9a9c3",
+            "4d38cf22ddab48d296c54385a45ed8a2",
+            "2465c3759bb844c4a29ebcabbe070ee7",
+            "e4533a31eb19415f8c387bdd438c8860",
+            "24fca98aefc845a0a8f852f0cc7f6ded",
+            "da317ce5b4094a329faebf540fd999f1",
+            "f68d3d5818cb4594b571db74af3ae95a",
+            "15f7ba799cd0434291e31b44068d95af",
+            "2e4d6071fb87459f80f417e6a9301508",
+            "cb7f9ab068524581a75e7a82627fd23a",
+            "648ff1e56d3b440a852995883f62c445",
+            "0006c546adca4c1189b3b67f2c36fc1b",
+            "9daad2e5691645768071d92dfed0c784",
+            "0713655aaff54de68d344fe97060d426",
+            "1adc9e3830394315a7fa50a6f5695d96",
+            "8346610178c74353bb3f6a59d22f4805",
+            "7d56ccbb0a684068a59168d4c541ff9c",
+            "e1c07574b96743b8b8389fd28bbf1c17",
+            "f57c52aa284e4250a0bcee30d6d84487",
+            "3980a0a6288143afa97c2d2b5a65074d",
+            "2cbd6d1c77e0406386f8a2b16455b948",
+            "109b206270ff467ead91048552520e39",
+            "79a2a2f6d999445baca555e53713f0f8",
+            "88146d86eea14eba9fed6d676b733a93",
+            "08372744e3ce4c36b555eefda43fe3e6",
+            "eea84f8807cf43b48bd617344dcb5eee",
+            "1c6ae3efca054fbe8254cef989ea562a",
+            "400415e19d9043789abd0849129cdb19",
+            "3c72ec49060d4415a957462e4c007189",
+            "904a7075d1df4c8ca4dfc53da83010eb",
+            "46fdb70c3e3b48f4ab5604072390de16",
+            "d99bfdfaaaad482daa7c2f4af5e56e84",
+            "d4cf66a1ca1a466d8358ce65aeb5a04e",
+            "8e9f953ba632411eaf57ddcc9e112ed7",
+            "ec62a42aa6954771bae5e02f3dd64ffe",
+            "7e69bd39109146c1aa8a9722c7b4361c",
+            "c4ac2c4bce1147c089721a1637140dff",
+            "ff9ea2ccbf90411083fa58d2da395e3a",
+            "4d7df12b08034e7dbb5e15fad37e279e",
+            "2f4f87a0908d49b9b19bb9d143558372"
+          ]
+        },
+        "id": "aCFbEW-7IFHA",
+        "outputId": "52fc190d-3856-4965-cce1-41a752d436b3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_token.py:89: UserWarning: \n",
+            "The secret `HF_TOKEN` does not exist in your Colab secrets.\n",
+            "To authenticate with the Hugging Face Hub, create a token in your settings tab (https://huggingface.co/settings/tokens), set it as secret in your Google Colab and restart your session.\n",
+            "You will be able to reuse this secret in all of your notebooks.\n",
+            "Please note that authentication is recommended but still optional to access public models or datasets.\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "tokenizer_config.json:   0%|          | 0.00/48.0 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "9f6b953d57a64314a6745158dd35eb03"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "vocab.txt:   0%|          | 0.00/232k [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "15f7ba799cd0434291e31b44068d95af"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "tokenizer.json:   0%|          | 0.00/466k [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "f57c52aa284e4250a0bcee30d6d84487"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "config.json:   0%|          | 0.00/570 [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "904a7075d1df4c8ca4dfc53da83010eb"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2699: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "{'ids': tensor([  101,  6796, 12170, 22669,  2104,  4812,  2005,  4692, 13742,  2012,\n",
+              "          4913,  1004, 18396,  1005,  1055,   102,     0,     0,     0,     0]),\n",
+              " 'mask': tensor([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0]),\n",
+              " 'labels': tensor(2)}"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 4
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# DataLoaderを作成\n",
+        "batch_size = 64\n",
+        "\n",
+        "def seed_worker(worker_id):\n",
+        "    worker_seed = torch.initial_seed() % 2**32\n",
+        "    np.random.seed(worker_seed)\n",
+        "    random.seed(worker_seed)\n",
+        "\n",
+        "g = torch.Generator()\n",
+        "g.manual_seed(1234)\n",
+        "\n",
+        "train_dataloader = DataLoader(\n",
+        "            train_dataset, batch_size=batch_size, shuffle=True, worker_init_fn=seed_worker, generator=g)\n",
+        "valid_dataloader = DataLoader(\n",
+        "            valid_dataset, batch_size=batch_size, shuffle=False, worker_init_fn=seed_worker, generator=g)\n",
+        "test_dataloader = DataLoader(\n",
+        "            test_dataset, batch_size=batch_size, shuffle=False, worker_init_fn=seed_worker, generator=g)\n",
+        "\n",
+        "dataloaders_dict = {'train': train_dataloader,\n",
+        "                    'val': valid_dataloader,\n",
+        "                    'test': test_dataloader,\n",
+        "                   }\n",
+        "\n",
+        "# 動作確認\n",
+        "batch_iter = iter(dataloaders_dict['train'])\n",
+        "inputs = next(batch_iter)\n",
+        "print(inputs['ids'].size())\n",
+        "print(inputs['mask'].size())\n",
+        "print(inputs['labels'].size())"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "YJ5BLPQaIYph",
+        "outputId": "4354d152-d3ca-460b-8fbe-428149378264"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "torch.Size([64, 20])\n",
+            "torch.Size([64, 20])\n",
+            "torch.Size([64])\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2699: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
+            "  warnings.warn(\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#データローダ―の中身を確認\n",
+        "print(inputs['ids'])\n",
+        "print(inputs['mask'])\n",
+        "print(inputs['labels'])"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "NntLifplNxT7",
+        "outputId": "555b8e83-6153-4375-de02-1f1ea4108f3d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "tensor([[  101,  9606, 12584,  ...,  1012,  1012,   102],\n",
+            "        [  101, 12495, 25832,  ...,     0,     0,     0],\n",
+            "        [  101,  7922, 23021,  ...,     0,     0,     0],\n",
+            "        ...,\n",
+            "        [  101, 24869,  2100,  ...,     0,     0,     0],\n",
+            "        [  101,  8731,  2758,  ...,     0,     0,     0],\n",
+            "        [  101, 10651,  1015,  ...,     0,     0,     0]])\n",
+            "tensor([[1, 1, 1,  ..., 1, 1, 1],\n",
+            "        [1, 1, 1,  ..., 0, 0, 0],\n",
+            "        [1, 1, 1,  ..., 0, 0, 0],\n",
+            "        ...,\n",
+            "        [1, 1, 1,  ..., 0, 0, 0],\n",
+            "        [1, 1, 1,  ..., 0, 0, 0],\n",
+            "        [1, 1, 1,  ..., 0, 0, 0]])\n",
+            "tensor([2, 2, 0, 0, 2, 1, 0, 0, 2, 1, 1, 1, 0, 2, 0, 0, 0, 0, 1, 2, 2, 2, 0, 1,\n",
+            "        0, 0, 1, 2, 1, 2, 2, 0, 2, 2, 2, 0, 0, 2, 0, 0, 0, 3, 2, 3, 1, 2, 0, 2,\n",
+            "        0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 2, 1, 0, 0, 0, 0])\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# BERT分類モデルの定義\n",
+        "class BERTClass(torch.nn.Module):\n",
+        "    def __init__(self, drop_rate, hidden_size, output_size):\n",
+        "        super().__init__()\n",
+        "        self.bert = BertModel.from_pretrained('bert-base-uncased')\n",
+        "        self.drop = nn.Dropout(drop_rate)\n",
+        "        self.fc = nn.Sequential(\n",
+        "                                nn.Linear(768, hidden_size),\n",
+        "                                nn.ReLU(),\n",
+        "                                nn.BatchNorm1d(hidden_size),\n",
+        "                                nn.Linear(hidden_size, output_size)\n",
+        "                                )\n",
+        "\n",
+        "    def forward(self, ids, mask):\n",
+        "        out = self.bert(ids, attention_mask=mask)[-1]\n",
+        "        out = self.fc(self.drop(out))\n",
+        "        return out"
+      ],
+      "metadata": {
+        "id": "lPVeruYZI8_s"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# 学習用の関数を定義\n",
+        "def train_model(net, dataloaders_dict, criterion, optimizer, num_epochs):\n",
+        "    # 初期設定\n",
+        "    # GPUが使えるか確認\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    print(torch.cuda.get_device_name())\n",
+        "    print(\"使用デバイス:\", device)\n",
+        "\n",
+        "    # ネットワークをgpuへ\n",
+        "    net.to(device)\n",
+        "\n",
+        "    train_loss = []\n",
+        "    train_acc = []\n",
+        "    valid_loss = []\n",
+        "    valid_acc = []\n",
+        "\n",
+        "    # epochのループ\n",
+        "    for epoch in range(num_epochs):\n",
+        "        # epochごとの学習と検証のループ\n",
+        "        for phase in ['train', 'val']:\n",
+        "            if phase == 'train':\n",
+        "                net.train() # 訓練モード\n",
+        "            else:\n",
+        "                net.eval() # 検証モード\n",
+        "\n",
+        "            epoch_loss = 0.0 # epochの損失和\n",
+        "            epoch_corrects = 0 # epochの正解数\n",
+        "\n",
+        "            # データローダーからミニバッチを取り出すループ\n",
+        "            for data in dataloaders_dict[phase]:\n",
+        "                # GPUが使えるならGPUにおくる\n",
+        "                ids = data['ids'].to(device)\n",
+        "                mask = data['mask'].to(device)\n",
+        "                labels = data['labels'].to(device)\n",
+        "                optimizer.zero_grad() # optimizerを初期化\n",
+        "\n",
+        "                # 順伝播計算(forward)\n",
+        "                with torch.set_grad_enabled(phase == 'train'):\n",
+        "                    outputs = net(ids, mask)\n",
+        "                    loss = criterion(outputs, labels) # 損失を計算\n",
+        "                    _, preds = torch.max(outputs, 1) # ラベルを予想\n",
+        "\n",
+        "                    # 訓練時は逆伝播\n",
+        "                    if phase == 'train':\n",
+        "                        loss.backward()\n",
+        "                        optimizer.step()\n",
+        "\n",
+        "                    # イテレーション結果の計算\n",
+        "                    # lossの合計を更新\n",
+        "                    epoch_loss += loss.item() * ids.size(0)\n",
+        "                    # 正解数の合計を更新\n",
+        "                    epoch_corrects += torch.sum(preds == labels.data)\n",
+        "\n",
+        "            # epochごとのlossと正解率の表示\n",
+        "            epoch_loss = epoch_loss / len(dataloaders_dict[phase].dataset)\n",
+        "            epoch_acc = epoch_corrects.double() / len(dataloaders_dict[phase].dataset)\n",
+        "            if phase == 'train':\n",
+        "                train_loss.append(epoch_loss)\n",
+        "                train_acc.append(epoch_acc.cpu())\n",
+        "            else:\n",
+        "                valid_loss.append(epoch_loss)\n",
+        "                valid_acc.append(epoch_acc.cpu())\n",
+        "\n",
+        "        print('Epoch {} / {} (train) Loss: {:.4f}, Acc: {:.4f}, (val) Loss: {:.4f}, Acc: {:.4f}'.format(epoch + 1, num_epochs, train_loss[-1], train_acc[-1], valid_loss[-1], valid_acc[-1]))\n",
+        "    return train_loss, train_acc, valid_loss, valid_acc\n",
+        "\n",
+        "\n",
+        "# パラメータの設定\n",
+        "DROP_RATE = 0.2\n",
+        "HIDDEN_SIZE = 256\n",
+        "OUTPUT_SIZE = 4\n",
+        "BATCH_SIZE = 64\n",
+        "NUM_EPOCHS = 8\n",
+        "LEARNING_RATE = 1e-5\n",
+        "\n",
+        "# モデルの定義\n",
+        "net = BERTClass(DROP_RATE, HIDDEN_SIZE, OUTPUT_SIZE)\n",
+        "net.train()\n",
+        "\n",
+        "# 損失関数の定義\n",
+        "criterion = nn.CrossEntropyLoss()\n",
+        "\n",
+        "# オプティマイザの定義\n",
+        "optimizer = torch.optim.AdamW(params=net.parameters(), lr=LEARNING_RATE)\n",
+        "\n",
+        "train_loss, train_acc, valid_loss, valid_acc = train_model(net,\n",
+        "            dataloaders_dict, criterion, optimizer, num_epochs=NUM_EPOCHS)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 234,
+          "referenced_widgets": [
+            "5355fbd4e6ce40d991d58840c91d7645",
+            "33f8eef647d14bccb306f30f4056fd28",
+            "46919043957c490896dc259ae76020a8",
+            "20da727e862c4a28b7b2cd0421ae7ad5",
+            "6ea0c4b89bae428a8dfa5282559a5a4f",
+            "9ae1b401042046889490b9afc7862849",
+            "2bf50af7ac6945579679217da95a37b0",
+            "73a541b996374260a9397b49d70b334a",
+            "f80bd65f09e74216ae2cb5ed410e7e8b",
+            "eccc4d49279e488abfcafacddf86c7ab",
+            "4ddc963ac5594e6fb868a3e98a89ac4e"
+          ]
+        },
+        "id": "DExlBy6UJAO0",
+        "outputId": "498e8e82-915c-4f39-adae-ff59c59ee50e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "model.safetensors:   0%|          | 0.00/440M [00:00<?, ?B/s]"
+            ],
+            "application/vnd.jupyter.widget-view+json": {
+              "version_major": 2,
+              "version_minor": 0,
+              "model_id": "5355fbd4e6ce40d991d58840c91d7645"
+            }
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Tesla T4\n",
+            "使用デバイス: cuda:0\n",
+            "Epoch 1 / 8 (train) Loss: 0.6313, Acc: 0.7835, (val) Loss: 0.2644, Acc: 0.9183\n",
+            "Epoch 2 / 8 (train) Loss: 0.2727, Acc: 0.9166, (val) Loss: 0.2126, Acc: 0.9370\n",
+            "Epoch 3 / 8 (train) Loss: 0.1889, Acc: 0.9440, (val) Loss: 0.2025, Acc: 0.9363\n",
+            "Epoch 4 / 8 (train) Loss: 0.1330, Acc: 0.9621, (val) Loss: 0.2035, Acc: 0.9415\n",
+            "Epoch 5 / 8 (train) Loss: 0.0996, Acc: 0.9731, (val) Loss: 0.2056, Acc: 0.9408\n",
+            "Epoch 6 / 8 (train) Loss: 0.0746, Acc: 0.9808, (val) Loss: 0.2131, Acc: 0.9378\n",
+            "Epoch 7 / 8 (train) Loss: 0.0587, Acc: 0.9860, (val) Loss: 0.2141, Acc: 0.9408\n",
+            "Epoch 8 / 8 (train) Loss: 0.0415, Acc: 0.9916, (val) Loss: 0.2219, Acc: 0.9445\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "#精度計算用の関数を定義\n",
+        "def calc_acc(net, dataloader):\n",
+        "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+        "    net.eval()\n",
+        "    corrects = 0\n",
+        "    with torch.no_grad():\n",
+        "        for data in dataloader:\n",
+        "            ids = data['ids'].to(device)\n",
+        "            mask = data['mask'].to(device)\n",
+        "            labels = data['labels'].to(device)\n",
+        "            outputs = net(ids, mask)\n",
+        "            _, preds = torch.max(outputs, 1)\n",
+        "            corrects += torch.sum(preds == labels.data).cpu()\n",
+        "    return corrects / len(dataloader.dataset)\n",
+        "\n",
+        "#グラフの描画\n",
+        "fig, ax = plt.subplots(1,2, figsize=(10, 5))\n",
+        "epochs = np.arange(NUM_EPOCHS)\n",
+        "ax[0].plot(epochs, train_loss, label='train')\n",
+        "ax[0].plot(epochs, valid_loss, label='valid')\n",
+        "ax[0].set_title('loss')\n",
+        "ax[0].set_xlabel('epoch')\n",
+        "ax[0].set_ylabel('loss')\n",
+        "ax[1].plot(epochs, train_acc, label='train')\n",
+        "ax[1].plot(epochs, valid_acc, label='valid')\n",
+        "ax[1].set_title('acc')\n",
+        "ax[1].set_xlabel('epoch')\n",
+        "ax[1].set_ylabel('acc')\n",
+        "ax[0].legend(loc='best')\n",
+        "ax[1].legend(loc='best')\n",
+        "plt.tight_layout()\n",
+        "plt.show()\n",
+        "\n",
+        "#精度の表示\n",
+        "acc_train = calc_acc(net, train_dataloader)\n",
+        "acc_valid = calc_acc(net, valid_dataloader)\n",
+        "acc_test = calc_acc(net, test_dataloader)\n",
+        "print('学習データの正解率: {:.4f}'.format(acc_train))\n",
+        "print('検証データの正解率: {:.4f}'.format(acc_valid))\n",
+        "print('テストデータの正解率: {:.4f}'.format(acc_test))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 619
+        },
+        "id": "Ov7g4m7ZLNmE",
+        "outputId": "09748bcb-f5b9-497d-ca06-8f1c2ea2ed03"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1000x500 with 2 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "/usr/local/lib/python3.10/dist-packages/transformers/tokenization_utils_base.py:2699: FutureWarning: The `pad_to_max_length` argument is deprecated and will be removed in a future version, use `padding=True` or `padding='longest'` to pad to the longest sequence in the batch, or use `padding='max_length'` to pad to a max length. In this case, you can give a specific length with `max_length` (e.g. `max_length=45`) or leave max_length to None to pad to the maximal input size of the model (e.g. 512 for Bert).\n",
+            "  warnings.warn(\n"
+          ]
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "学習データの正解率: 0.9958\n",
+            "検証データの正解率: 0.9445\n",
+            "テストデータの正解率: 0.9438\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "D3W_cKr_XQdh",
+        "outputId": "8d4eedb2-12ca-4683-b08c-0d41f98d444b"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "pip install torchinfo"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GJp3iMQQKqVL",
+        "outputId": "50761c76-f233-4f2d-cbf5-7b4b3b29407d"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Requirement already satisfied: torchinfo in /usr/local/lib/python3.10/dist-packages (1.8.0)\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file