20221119_모델학습.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ZzangJay/team_project/blob/main/20221119_%EB%AA%A8%EB%8D%B8%ED%95%99%EC%8A%B5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "xCBwZEG88iTZ"
      },
      "outputs": [],
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#import tensorflow as tf \n",
        "import os\n",
        "import sys\n",
        "from datetime import datetime, timedelta\n",
        "from tqdm.autonotebook import tqdm\n",
        "import csv\n",
        "import re\n",
        "import gzip\n",
        "import shutil\n",
        "import pickle"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dKfa-fAw8qIn",
        "outputId": "12408386-737d-4412-e39e-43350ac0bcc8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/gdrive/\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['CHANGELOG.txt',\n",
              " 'LICENSE.txt',\n",
              " 'SHA256SUMS.txt',\n",
              " 'index.html',\n",
              " 'icu',\n",
              " 'hosp',\n",
              " 'drop_2_chartevents.csv']"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "from google.colab import drive  # for colab\n",
        "drive.mount('/content/gdrive/')  # for colab\n",
        "cloud_directory = '/content/gdrive/MyDrive/mimiciv_unzip/'\n",
        "os.listdir(cloud_directory) # for colab, check cloud directory mount"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with gzip.open('/content/gdrive/MyDrive/sepsis_model_weight/20221119_death_dataset.pickle','rb') as f:\n",
        "    death_dataset = pickle.load(f)\n",
        "\n",
        "with gzip.open('/content/gdrive/MyDrive/sepsis_model_weight/20221119_anti_dataset.pickle','rb') as f:\n",
        "    anti_dataset = pickle.load(f)"
      ],
      "metadata": {
        "id": "yIJr__nwQCjl"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "78GmjAzpqJWt"
      },
      "source": [
        "## train-test 분할"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "o-6aOPFhqFQ_"
      },
      "outputs": [],
      "source": [
        "## 학습용 검증용 데이터 나누기 (9:1)\n",
        "def split_train_test(dataset, train_ratio=0.9, pos_neg=True):\n",
        "  #레이블이 양성, 음성인 경우, 학습 데이터, 테스트 데이터를 나눌 때 \n",
        "  #양성, 음성의 비율을 각각 유지할 수 있도록 구현\n",
        "  if pos_neg:\n",
        "    pos_idx = np.where(np.array(dataset['LABEL']) == 1)[0]\n",
        "    neg_idx = np.where(np.array(dataset['LABEL']) == 0)[0]\n",
        "\n",
        "    # suffle 넣어줘서 index 섞어줘야함. np.random, random,suffle\n",
        "    np.random.shuffle(pos_idx)\n",
        "    np.random.shuffle(neg_idx)\n",
        "\n",
        "    pos_num = len(pos_idx)\n",
        "    neg_num = len(neg_idx)\n",
        "\n",
        "    train_pos_idx = list(pos_idx[:int(pos_num * train_ratio)])\n",
        "    test_pos_idx = list(pos_idx[int(pos_num * train_ratio):])\n",
        "\n",
        "    train_neg_idx = list(neg_idx[:int(neg_num * train_ratio)])\n",
        "    test_neg_idx = list(neg_idx[int(neg_num * train_ratio):])\n",
        "\n",
        "    train_idx = train_pos_idx + train_neg_idx\n",
        "    test_idx = test_pos_idx + test_neg_idx\n",
        "  \n",
        "  #레이블이 양성, 음성이 아닌경우 단순하게 전체 데이터에서 학습, 테스트 비율만큼 나누기\n",
        "  else:\n",
        "    idx = np.arange(len(dataset['LABEL']))\n",
        "    np.random.shuffle(idx)\n",
        "    train_idx = idx[:int(len(idx) * train_ratio)]\n",
        "    test_idx = idx[int(len(idx) * train_ratio):]\n",
        "\n",
        "  train_set = dict({\n",
        "      'HADM_IDS': np.array(dataset['HADM_IDS'])[train_idx],\n",
        "      'LABEL': np.array(dataset['LABEL'])[train_idx],\n",
        "      'DATA': np.array(dataset['DATA'])[train_idx],\n",
        "      'EXTRA': np.array(dataset['EXTRA'])[train_idx].reshape((-1,2))\n",
        "  })\n",
        "\n",
        "  test_set = dict({\n",
        "      'HADM_IDS': np.array(dataset['HADM_IDS'])[test_idx],\n",
        "      'LABEL': np.array(dataset['LABEL'])[test_idx],\n",
        "      'DATA': np.array(dataset['DATA'])[test_idx],\n",
        "      'EXTRA': np.array(dataset['EXTRA'])[test_idx].reshape((-1,2))\n",
        "  })\n",
        "  return train_set, test_set"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## 학습용 검증용 데이터 나누기 (9:1)\n",
        "def split_train_test_many(dataset, train_ratio=0.9, pos_neg=True):\n",
        "  if pos_neg:\n",
        "    pass\n",
        "  else:\n",
        "    idx = np.arange(len(dataset['LABEL_1']))\n",
        "    np.random.shuffle(idx)\n",
        "    train_idx = idx[:int(len(idx) * train_ratio)]\n",
        "    test_idx = idx[int(len(idx) * train_ratio):]\n",
        "\n",
        "  train_set = dict({\n",
        "      'HADM_IDS': np.array(dataset['HADM_IDS'])[train_idx],\n",
        "      'LABEL_1': np.array(dataset['LABEL_1'])[train_idx],\n",
        "      'LABEL_2': np.array(dataset['LABEL_2'])[train_idx],\n",
        "      'LABEL_3': np.array(dataset['LABEL_3'])[train_idx],\n",
        "      'LABEL_4': np.array(dataset['LABEL_4'])[train_idx],\n",
        "      'LABEL_5': np.array(dataset['LABEL_5'])[train_idx],\n",
        "      'DATA': np.array(dataset['DATA'])[train_idx],\n",
        "      'EXTRA': np.array(dataset['EXTRA'])[train_idx].reshape((-1,2))\n",
        "  })\n",
        "\n",
        "  test_set = dict({\n",
        "      'HADM_IDS': np.array(dataset['HADM_IDS'])[test_idx],\n",
        "      'LABEL_1': np.array(dataset['LABEL_1'])[test_idx],\n",
        "      'LABEL_2': np.array(dataset['LABEL_2'])[test_idx],\n",
        "      'LABEL_3': np.array(dataset['LABEL_3'])[test_idx],\n",
        "      'LABEL_4': np.array(dataset['LABEL_4'])[test_idx],\n",
        "      'LABEL_5': np.array(dataset['LABEL_5'])[test_idx],\n",
        "      'DATA': np.array(dataset['DATA'])[test_idx],\n",
        "      'EXTRA': np.array(dataset['EXTRA'])[test_idx].reshape((-1,2))\n",
        "  })\n",
        "  return train_set, test_set"
      ],
      "metadata": {
        "id": "UqbId19P4RJA"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "GI5h60FIqQXK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09be523a-7111-4f5e-f569-2ac45ad29b72"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:35: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:42: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:18: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n",
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:29: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n"
          ]
        }
      ],
      "source": [
        "death_train, death_test = split_train_test(death_dataset)\n",
        "anti_train, anti_test = split_train_test_many(anti_dataset, pos_neg=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "QgYq2iiPqSZj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8aa4b16f-cd40-4652-8338-05a6d015add9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "29105\n",
            "3235\n",
            "29106\n",
            "3234\n",
            "0.3348106919535491\n",
            "0.3364254792826221\n",
            "0.357555143269429\n",
            "0.3484848484848485\n",
            "0.1862502576788291\n",
            "0.17625231910946196\n",
            "0.11142032570603999\n",
            "0.11657390228818801\n",
            "0.05816670102384388\n",
            "0.06060606060606061\n"
          ]
        }
      ],
      "source": [
        "print(len(death_train['HADM_IDS']))\n",
        "print(len(death_test['HADM_IDS']))\n",
        "print(len(anti_train['HADM_IDS']))\n",
        "print(len(anti_test['HADM_IDS']))\n",
        "\n",
        "print(sum(anti_train['LABEL_1']==1)/len(anti_train['HADM_IDS']))\n",
        "print(sum(anti_test['LABEL_1']==1)/len(anti_test['HADM_IDS']))\n",
        "print(sum(anti_train['LABEL_2']==1)/len(anti_train['HADM_IDS']))\n",
        "print(sum(anti_test['LABEL_2']==1)/len(anti_test['HADM_IDS']))\n",
        "print(sum(anti_train['LABEL_3']==1)/len(anti_train['HADM_IDS']))\n",
        "print(sum(anti_test['LABEL_3']==1)/len(anti_test['HADM_IDS']))\n",
        "print(sum(anti_train['LABEL_4']==1)/len(anti_train['HADM_IDS']))\n",
        "print(sum(anti_test['LABEL_4']==1)/len(anti_test['HADM_IDS']))\n",
        "print(sum(anti_train['LABEL_5']==1)/len(anti_train['HADM_IDS']))\n",
        "print(sum(anti_test['LABEL_5']==1)/len(anti_test['HADM_IDS']))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VZvM3xUVqF5A"
      },
      "source": [
        "## loader 만들기"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install tensorflow-addons"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2lzzMVZCYT5n",
        "outputId": "6b8e3632-f1ac-4dc1-f2a8-1ab715a08f6e"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting tensorflow-addons\n",
            "  Downloading tensorflow_addons-0.18.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.1 MB 8.3 MB/s \n",
            "\u001b[?25hRequirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.7/dist-packages (from tensorflow-addons) (2.7.1)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from tensorflow-addons) (21.3)\n",
            "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->tensorflow-addons) (3.0.9)\n",
            "Installing collected packages: tensorflow-addons\n",
            "Successfully installed tensorflow-addons-0.18.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "id": "b38QBa6_TYQm"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "import math\n",
        "from tensorflow.keras.utils import Sequence\n",
        "import numpy as np\n",
        "import tensorflow_addons as tfa"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## 사망예측 모델용 데이터 로더_static 변수 추가\n",
        "class Death_Dataloader2(Sequence):\n",
        "    def __init__(self, x_set,x_set2, y_set, hadm_id_set, batch_size, shuffle=False):\n",
        "        self.x, self.x2, self.y, self.hadm_id = x_set, x_set2, y_set, hadm_id_set\n",
        "        self.batch_size = batch_size\n",
        "        self.shuffle = shuffle\n",
        "        self.on_epoch_end()\n",
        "\n",
        "    def __len__(self):\n",
        "        return math.ceil(len(self.x) / self.batch_size)\n",
        "\n",
        "\t\t# batch 단위로 직접 묶어줘야 함\n",
        "    def __getitem__(self, idx):\n",
        "\t\t# sampler의 역할(index를 batch_size만큼 sampling해줌)\n",
        "        indices = self.indices[idx*self.batch_size:(idx+1)*self.batch_size]\n",
        "\n",
        "        batch_x = [self.x[i] for i in indices]\n",
        "        \n",
        "        batch_x2 = [self.x2[i] for i in indices]\n",
        "\n",
        "        ## 입력 데이터들의 크기를 최대 24시간으로 통일하고 24시간 보다 짧은 데이터들의 경우 끝에 '0' padding 붙이기\n",
        "        padded_batch_x = np.zeros((len(batch_x), 24, len(feature_keys)))\n",
        "        for i in range(len(batch_x)):\n",
        "          valid_length = len(batch_x[i])\n",
        "          padded_batch_x[i][:valid_length, :] = batch_x[i]\n",
        "        \n",
        "\n",
        "        batch_y = [self.y[i] for i in indices]\n",
        "        batch_hadm_id = [self.hadm_id[i] for i in indices]\n",
        "\n",
        "        return [np.array(padded_batch_x).astype('float32'), np.array(batch_x2).astype('float32')] ,np.array(batch_y).astype('float32')\n",
        "\n",
        "    # epoch이 끝날때마다 실행\n",
        "    def on_epoch_end(self):\n",
        "        self.indices = np.arange(len(self.x))\n",
        "        if self.shuffle == True:\n",
        "            np.random.shuffle(self.indices)"
      ],
      "metadata": {
        "id": "d9mxUZExDbBP"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## 항생제예측 모델용 데이터 로더_static 변수 추가\n",
        "class Death_Dataloader_many(Sequence):\n",
        "    def __init__(self, x_set,x_set2, y_set_1, y_set_2, y_set_3, y_set_4, y_set_5, hadm_id_set, batch_size, shuffle=False):\n",
        "        self.x, self.x2, self.y_1, self.y_2, self.y_3, self.y_4, self.y_5, self.hadm_id = x_set, x_set2, y_set_1, y_set_2, y_set_3, y_set_4, y_set_5, hadm_id_set\n",
        "        self.batch_size = batch_size\n",
        "        self.shuffle = shuffle\n",
        "        self.on_epoch_end()\n",
        "\n",
        "    def __len__(self):\n",
        "        return math.ceil(len(self.x) / self.batch_size)\n",
        "\n",
        "\t\t# batch 단위로 직접 묶어줘야 함\n",
        "    def __getitem__(self, idx):\n",
        "\t\t# sampler의 역할(index를 batch_size만큼 sampling해줌)\n",
        "        indices = self.indices[idx*self.batch_size:(idx+1)*self.batch_size]\n",
        "\n",
        "        batch_x = [self.x[i] for i in indices]\n",
        "        \n",
        "        batch_x2 = [self.x2[i] for i in indices]\n",
        "\n",
        "        ## 입력 데이터들의 크기를 최대 24시간으로 통일하고 24시간 보다 짧은 데이터들의 경우 끝에 '0' padding 붙이기\n",
        "        padded_batch_x = np.zeros((len(batch_x), 24, len(feature_keys)))\n",
        "        for i in range(len(batch_x)):\n",
        "          valid_length = len(batch_x[i])\n",
        "          padded_batch_x[i][:valid_length, :] = batch_x[i]\n",
        "        \n",
        "\n",
        "        batch_y_1 = [self.y_1[i] for i in indices]\n",
        "        batch_y_2 = [self.y_2[i] for i in indices]\n",
        "        batch_y_3 = [self.y_3[i] for i in indices]\n",
        "        batch_y_4 = [self.y_4[i] for i in indices]\n",
        "        batch_y_5 = [self.y_5[i] for i in indices]\n",
        "        batch_hadm_id = [self.hadm_id[i] for i in indices]\n",
        "\n",
        "        return [np.array(padded_batch_x).astype('float32'), np.array(batch_x2).astype('float32')] ,[np.array(batch_y_1).astype('float32'),np.array(batch_y_2).astype('float32'),np.array(batch_y_3).astype('float32'),np.array(batch_y_4).astype('float32'),np.array(batch_y_5).astype('float32')]\n",
        "\n",
        "    # epoch이 끝날때마다 실행\n",
        "    def on_epoch_end(self):\n",
        "        self.indices = np.arange(len(self.x))\n",
        "        if self.shuffle == True:\n",
        "            np.random.shuffle(self.indices)\n"
      ],
      "metadata": {
        "id": "fEwG0zem61us"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "death_train_loader = Death_Dataloader2(death_train['DATA'], death_train['LABEL'], death_train['HADM_IDS'], 64, True)\n",
        "death_test_loader = Death_Dataloader2(death_test['DATA'], death_test['LABEL'], death_test['HADM_IDS'], 64, False)\n",
        "anti_train_loader = Death_Dataloader_many(anti_train['DATA'], anti_train['EXTRA'], anti_train['LABEL_1'], anti_train['LABEL_2'],anti_train['LABEL_3'],anti_train['LABEL_4'],anti_train['LABEL_5'],anti_train['HADM_IDS'], 64, True)\n",
        "anti_test_loader = Death_Dataloader_many(anti_test['DATA'], anti_test['EXTRA'], anti_test['LABEL_1'], anti_test['LABEL_2'],anti_test['LABEL_3'],anti_test['LABEL_4'],anti_test['LABEL_5'],anti_test['HADM_IDS'], 64, True)"
      ],
      "metadata": {
        "id": "B5fBhj-Dpy9F"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 항생제별 모델"
      ],
      "metadata": {
        "id": "BEM7E6v6ZT3p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from keras import backend as k\n",
        "k.clear_session()"
      ],
      "metadata": {
        "id": "vqtDuGE-hLjl"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "lr_schedule2 = keras.optimizers.schedules.CosineDecay(initial_learning_rate=0.02,decay_steps=10000)\n",
        "optimizer_cosine = keras.optimizers.SGD(learning_rate=lr_schedule2)\n",
        "\n",
        "# lr_schedule = keras.optimizers.schedules.ExponentialDecay(\n",
        "#     initial_learning_rate=0.005,\n",
        "#     decay_steps=100000,\n",
        "#     decay_rate=0.96)\n",
        "# optimizer_decay = keras.optimizers.SGD(learning_rate=lr_schedule)\n",
        "\n",
        "# lr_schedule3 = keras.optimizers.schedules.CosineDecayRestarts(\n",
        "#     initial_learning_rate=0.02,first_decay_steps=10, t_mul=2, m_mul=0.9, alpha=0)\n",
        "# optimizer_cosine = keras.optimizers.SGD(learning_rate=lr_schedule3)\n"
      ],
      "metadata": {
        "id": "0DV-N0PhYtqS"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def lstm_bidirect3():\n",
        "  input1 = layers.Input(shape=(24,22))\n",
        "  model1 = layers.LSTM(64,return_sequences=True)(input1)\n",
        "  model1 = layers.LSTM(64)(model1)\n",
        "  model1 = layers.Dense(32)(model1)\n",
        "  model1 = layers.BatchNormalization()(model1)\n",
        "  model1 = layers.Activation('relu')(model1)\n",
        "  model1 = layers.Dense(32)(model1)\n",
        "  model1 = layers.BatchNormalization()(model1)\n",
        "  model1 = layers.Activation('relu')(model1)\n",
        "  model1 = layers.Dropout(0.2)(model1)\n",
        "  model1 = layers.Dense(16)(model1)\n",
        "\n",
        "  input2 = layers.Input(2)\n",
        "  model2 = layers.Dense(64, activation='relu')(input2)\n",
        "  model2 = layers.BatchNormalization()(model2)\n",
        "  model2 = layers.Activation('relu')(model2)\n",
        "  model2 = layers.Dense(32, activation='relu')(input2)\n",
        "  model2 = layers.BatchNormalization()(model2)\n",
        "  model2 = layers.Activation('relu')(model2)\n",
        "  model2 = layers.Dropout(0.2)(model2)\n",
        "  model2 = layers.Dense(16)(model2)\n",
        "\n",
        "  model_add = layers.Add()([model1, model2])\n",
        "  model_add = layers.Dense(16)(model_add)\n",
        "  model_add = layers.BatchNormalization()(model_add)\n",
        "  model_add = layers.Dense(16)(model_add)\n",
        "  model_add = layers.BatchNormalization()(model_add)\n",
        "  #output = layers.Dense(1, activation='sigmoid')(model_add)\n",
        "  output_1 = layers.Dense(1, activation='sigmoid', name='anti_1')(model_add)\n",
        "  output_2 = layers.Dense(1, activation='sigmoid', name='anti_2')(model_add)\n",
        "  output_3 = layers.Dense(1, activation='sigmoid', name='anti_3')(model_add)\n",
        "  output_4 = layers.Dense(1, activation='sigmoid', name='anti_4')(model_add)\n",
        "  output_5 = layers.Dense(1, activation='sigmoid', name='anti_5')(model_add)\n",
        "\n",
        "  model = keras.Model(inputs=[input1, input2], outputs=[output_1, output_2, output_3, output_4, output_5])\n",
        "\n",
        "  model.compile(loss={'anti_1':'binary_crossentropy', 'anti_2':'binary_crossentropy', 'anti_3':'binary_crossentropy', 'anti_4':'binary_crossentropy', 'anti_5':'binary_crossentropy'},metrics={'anti_1':'AUC', 'anti_2':'AUC', 'anti_3':'AUC', 'anti_4':'AUC', 'anti_5':'AUC'})\n",
        "  \n",
        "  return model"
      ],
      "metadata": {
        "id": "3gyDrG4_K9NW"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model3=lstm_bidirect3()"
      ],
      "metadata": {
        "id": "P155gOXHEKXD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.utils import plot_model\n",
        "plot_model(model3, to_file='./model.png')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "44RFKneNGYHc",
        "outputId": "b3c29115-d31d-422b-a59d-4101a9170679"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "callback = [tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=20),\n",
        "            tf.keras.callbacks.ModelCheckpoint(filepath='/content/gdrive/MyDrive/sepsis_model_weight/anti_model/lstm_model_many.{epoch:02d}-{val_loss:.3f}.h5',save_best_only=True)]"
      ],
      "metadata": {
        "id": "2xNQ-9s5Jp71"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "history_lstm = model3.fit(anti_train_loader,validation_data=anti_test_loader,epochs=500,callbacks=callback,batch_size=64)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8SbNAskXZho4",
        "outputId": "80e431f0-e5ab-4dec-c5cc-e69bdb4fca48"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/500\n",
            "455/455 [==============================] - 20s 26ms/step - loss: 2.7133 - anti_1_loss: 0.6187 - anti_2_loss: 0.6621 - anti_3_loss: 0.5280 - anti_4_loss: 0.5270 - anti_5_loss: 0.3774 - anti_1_auc: 0.6371 - anti_2_auc_1: 0.5436 - anti_3_auc_2: 0.5661 - anti_4_auc_3: 0.5185 - anti_5_auc_4: 0.5283 - val_loss: 2.2998 - val_anti_1_loss: 0.5909 - val_anti_2_loss: 0.6428 - val_anti_3_loss: 0.4697 - val_anti_4_loss: 0.3734 - val_anti_5_loss: 0.2230 - val_anti_1_auc: 0.6640 - val_anti_2_auc_1: 0.5902 - val_anti_3_auc_2: 0.6380 - val_anti_4_auc_3: 0.5747 - val_anti_5_auc_4: 0.6822\n",
            "Epoch 2/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.2348 - anti_1_loss: 0.5835 - anti_2_loss: 0.6372 - anti_3_loss: 0.4601 - anti_4_loss: 0.3431 - anti_5_loss: 0.2109 - anti_1_auc: 0.6701 - anti_2_auc_1: 0.5900 - anti_3_auc_2: 0.6354 - anti_4_auc_3: 0.5878 - anti_5_auc_4: 0.6800 - val_loss: 2.2565 - val_anti_1_loss: 0.5757 - val_anti_2_loss: 0.6404 - val_anti_3_loss: 0.4658 - val_anti_4_loss: 0.3672 - val_anti_5_loss: 0.2075 - val_anti_1_auc: 0.6670 - val_anti_2_auc_1: 0.5909 - val_anti_3_auc_2: 0.6390 - val_anti_4_auc_3: 0.5834 - val_anti_5_auc_4: 0.7195\n",
            "Epoch 3/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.2175 - anti_1_loss: 0.5776 - anti_2_loss: 0.6353 - anti_3_loss: 0.4558 - anti_4_loss: 0.3414 - anti_5_loss: 0.2074 - anti_1_auc: 0.6796 - anti_2_auc_1: 0.5949 - anti_3_auc_2: 0.6498 - anti_4_auc_3: 0.5996 - anti_5_auc_4: 0.7000 - val_loss: 2.2619 - val_anti_1_loss: 0.5730 - val_anti_2_loss: 0.6395 - val_anti_3_loss: 0.4612 - val_anti_4_loss: 0.3650 - val_anti_5_loss: 0.2231 - val_anti_1_auc: 0.6551 - val_anti_2_auc_1: 0.6023 - val_anti_3_auc_2: 0.6506 - val_anti_4_auc_3: 0.5897 - val_anti_5_auc_4: 0.7149\n",
            "Epoch 4/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.2104 - anti_1_loss: 0.5747 - anti_2_loss: 0.6333 - anti_3_loss: 0.4542 - anti_4_loss: 0.3411 - anti_5_loss: 0.2070 - anti_1_auc: 0.6834 - anti_2_auc_1: 0.6009 - anti_3_auc_2: 0.6527 - anti_4_auc_3: 0.6003 - anti_5_auc_4: 0.7058 - val_loss: 2.2442 - val_anti_1_loss: 0.5730 - val_anti_2_loss: 0.6372 - val_anti_3_loss: 0.4579 - val_anti_4_loss: 0.3656 - val_anti_5_loss: 0.2105 - val_anti_1_auc: 0.6651 - val_anti_2_auc_1: 0.6092 - val_anti_3_auc_2: 0.6520 - val_anti_4_auc_3: 0.5825 - val_anti_5_auc_4: 0.7053\n",
            "Epoch 5/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.2038 - anti_1_loss: 0.5735 - anti_2_loss: 0.6321 - anti_3_loss: 0.4527 - anti_4_loss: 0.3408 - anti_5_loss: 0.2047 - anti_1_auc: 0.6837 - anti_2_auc_1: 0.6077 - anti_3_auc_2: 0.6575 - anti_4_auc_3: 0.6036 - anti_5_auc_4: 0.7179 - val_loss: 2.2963 - val_anti_1_loss: 0.6032 - val_anti_2_loss: 0.6435 - val_anti_3_loss: 0.4705 - val_anti_4_loss: 0.3721 - val_anti_5_loss: 0.2070 - val_anti_1_auc: 0.6618 - val_anti_2_auc_1: 0.5877 - val_anti_3_auc_2: 0.6434 - val_anti_4_auc_3: 0.5854 - val_anti_5_auc_4: 0.7286\n",
            "Epoch 6/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.2017 - anti_1_loss: 0.5731 - anti_2_loss: 0.6307 - anti_3_loss: 0.4520 - anti_4_loss: 0.3405 - anti_5_loss: 0.2053 - anti_1_auc: 0.6865 - anti_2_auc_1: 0.6118 - anti_3_auc_2: 0.6599 - anti_4_auc_3: 0.6054 - anti_5_auc_4: 0.7159 - val_loss: 2.2367 - val_anti_1_loss: 0.5731 - val_anti_2_loss: 0.6349 - val_anti_3_loss: 0.4566 - val_anti_4_loss: 0.3662 - val_anti_5_loss: 0.2060 - val_anti_1_auc: 0.6814 - val_anti_2_auc_1: 0.6163 - val_anti_3_auc_2: 0.6577 - val_anti_4_auc_3: 0.5923 - val_anti_5_auc_4: 0.7291\n",
            "Epoch 7/500\n",
            "455/455 [==============================] - 10s 23ms/step - loss: 2.1952 - anti_1_loss: 0.5705 - anti_2_loss: 0.6306 - anti_3_loss: 0.4503 - anti_4_loss: 0.3400 - anti_5_loss: 0.2038 - anti_1_auc: 0.6912 - anti_2_auc_1: 0.6122 - anti_3_auc_2: 0.6657 - anti_4_auc_3: 0.6081 - anti_5_auc_4: 0.7232 - val_loss: 2.2194 - val_anti_1_loss: 0.5606 - val_anti_2_loss: 0.6323 - val_anti_3_loss: 0.4560 - val_anti_4_loss: 0.3644 - val_anti_5_loss: 0.2061 - val_anti_1_auc: 0.6793 - val_anti_2_auc_1: 0.6215 - val_anti_3_auc_2: 0.6565 - val_anti_4_auc_3: 0.5955 - val_anti_5_auc_4: 0.7248\n",
            "Epoch 8/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1941 - anti_1_loss: 0.5706 - anti_2_loss: 0.6308 - anti_3_loss: 0.4491 - anti_4_loss: 0.3402 - anti_5_loss: 0.2034 - anti_1_auc: 0.6884 - anti_2_auc_1: 0.6120 - anti_3_auc_2: 0.6684 - anti_4_auc_3: 0.6068 - anti_5_auc_4: 0.7255 - val_loss: 2.2582 - val_anti_1_loss: 0.5728 - val_anti_2_loss: 0.6311 - val_anti_3_loss: 0.4684 - val_anti_4_loss: 0.3632 - val_anti_5_loss: 0.2227 - val_anti_1_auc: 0.6796 - val_anti_2_auc_1: 0.6243 - val_anti_3_auc_2: 0.6446 - val_anti_4_auc_3: 0.6057 - val_anti_5_auc_4: 0.6914\n",
            "Epoch 9/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1915 - anti_1_loss: 0.5697 - anti_2_loss: 0.6297 - anti_3_loss: 0.4491 - anti_4_loss: 0.3392 - anti_5_loss: 0.2037 - anti_1_auc: 0.6931 - anti_2_auc_1: 0.6142 - anti_3_auc_2: 0.6664 - anti_4_auc_3: 0.6166 - anti_5_auc_4: 0.7242 - val_loss: 2.2432 - val_anti_1_loss: 0.5742 - val_anti_2_loss: 0.6358 - val_anti_3_loss: 0.4610 - val_anti_4_loss: 0.3651 - val_anti_5_loss: 0.2070 - val_anti_1_auc: 0.6787 - val_anti_2_auc_1: 0.6157 - val_anti_3_auc_2: 0.6511 - val_anti_4_auc_3: 0.5947 - val_anti_5_auc_4: 0.7207\n",
            "Epoch 10/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1868 - anti_1_loss: 0.5683 - anti_2_loss: 0.6288 - anti_3_loss: 0.4478 - anti_4_loss: 0.3394 - anti_5_loss: 0.2024 - anti_1_auc: 0.6958 - anti_2_auc_1: 0.6151 - anti_3_auc_2: 0.6704 - anti_4_auc_3: 0.6125 - anti_5_auc_4: 0.7324 - val_loss: 2.2667 - val_anti_1_loss: 0.5781 - val_anti_2_loss: 0.6457 - val_anti_3_loss: 0.4627 - val_anti_4_loss: 0.3641 - val_anti_5_loss: 0.2162 - val_anti_1_auc: 0.6846 - val_anti_2_auc_1: 0.6133 - val_anti_3_auc_2: 0.6492 - val_anti_4_auc_3: 0.6031 - val_anti_5_auc_4: 0.6984\n",
            "Epoch 11/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1818 - anti_1_loss: 0.5669 - anti_2_loss: 0.6271 - anti_3_loss: 0.4478 - anti_4_loss: 0.3382 - anti_5_loss: 0.2017 - anti_1_auc: 0.6973 - anti_2_auc_1: 0.6214 - anti_3_auc_2: 0.6712 - anti_4_auc_3: 0.6223 - anti_5_auc_4: 0.7335 - val_loss: 2.2404 - val_anti_1_loss: 0.5693 - val_anti_2_loss: 0.6378 - val_anti_3_loss: 0.4588 - val_anti_4_loss: 0.3655 - val_anti_5_loss: 0.2089 - val_anti_1_auc: 0.6769 - val_anti_2_auc_1: 0.5957 - val_anti_3_auc_2: 0.6550 - val_anti_4_auc_3: 0.6035 - val_anti_5_auc_4: 0.7220\n",
            "Epoch 12/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1813 - anti_1_loss: 0.5663 - anti_2_loss: 0.6274 - anti_3_loss: 0.4476 - anti_4_loss: 0.3378 - anti_5_loss: 0.2022 - anti_1_auc: 0.6988 - anti_2_auc_1: 0.6206 - anti_3_auc_2: 0.6712 - anti_4_auc_3: 0.6234 - anti_5_auc_4: 0.7302 - val_loss: 2.2257 - val_anti_1_loss: 0.5659 - val_anti_2_loss: 0.6310 - val_anti_3_loss: 0.4565 - val_anti_4_loss: 0.3661 - val_anti_5_loss: 0.2061 - val_anti_1_auc: 0.6825 - val_anti_2_auc_1: 0.6235 - val_anti_3_auc_2: 0.6588 - val_anti_4_auc_3: 0.6075 - val_anti_5_auc_4: 0.7289\n",
            "Epoch 13/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1758 - anti_1_loss: 0.5649 - anti_2_loss: 0.6264 - anti_3_loss: 0.4454 - anti_4_loss: 0.3378 - anti_5_loss: 0.2013 - anti_1_auc: 0.7017 - anti_2_auc_1: 0.6238 - anti_3_auc_2: 0.6758 - anti_4_auc_3: 0.6251 - anti_5_auc_4: 0.7351 - val_loss: 2.2515 - val_anti_1_loss: 0.5759 - val_anti_2_loss: 0.6392 - val_anti_3_loss: 0.4624 - val_anti_4_loss: 0.3616 - val_anti_5_loss: 0.2124 - val_anti_1_auc: 0.6844 - val_anti_2_auc_1: 0.6193 - val_anti_3_auc_2: 0.6522 - val_anti_4_auc_3: 0.6177 - val_anti_5_auc_4: 0.7065\n",
            "Epoch 14/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1721 - anti_1_loss: 0.5632 - anti_2_loss: 0.6267 - anti_3_loss: 0.4447 - anti_4_loss: 0.3365 - anti_5_loss: 0.2010 - anti_1_auc: 0.7029 - anti_2_auc_1: 0.6228 - anti_3_auc_2: 0.6784 - anti_4_auc_3: 0.6330 - anti_5_auc_4: 0.7363 - val_loss: 2.2253 - val_anti_1_loss: 0.5625 - val_anti_2_loss: 0.6293 - val_anti_3_loss: 0.4580 - val_anti_4_loss: 0.3641 - val_anti_5_loss: 0.2115 - val_anti_1_auc: 0.6764 - val_anti_2_auc_1: 0.6244 - val_anti_3_auc_2: 0.6550 - val_anti_4_auc_3: 0.6089 - val_anti_5_auc_4: 0.7061\n",
            "Epoch 15/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1694 - anti_1_loss: 0.5629 - anti_2_loss: 0.6260 - anti_3_loss: 0.4435 - anti_4_loss: 0.3372 - anti_5_loss: 0.1998 - anti_1_auc: 0.7031 - anti_2_auc_1: 0.6237 - anti_3_auc_2: 0.6815 - anti_4_auc_3: 0.6289 - anti_5_auc_4: 0.7428 - val_loss: 2.2228 - val_anti_1_loss: 0.5634 - val_anti_2_loss: 0.6301 - val_anti_3_loss: 0.4555 - val_anti_4_loss: 0.3674 - val_anti_5_loss: 0.2064 - val_anti_1_auc: 0.6835 - val_anti_2_auc_1: 0.6295 - val_anti_3_auc_2: 0.6556 - val_anti_4_auc_3: 0.6106 - val_anti_5_auc_4: 0.7217\n",
            "Epoch 16/500\n",
            "455/455 [==============================] - 10s 23ms/step - loss: 2.1667 - anti_1_loss: 0.5619 - anti_2_loss: 0.6253 - anti_3_loss: 0.4434 - anti_4_loss: 0.3368 - anti_5_loss: 0.1993 - anti_1_auc: 0.7065 - anti_2_auc_1: 0.6270 - anti_3_auc_2: 0.6808 - anti_4_auc_3: 0.6319 - anti_5_auc_4: 0.7470 - val_loss: 2.2275 - val_anti_1_loss: 0.5666 - val_anti_2_loss: 0.6305 - val_anti_3_loss: 0.4547 - val_anti_4_loss: 0.3683 - val_anti_5_loss: 0.2074 - val_anti_1_auc: 0.6834 - val_anti_2_auc_1: 0.6236 - val_anti_3_auc_2: 0.6620 - val_anti_4_auc_3: 0.5956 - val_anti_5_auc_4: 0.7121\n",
            "Epoch 17/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1655 - anti_1_loss: 0.5608 - anti_2_loss: 0.6245 - anti_3_loss: 0.4438 - anti_4_loss: 0.3363 - anti_5_loss: 0.2001 - anti_1_auc: 0.7079 - anti_2_auc_1: 0.6294 - anti_3_auc_2: 0.6802 - anti_4_auc_3: 0.6329 - anti_5_auc_4: 0.7412 - val_loss: 2.2383 - val_anti_1_loss: 0.5728 - val_anti_2_loss: 0.6353 - val_anti_3_loss: 0.4582 - val_anti_4_loss: 0.3637 - val_anti_5_loss: 0.2083 - val_anti_1_auc: 0.6753 - val_anti_2_auc_1: 0.6135 - val_anti_3_auc_2: 0.6568 - val_anti_4_auc_3: 0.6109 - val_anti_5_auc_4: 0.7173\n",
            "Epoch 18/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1636 - anti_1_loss: 0.5612 - anti_2_loss: 0.6241 - anti_3_loss: 0.4427 - anti_4_loss: 0.3363 - anti_5_loss: 0.1992 - anti_1_auc: 0.7058 - anti_2_auc_1: 0.6286 - anti_3_auc_2: 0.6843 - anti_4_auc_3: 0.6331 - anti_5_auc_4: 0.7479 - val_loss: 2.2529 - val_anti_1_loss: 0.5804 - val_anti_2_loss: 0.6376 - val_anti_3_loss: 0.4567 - val_anti_4_loss: 0.3666 - val_anti_5_loss: 0.2115 - val_anti_1_auc: 0.6849 - val_anti_2_auc_1: 0.6141 - val_anti_3_auc_2: 0.6654 - val_anti_4_auc_3: 0.6080 - val_anti_5_auc_4: 0.7055\n",
            "Epoch 19/500\n",
            "455/455 [==============================] - 10s 23ms/step - loss: 2.1593 - anti_1_loss: 0.5587 - anti_2_loss: 0.6229 - anti_3_loss: 0.4427 - anti_4_loss: 0.3358 - anti_5_loss: 0.1991 - anti_1_auc: 0.7086 - anti_2_auc_1: 0.6319 - anti_3_auc_2: 0.6835 - anti_4_auc_3: 0.6362 - anti_5_auc_4: 0.7488 - val_loss: 2.2248 - val_anti_1_loss: 0.5657 - val_anti_2_loss: 0.6290 - val_anti_3_loss: 0.4582 - val_anti_4_loss: 0.3611 - val_anti_5_loss: 0.2108 - val_anti_1_auc: 0.6873 - val_anti_2_auc_1: 0.6316 - val_anti_3_auc_2: 0.6563 - val_anti_4_auc_3: 0.6231 - val_anti_5_auc_4: 0.7250\n",
            "Epoch 20/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1578 - anti_1_loss: 0.5578 - anti_2_loss: 0.6234 - anti_3_loss: 0.4416 - anti_4_loss: 0.3350 - anti_5_loss: 0.2000 - anti_1_auc: 0.7118 - anti_2_auc_1: 0.6309 - anti_3_auc_2: 0.6847 - anti_4_auc_3: 0.6400 - anti_5_auc_4: 0.7435 - val_loss: 2.2275 - val_anti_1_loss: 0.5632 - val_anti_2_loss: 0.6326 - val_anti_3_loss: 0.4602 - val_anti_4_loss: 0.3619 - val_anti_5_loss: 0.2097 - val_anti_1_auc: 0.6870 - val_anti_2_auc_1: 0.6243 - val_anti_3_auc_2: 0.6520 - val_anti_4_auc_3: 0.6242 - val_anti_5_auc_4: 0.7198\n",
            "Epoch 21/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1561 - anti_1_loss: 0.5587 - anti_2_loss: 0.6232 - anti_3_loss: 0.4398 - anti_4_loss: 0.3353 - anti_5_loss: 0.1991 - anti_1_auc: 0.7120 - anti_2_auc_1: 0.6319 - anti_3_auc_2: 0.6894 - anti_4_auc_3: 0.6385 - anti_5_auc_4: 0.7512 - val_loss: 2.2423 - val_anti_1_loss: 0.5732 - val_anti_2_loss: 0.6338 - val_anti_3_loss: 0.4590 - val_anti_4_loss: 0.3624 - val_anti_5_loss: 0.2139 - val_anti_1_auc: 0.6817 - val_anti_2_auc_1: 0.6248 - val_anti_3_auc_2: 0.6580 - val_anti_4_auc_3: 0.6176 - val_anti_5_auc_4: 0.6924\n",
            "Epoch 22/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1525 - anti_1_loss: 0.5570 - anti_2_loss: 0.6224 - anti_3_loss: 0.4401 - anti_4_loss: 0.3349 - anti_5_loss: 0.1981 - anti_1_auc: 0.7140 - anti_2_auc_1: 0.6335 - anti_3_auc_2: 0.6887 - anti_4_auc_3: 0.6425 - anti_5_auc_4: 0.7493 - val_loss: 2.2254 - val_anti_1_loss: 0.5611 - val_anti_2_loss: 0.6310 - val_anti_3_loss: 0.4580 - val_anti_4_loss: 0.3592 - val_anti_5_loss: 0.2160 - val_anti_1_auc: 0.6893 - val_anti_2_auc_1: 0.6198 - val_anti_3_auc_2: 0.6602 - val_anti_4_auc_3: 0.6302 - val_anti_5_auc_4: 0.6902\n",
            "Epoch 23/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1512 - anti_1_loss: 0.5574 - anti_2_loss: 0.6223 - anti_3_loss: 0.4395 - anti_4_loss: 0.3342 - anti_5_loss: 0.1978 - anti_1_auc: 0.7138 - anti_2_auc_1: 0.6325 - anti_3_auc_2: 0.6902 - anti_4_auc_3: 0.6464 - anti_5_auc_4: 0.7533 - val_loss: 2.2168 - val_anti_1_loss: 0.5621 - val_anti_2_loss: 0.6298 - val_anti_3_loss: 0.4556 - val_anti_4_loss: 0.3616 - val_anti_5_loss: 0.2077 - val_anti_1_auc: 0.6844 - val_anti_2_auc_1: 0.6277 - val_anti_3_auc_2: 0.6637 - val_anti_4_auc_3: 0.6191 - val_anti_5_auc_4: 0.7261\n",
            "Epoch 24/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1476 - anti_1_loss: 0.5563 - anti_2_loss: 0.6203 - anti_3_loss: 0.4392 - anti_4_loss: 0.3343 - anti_5_loss: 0.1974 - anti_1_auc: 0.7150 - anti_2_auc_1: 0.6392 - anti_3_auc_2: 0.6898 - anti_4_auc_3: 0.6468 - anti_5_auc_4: 0.7541 - val_loss: 2.2266 - val_anti_1_loss: 0.5691 - val_anti_2_loss: 0.6310 - val_anti_3_loss: 0.4572 - val_anti_4_loss: 0.3631 - val_anti_5_loss: 0.2061 - val_anti_1_auc: 0.6769 - val_anti_2_auc_1: 0.6274 - val_anti_3_auc_2: 0.6614 - val_anti_4_auc_3: 0.6163 - val_anti_5_auc_4: 0.7353\n",
            "Epoch 25/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1447 - anti_1_loss: 0.5537 - anti_2_loss: 0.6207 - anti_3_loss: 0.4383 - anti_4_loss: 0.3345 - anti_5_loss: 0.1975 - anti_1_auc: 0.7191 - anti_2_auc_1: 0.6360 - anti_3_auc_2: 0.6935 - anti_4_auc_3: 0.6442 - anti_5_auc_4: 0.7539 - val_loss: 2.2390 - val_anti_1_loss: 0.5737 - val_anti_2_loss: 0.6358 - val_anti_3_loss: 0.4630 - val_anti_4_loss: 0.3604 - val_anti_5_loss: 0.2062 - val_anti_1_auc: 0.6810 - val_anti_2_auc_1: 0.6188 - val_anti_3_auc_2: 0.6599 - val_anti_4_auc_3: 0.6267 - val_anti_5_auc_4: 0.7252\n",
            "Epoch 26/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1413 - anti_1_loss: 0.5527 - anti_2_loss: 0.6205 - anti_3_loss: 0.4371 - anti_4_loss: 0.3346 - anti_5_loss: 0.1964 - anti_1_auc: 0.7201 - anti_2_auc_1: 0.6353 - anti_3_auc_2: 0.6947 - anti_4_auc_3: 0.6430 - anti_5_auc_4: 0.7606 - val_loss: 2.2350 - val_anti_1_loss: 0.5709 - val_anti_2_loss: 0.6348 - val_anti_3_loss: 0.4601 - val_anti_4_loss: 0.3605 - val_anti_5_loss: 0.2087 - val_anti_1_auc: 0.6865 - val_anti_2_auc_1: 0.6227 - val_anti_3_auc_2: 0.6585 - val_anti_4_auc_3: 0.6239 - val_anti_5_auc_4: 0.7199\n",
            "Epoch 27/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1416 - anti_1_loss: 0.5542 - anti_2_loss: 0.6205 - anti_3_loss: 0.4374 - anti_4_loss: 0.3335 - anti_5_loss: 0.1959 - anti_1_auc: 0.7207 - anti_2_auc_1: 0.6390 - anti_3_auc_2: 0.6936 - anti_4_auc_3: 0.6516 - anti_5_auc_4: 0.7640 - val_loss: 2.2464 - val_anti_1_loss: 0.5692 - val_anti_2_loss: 0.6383 - val_anti_3_loss: 0.4577 - val_anti_4_loss: 0.3638 - val_anti_5_loss: 0.2174 - val_anti_1_auc: 0.6746 - val_anti_2_auc_1: 0.6151 - val_anti_3_auc_2: 0.6596 - val_anti_4_auc_3: 0.6112 - val_anti_5_auc_4: 0.7015\n",
            "Epoch 28/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1354 - anti_1_loss: 0.5518 - anti_2_loss: 0.6188 - anti_3_loss: 0.4361 - anti_4_loss: 0.3329 - anti_5_loss: 0.1957 - anti_1_auc: 0.7229 - anti_2_auc_1: 0.6421 - anti_3_auc_2: 0.6969 - anti_4_auc_3: 0.6532 - anti_5_auc_4: 0.7649 - val_loss: 2.2369 - val_anti_1_loss: 0.5678 - val_anti_2_loss: 0.6352 - val_anti_3_loss: 0.4567 - val_anti_4_loss: 0.3624 - val_anti_5_loss: 0.2148 - val_anti_1_auc: 0.6857 - val_anti_2_auc_1: 0.6250 - val_anti_3_auc_2: 0.6576 - val_anti_4_auc_3: 0.6131 - val_anti_5_auc_4: 0.6975\n",
            "Epoch 29/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1332 - anti_1_loss: 0.5494 - anti_2_loss: 0.6186 - anti_3_loss: 0.4359 - anti_4_loss: 0.3335 - anti_5_loss: 0.1958 - anti_1_auc: 0.7249 - anti_2_auc_1: 0.6423 - anti_3_auc_2: 0.6991 - anti_4_auc_3: 0.6511 - anti_5_auc_4: 0.7626 - val_loss: 2.2345 - val_anti_1_loss: 0.5631 - val_anti_2_loss: 0.6321 - val_anti_3_loss: 0.4626 - val_anti_4_loss: 0.3639 - val_anti_5_loss: 0.2128 - val_anti_1_auc: 0.6897 - val_anti_2_auc_1: 0.6215 - val_anti_3_auc_2: 0.6615 - val_anti_4_auc_3: 0.6219 - val_anti_5_auc_4: 0.7148\n",
            "Epoch 30/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1281 - anti_1_loss: 0.5503 - anti_2_loss: 0.6181 - anti_3_loss: 0.4335 - anti_4_loss: 0.3314 - anti_5_loss: 0.1949 - anti_1_auc: 0.7251 - anti_2_auc_1: 0.6419 - anti_3_auc_2: 0.7021 - anti_4_auc_3: 0.6591 - anti_5_auc_4: 0.7658 - val_loss: 2.2365 - val_anti_1_loss: 0.5668 - val_anti_2_loss: 0.6353 - val_anti_3_loss: 0.4576 - val_anti_4_loss: 0.3639 - val_anti_5_loss: 0.2128 - val_anti_1_auc: 0.6872 - val_anti_2_auc_1: 0.6244 - val_anti_3_auc_2: 0.6651 - val_anti_4_auc_3: 0.6257 - val_anti_5_auc_4: 0.7162\n",
            "Epoch 31/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1267 - anti_1_loss: 0.5473 - anti_2_loss: 0.6182 - anti_3_loss: 0.4353 - anti_4_loss: 0.3319 - anti_5_loss: 0.1940 - anti_1_auc: 0.7301 - anti_2_auc_1: 0.6420 - anti_3_auc_2: 0.7022 - anti_4_auc_3: 0.6577 - anti_5_auc_4: 0.7696 - val_loss: 2.2301 - val_anti_1_loss: 0.5658 - val_anti_2_loss: 0.6305 - val_anti_3_loss: 0.4566 - val_anti_4_loss: 0.3613 - val_anti_5_loss: 0.2159 - val_anti_1_auc: 0.6838 - val_anti_2_auc_1: 0.6217 - val_anti_3_auc_2: 0.6613 - val_anti_4_auc_3: 0.6194 - val_anti_5_auc_4: 0.7225\n",
            "Epoch 32/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1223 - anti_1_loss: 0.5479 - anti_2_loss: 0.6168 - anti_3_loss: 0.4332 - anti_4_loss: 0.3300 - anti_5_loss: 0.1944 - anti_1_auc: 0.7276 - anti_2_auc_1: 0.6469 - anti_3_auc_2: 0.7046 - anti_4_auc_3: 0.6662 - anti_5_auc_4: 0.7696 - val_loss: 2.2425 - val_anti_1_loss: 0.5700 - val_anti_2_loss: 0.6340 - val_anti_3_loss: 0.4616 - val_anti_4_loss: 0.3637 - val_anti_5_loss: 0.2133 - val_anti_1_auc: 0.6766 - val_anti_2_auc_1: 0.6221 - val_anti_3_auc_2: 0.6549 - val_anti_4_auc_3: 0.6145 - val_anti_5_auc_4: 0.6968\n",
            "Epoch 33/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1156 - anti_1_loss: 0.5457 - anti_2_loss: 0.6141 - anti_3_loss: 0.4317 - anti_4_loss: 0.3306 - anti_5_loss: 0.1935 - anti_1_auc: 0.7305 - anti_2_auc_1: 0.6525 - anti_3_auc_2: 0.7100 - anti_4_auc_3: 0.6644 - anti_5_auc_4: 0.7714 - val_loss: 2.2760 - val_anti_1_loss: 0.5776 - val_anti_2_loss: 0.6455 - val_anti_3_loss: 0.4625 - val_anti_4_loss: 0.3759 - val_anti_5_loss: 0.2146 - val_anti_1_auc: 0.6680 - val_anti_2_auc_1: 0.6106 - val_anti_3_auc_2: 0.6494 - val_anti_4_auc_3: 0.6076 - val_anti_5_auc_4: 0.6944\n",
            "Epoch 34/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1169 - anti_1_loss: 0.5449 - anti_2_loss: 0.6153 - anti_3_loss: 0.4326 - anti_4_loss: 0.3305 - anti_5_loss: 0.1935 - anti_1_auc: 0.7329 - anti_2_auc_1: 0.6493 - anti_3_auc_2: 0.7055 - anti_4_auc_3: 0.6631 - anti_5_auc_4: 0.7717 - val_loss: 2.2459 - val_anti_1_loss: 0.5704 - val_anti_2_loss: 0.6319 - val_anti_3_loss: 0.4617 - val_anti_4_loss: 0.3630 - val_anti_5_loss: 0.2189 - val_anti_1_auc: 0.6773 - val_anti_2_auc_1: 0.6212 - val_anti_3_auc_2: 0.6506 - val_anti_4_auc_3: 0.6175 - val_anti_5_auc_4: 0.7138\n",
            "Epoch 35/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1106 - anti_1_loss: 0.5427 - anti_2_loss: 0.6144 - anti_3_loss: 0.4316 - anti_4_loss: 0.3293 - anti_5_loss: 0.1927 - anti_1_auc: 0.7364 - anti_2_auc_1: 0.6510 - anti_3_auc_2: 0.7071 - anti_4_auc_3: 0.6704 - anti_5_auc_4: 0.7759 - val_loss: 2.2452 - val_anti_1_loss: 0.5772 - val_anti_2_loss: 0.6350 - val_anti_3_loss: 0.4588 - val_anti_4_loss: 0.3637 - val_anti_5_loss: 0.2105 - val_anti_1_auc: 0.6781 - val_anti_2_auc_1: 0.6203 - val_anti_3_auc_2: 0.6676 - val_anti_4_auc_3: 0.6041 - val_anti_5_auc_4: 0.7085\n",
            "Epoch 36/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1065 - anti_1_loss: 0.5410 - anti_2_loss: 0.6130 - anti_3_loss: 0.4310 - anti_4_loss: 0.3294 - anti_5_loss: 0.1921 - anti_1_auc: 0.7392 - anti_2_auc_1: 0.6531 - anti_3_auc_2: 0.7098 - anti_4_auc_3: 0.6694 - anti_5_auc_4: 0.7772 - val_loss: 2.2460 - val_anti_1_loss: 0.5710 - val_anti_2_loss: 0.6352 - val_anti_3_loss: 0.4641 - val_anti_4_loss: 0.3646 - val_anti_5_loss: 0.2112 - val_anti_1_auc: 0.6804 - val_anti_2_auc_1: 0.6173 - val_anti_3_auc_2: 0.6517 - val_anti_4_auc_3: 0.6155 - val_anti_5_auc_4: 0.7142\n",
            "Epoch 37/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1045 - anti_1_loss: 0.5431 - anti_2_loss: 0.6133 - anti_3_loss: 0.4289 - anti_4_loss: 0.3281 - anti_5_loss: 0.1910 - anti_1_auc: 0.7352 - anti_2_auc_1: 0.6536 - anti_3_auc_2: 0.7134 - anti_4_auc_3: 0.6763 - anti_5_auc_4: 0.7815 - val_loss: 2.2428 - val_anti_1_loss: 0.5700 - val_anti_2_loss: 0.6337 - val_anti_3_loss: 0.4628 - val_anti_4_loss: 0.3654 - val_anti_5_loss: 0.2109 - val_anti_1_auc: 0.6811 - val_anti_2_auc_1: 0.6202 - val_anti_3_auc_2: 0.6664 - val_anti_4_auc_3: 0.6083 - val_anti_5_auc_4: 0.7122\n",
            "Epoch 38/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.1006 - anti_1_loss: 0.5406 - anti_2_loss: 0.6128 - anti_3_loss: 0.4281 - anti_4_loss: 0.3278 - anti_5_loss: 0.1913 - anti_1_auc: 0.7405 - anti_2_auc_1: 0.6565 - anti_3_auc_2: 0.7152 - anti_4_auc_3: 0.6764 - anti_5_auc_4: 0.7824 - val_loss: 2.2540 - val_anti_1_loss: 0.5731 - val_anti_2_loss: 0.6384 - val_anti_3_loss: 0.4685 - val_anti_4_loss: 0.3658 - val_anti_5_loss: 0.2082 - val_anti_1_auc: 0.6803 - val_anti_2_auc_1: 0.6230 - val_anti_3_auc_2: 0.6537 - val_anti_4_auc_3: 0.6157 - val_anti_5_auc_4: 0.7134\n",
            "Epoch 39/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.0910 - anti_1_loss: 0.5365 - anti_2_loss: 0.6107 - anti_3_loss: 0.4262 - anti_4_loss: 0.3275 - anti_5_loss: 0.1900 - anti_1_auc: 0.7435 - anti_2_auc_1: 0.6601 - anti_3_auc_2: 0.7191 - anti_4_auc_3: 0.6794 - anti_5_auc_4: 0.7856 - val_loss: 2.2520 - val_anti_1_loss: 0.5760 - val_anti_2_loss: 0.6340 - val_anti_3_loss: 0.4593 - val_anti_4_loss: 0.3678 - val_anti_5_loss: 0.2149 - val_anti_1_auc: 0.6783 - val_anti_2_auc_1: 0.6195 - val_anti_3_auc_2: 0.6630 - val_anti_4_auc_3: 0.5922 - val_anti_5_auc_4: 0.6841\n",
            "Epoch 40/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.0932 - anti_1_loss: 0.5387 - anti_2_loss: 0.6111 - anti_3_loss: 0.4262 - anti_4_loss: 0.3271 - anti_5_loss: 0.1901 - anti_1_auc: 0.7415 - anti_2_auc_1: 0.6604 - anti_3_auc_2: 0.7199 - anti_4_auc_3: 0.6796 - anti_5_auc_4: 0.7874 - val_loss: 2.2530 - val_anti_1_loss: 0.5734 - val_anti_2_loss: 0.6362 - val_anti_3_loss: 0.4648 - val_anti_4_loss: 0.3659 - val_anti_5_loss: 0.2127 - val_anti_1_auc: 0.6779 - val_anti_2_auc_1: 0.6193 - val_anti_3_auc_2: 0.6563 - val_anti_4_auc_3: 0.6059 - val_anti_5_auc_4: 0.7156\n",
            "Epoch 41/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.0861 - anti_1_loss: 0.5375 - anti_2_loss: 0.6095 - anti_3_loss: 0.4254 - anti_4_loss: 0.3256 - anti_5_loss: 0.1882 - anti_1_auc: 0.7439 - anti_2_auc_1: 0.6624 - anti_3_auc_2: 0.7184 - anti_4_auc_3: 0.6846 - anti_5_auc_4: 0.7913 - val_loss: 2.2700 - val_anti_1_loss: 0.5838 - val_anti_2_loss: 0.6400 - val_anti_3_loss: 0.4632 - val_anti_4_loss: 0.3688 - val_anti_5_loss: 0.2143 - val_anti_1_auc: 0.6782 - val_anti_2_auc_1: 0.6211 - val_anti_3_auc_2: 0.6587 - val_anti_4_auc_3: 0.6117 - val_anti_5_auc_4: 0.7063\n",
            "Epoch 42/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.0804 - anti_1_loss: 0.5342 - anti_2_loss: 0.6076 - anti_3_loss: 0.4242 - anti_4_loss: 0.3256 - anti_5_loss: 0.1888 - anti_1_auc: 0.7492 - anti_2_auc_1: 0.6663 - anti_3_auc_2: 0.7237 - anti_4_auc_3: 0.6880 - anti_5_auc_4: 0.7922 - val_loss: 2.2574 - val_anti_1_loss: 0.5798 - val_anti_2_loss: 0.6332 - val_anti_3_loss: 0.4646 - val_anti_4_loss: 0.3679 - val_anti_5_loss: 0.2119 - val_anti_1_auc: 0.6784 - val_anti_2_auc_1: 0.6232 - val_anti_3_auc_2: 0.6552 - val_anti_4_auc_3: 0.6057 - val_anti_5_auc_4: 0.7144\n",
            "Epoch 43/500\n",
            "455/455 [==============================] - 10s 22ms/step - loss: 2.0772 - anti_1_loss: 0.5345 - anti_2_loss: 0.6079 - anti_3_loss: 0.4215 - anti_4_loss: 0.3252 - anti_5_loss: 0.1881 - anti_1_auc: 0.7483 - anti_2_auc_1: 0.6662 - anti_3_auc_2: 0.7283 - anti_4_auc_3: 0.6881 - anti_5_auc_4: 0.7945 - val_loss: 2.2686 - val_anti_1_loss: 0.5756 - val_anti_2_loss: 0.6346 - val_anti_3_loss: 0.4710 - val_anti_4_loss: 0.3689 - val_anti_5_loss: 0.2184 - val_anti_1_auc: 0.6820 - val_anti_2_auc_1: 0.6169 - val_anti_3_auc_2: 0.6518 - val_anti_4_auc_3: 0.5988 - val_anti_5_auc_4: 0.6859\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import pyplot as plt\n",
        "plt.plot(history_lstm.history['anti_1_auc'])\n",
        "plt.plot(history_lstm.history['val_anti_1_auc'])\n",
        "plt.plot(history_lstm.history['anti_2_auc_1'])\n",
        "plt.plot(history_lstm.history['val_anti_2_auc_1'])\n",
        "plt.plot(history_lstm.history['anti_3_auc_2'])\n",
        "plt.plot(history_lstm.history['val_anti_3_auc_2'])\n",
        "plt.plot(history_lstm.history['anti_4_auc_3'])\n",
        "plt.plot(history_lstm.history['val_anti_4_auc_3'])\n",
        "plt.plot(history_lstm.history['anti_5_auc_4'])\n",
        "plt.plot(history_lstm.history['val_anti_5_auc_4'])\n",
        "plt.title('model auc')\n",
        "plt.ylabel('auc')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['anti_1_train', 'anti_1_val','anti_2_train', 'anti_2_val','anti_3_train', 'anti_3_val','anti_4_train', 'anti_4_val','anti_5_train', 'anti_5_val'], loc='lower left',bbox_to_anchor=(1, 0))\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "MFX2sxvhZvaY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 최종모형"
      ],
      "metadata": {
        "id": "lXbI8m73DWr0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "death_train_loader = Death_Dataloader2(death_train['DATA'], death_train['EXTRA'], death_train['LABEL'], death_train['HADM_IDS'], 64, True)\n",
        "death_test_loader = Death_Dataloader2(death_test['DATA'], death_test['EXTRA'], death_test['LABEL'], death_test['HADM_IDS'], 64, False)"
      ],
      "metadata": {
        "id": "Y_zblG0LZi7J"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "base_model = keras.models.load_model('/content/gdrive/MyDrive/sepsis_model_weight/lstm_model/lstm_model_many.23-2.217.h5')"
      ],
      "metadata": {
        "id": "wBVkGX5GqZWM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "base_model.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CsW4W3xqwDvB",
        "outputId": "ca05f296-2524-485a-d07c-0d64635ea4a3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"model\"\n",
            "__________________________________________________________________________________________________\n",
            " Layer (type)                   Output Shape         Param #     Connected to                     \n",
            "==================================================================================================\n",
            " input_1 (InputLayer)           [(None, 24, 22)]     0           []                               \n",
            "                                                                                                  \n",
            " lstm (LSTM)                    (None, 24, 64)       22272       ['input_1[0][0]']                \n",
            "                                                                                                  \n",
            " lstm_1 (LSTM)                  (None, 64)           33024       ['lstm[0][0]']                   \n",
            "                                                                                                  \n",
            " dense (Dense)                  (None, 32)           2080        ['lstm_1[0][0]']                 \n",
            "                                                                                                  \n",
            " batch_normalization (BatchNorm  (None, 32)          128         ['dense[0][0]']                  \n",
            " alization)                                                                                       \n",
            "                                                                                                  \n",
            " activation (Activation)        (None, 32)           0           ['batch_normalization[0][0]']    \n",
            "                                                                                                  \n",
            " input_2 (InputLayer)           [(None, 2)]          0           []                               \n",
            "                                                                                                  \n",
            " dense_1 (Dense)                (None, 32)           1056        ['activation[0][0]']             \n",
            "                                                                                                  \n",
            " dense_4 (Dense)                (None, 32)           96          ['input_2[0][0]']                \n",
            "                                                                                                  \n",
            " batch_normalization_1 (BatchNo  (None, 32)          128         ['dense_1[0][0]']                \n",
            " rmalization)                                                                                     \n",
            "                                                                                                  \n",
            " batch_normalization_3 (BatchNo  (None, 32)          128         ['dense_4[0][0]']                \n",
            " rmalization)                                                                                     \n",
            "                                                                                                  \n",
            " activation_1 (Activation)      (None, 32)           0           ['batch_normalization_1[0][0]']  \n",
            "                                                                                                  \n",
            " activation_3 (Activation)      (None, 32)           0           ['batch_normalization_3[0][0]']  \n",
            "                                                                                                  \n",
            " dropout (Dropout)              (None, 32)           0           ['activation_1[0][0]']           \n",
            "                                                                                                  \n",
            " dropout_1 (Dropout)            (None, 32)           0           ['activation_3[0][0]']           \n",
            "                                                                                                  \n",
            " dense_2 (Dense)                (None, 16)           528         ['dropout[0][0]']                \n",
            "                                                                                                  \n",
            " dense_5 (Dense)                (None, 16)           528         ['dropout_1[0][0]']              \n",
            "                                                                                                  \n",
            " add (Add)                      (None, 16)           0           ['dense_2[0][0]',                \n",
            "                                                                  'dense_5[0][0]']                \n",
            "                                                                                                  \n",
            " dense_6 (Dense)                (None, 16)           272         ['add[0][0]']                    \n",
            "                                                                                                  \n",
            " batch_normalization_4 (BatchNo  (None, 16)          64          ['dense_6[0][0]']                \n",
            " rmalization)                                                                                     \n",
            "                                                                                                  \n",
            " dense_7 (Dense)                (None, 16)           272         ['batch_normalization_4[0][0]']  \n",
            "                                                                                                  \n",
            " batch_normalization_5 (BatchNo  (None, 16)          64          ['dense_7[0][0]']                \n",
            " rmalization)                                                                                     \n",
            "                                                                                                  \n",
            " anti_1 (Dense)                 (None, 1)            17          ['batch_normalization_5[0][0]']  \n",
            "                                                                                                  \n",
            " anti_2 (Dense)                 (None, 1)            17          ['batch_normalization_5[0][0]']  \n",
            "                                                                                                  \n",
            " anti_3 (Dense)                 (None, 1)            17          ['batch_normalization_5[0][0]']  \n",
            "                                                                                                  \n",
            " anti_4 (Dense)                 (None, 1)            17          ['batch_normalization_5[0][0]']  \n",
            "                                                                                                  \n",
            " anti_5 (Dense)                 (None, 1)            17          ['batch_normalization_5[0][0]']  \n",
            "                                                                                                  \n",
            "==================================================================================================\n",
            "Total params: 60,725\n",
            "Trainable params: 60,469\n",
            "Non-trainable params: 256\n",
            "__________________________________________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def last_model():\n",
        "    x = base_model(base_model.input,training=False)\n",
        "    outs = layers.Dense(1, activation='sigmoid',name='death')(base_model.layers[-6].output)\n",
        "    model = keras.Model(base_model.input, outs)\n",
        "    model.compile(loss={'death':'binary_crossentropy'},metrics={'death':'AUC'})\n",
        "  \n",
        "    return model\n",
        "\n",
        "model4=last_model()"
      ],
      "metadata": {
        "id": "92gj-wravJ8T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "optimizers = [\n",
        "    keras.optimizers.Adam(learning_rate=1e-4),\n",
        "    keras.optimizers.Adam(learning_rate=1e-2)\n",
        "]\n",
        "optimizers_and_layers = [(optimizers[0], model4.layers[0:-1]), (optimizers[1], model4.layers[-1])]\n",
        "optimizer = tfa.optimizers.MultiOptimizer(optimizers_and_layers)"
      ],
      "metadata": {
        "id": "CWwi7gcLZfDr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from keras.utils import plot_model\n",
        "plot_model(model4, to_file='./model.png')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "-GqcXBqKMV-l",
        "outputId": "2d148980-3275-4d1a-febe-c292e75dc11c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAw0AAAZRCAIAAAB89+icAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdfVxUdf7///cZZmCYUa4EwURAoEKULC+KSK3c1bXaXJVLFa+2+nqxrVmalFnrrnZhmriZ2ra6bmkpIG5lbZ/cyqtCzNLUVMg0JSUFuVRAuTq/P85v58biWwSc4XDxuP/FOec97/N6H88MT9/nzEFRVVUAAADgKga9CwAAAGilyEkAAABy5CQAAAA5chIAAICcUe8CWrs9e/YsW7ZM7yrQJj311FN333233lUAAJqP+aTr+Pnnnzdv3qx3FTrIzMzMzMzUu4o2bPPmzT///LPeVQAAbgjzSY2SlpamdwktLTY2VnTIgduLoih6lwAAuFHMJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpxkH//+97/d3d23bt2qdyEStbW1ycnJUVFRdu85MzOzV69eBoNBURRfX99FixbZfRfXkp6eHhwcrCiKoih+fn6JiYkttmsAQMdh1LuAdkJVVb1LkDt+/PiUKVO++uqrvn372r3zyMjIY8eOjRgx4tNPP83Ozvbw8LD7Lq4lOjo6Ojo6NDT0woUL586da7H9AgA6FOaT7OOhhx4qKSl5+OGHHb2jioqKxs8MHTx48Jlnnpk+ffrtt9/u0KpaRpPGDgDAjSMntTFr167Ny8trZOO+ffump6ePHz/excXFoVW1jCaNHQCAG0dOsoMvv/wyICBAUZQ33nhDCLFq1Sqr1WqxWD744IMHHnjAzc3N399/48aNWuPXX3/dbDZ37dp12rRp3bp1M5vNUVFRe/fu1bbOnDnT2dnZz89PW/zDH/5gtVoVRblw4YIQYtasWbNnzz5x4oSiKKGhoXqM9Tpa29h3794dHh7u7u5uNpsjIiI+/fRTIcSjjz6q3dgUEhJy4MABIcSUKVMsFou7u/uHH34ohKipqXnhhRcCAgJcXV1vu+22lJQUIcSrr75qsVg6d+6cl5c3e/bs7t27Z2dn2/PYAQBaIRUN0n5HXrfZzz//LIRYsWKFtvjcc88JIT7//POSkpK8vLzBgwdbrdbKykpt69SpU61W69GjRy9fvnzkyJGBAwd27tw5JydH2zp+/HhfX19bz0uWLBFC5Ofna4vR0dEhISFNHcVdd93Vt2/fJr0kJiYmJiamMS1/85vfCCGKioq0xZYce0hIiLu7ewO1paWlLViwoLCwsKCgIDIyskuXLraunJyczp49a2s5bty4Dz/8UPt5zpw5Li4umzdvLioqmjdvnsFg2Ldvn21oTzzxxIoVK8aMGXPs2LEGdi2ESElJuc6xAwC0bswnOVBUVJSbm5uPj09CQkJZWVlOTo5tk9Fo7NWrl4uLS3h4+KpVqy5evLhu3TodS7W7VjL2mJiYP/3pT56enl5eXiNHjiwoKMjPzxdCTJ8+vaamxrbf0tLSffv2Pfjgg0KIy5cvr1q1avTo0dHR0R4eHvPnzzeZTHUrfOWVVx5//PH09PSwsDAHlQ0AaCXISS3B2dlZCFFVVSXdOmDAAIvFkpWV1bJFtZDWM3aTySSEqKmpEUIMHTr0lltu+cc//qGqqhBi06ZNCQkJTk5OQojs7Ozy8vI+ffpor3J1dfXz82uv/zoAgIaRk1oFFxcXbZ6jA3Lo2D/++OP77rvPx8fHxcVl7ty5tvWKokybNu3kyZOff/65EOKdd9555JFHtE1lZWVCiPnz5yv/dfr06fLycgdVCABozchJ+quqqiouLvb399e7EB04Yuy7du1KTk4WQuTk5IwePdrPz2/v3r0lJSWLFy+u22zy5Mlms3nNmjXZ2dlubm6BgYHaeh8fHyFEcnJy3evTe/bssWOFAIC2gudM6m/Hjh2qqkZGRmqLRqPxWlep2h9HjP3bb7+1Wq1CiMOHD1dVVc2YMSM4OFgIoShK3Waenp7x8fGbNm3q3LnzY489Zlvfo0cPs9n83Xff3WAZAIB2gPkkfdTW1hYVFVVXVx86dGjWrFkBAQGTJ0/WNoWGhhYWFr7//vtVVVX5+fmnT5+u+0IvL6/c3NxTp05dvHixjcYpx429qqrq/PnzO3bs0HJSQECAEOKzzz67fPny8ePHbQ8gsJk+ffqVK1c++uijug8INZvNU6ZM2bhx46pVq0pLS2tqas6cOfPLL7/Y9RgAANoIXb5l14Y05rkAK1as0J76Y7FYRo4cuXLlSovFIoS4+eabT5w48dZbb7m5uQkhAgMDf/jhB1VVp06dajKZunfvbjQa3dzcRo0adeLECVtvBQUF999/v9ls7tmz5x//+Menn35aCBEaGqp9eX7//v2BgYGurq6DBg06d+5cw4Xt2bPnnnvu6datm/Zv7efnFxUVtXPnzsYMvDHPBcjMzOzdu7fBYNA6f/HFF1ts7KtXrw4JCbnWWb1lyxatw6SkJC8vLw8Pj9jYWO3pViEhIbbHEKiqescddzz77LP1xnXlypWkpKSAgACj0ejj4xMdHX3kyJHFixe7uroKIXr06LF+/frrHkDBcwEAoO1T1Nb6h8laidTU1Pj4ePsepWnTpqWlpRUUFNixT7uLjY0VQqSlpdm329Y29oceeuiNN97o2bOn3XtWFCUlJSUuLs7uPQMAWgzX3fShfTu9Y9J97LZrdocOHdLmrvStBwDQapGT2qqsrCzl2hISEvQusPVKSko6fvz4Dz/8MGXKlIULF+pdDgCg9SIntbR58+atW7eupKSkZ8+emzdvbnY/YWFhDVxP3bRpkx1rthd7jf0GWSyWsLCwX//61wsWLAgPD9erDABA68f9SdfhiPuT2gQH3Z/UcXB/EgC0A8wnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAICcUe8C2obY2Fi9S2hpmZmZokMOHAAAG3LSdfTo0SMmJkbvKnQQGRl53TbffPONEGLAgAGOL6ftiYmJ6dGjh95VAABuiKKqqt41oK2Ki4sTQqSmpupdCAAADsH9SQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcoqqqnrXgDbjn//85/Lly2tqarTF/Px8IYSPj4+26OTkNGvWrMmTJ+tVHgAA9kVOQhNkZ2eHhYU10ODYsWMNNwAAoA3huhua4NZbb42IiFAU5epNiqJEREQQkgAA7Qk5CU0zceJEJyenq9cbjcZJkya1fD0AADgO193QNLm5uf7+/lefNoqi5OTk+Pv761IVAACOwHwSmuamm26KiooyGP7nzDEYDFFRUYQkAEA7Q05Ck02YMKHeLUqKokycOFGvegAAcBCuu6HJCgsLfX19q6urbWucnJzOnz/fpUsXHasCAMDumE9Ck3l5eQ0bNsxoNGqLTk5Ow4YNIyQBANofchKaIzExsba2VvtZVdUJEyboWw8AAI7AdTc0R1lZmbe39+XLl4UQLi4uFy5c6NSpk95FAQBgZ8wnoTmsVuvIkSNNJpPRaBw1ahQhCQDQLpGT0Ezjx4+vrq6uqakZN26c3rUAAOAQRr0L6LjOnDmTkZGhdxXNV1NTYzabVVW9dOlSamqq3uU0H09+AgBcC/cn6SY1NTU+Pl7vKiBSUlLi4uL0rgIA0Boxn6SzVp5TY2NjhRBpaWnSrdu3b1cU5b777mvRmuxK+jd9AQDQkJPQfPfee6/eJQAA4EDkJDRfvb/yBgBAO8PvOQAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR05q1ZYuXdq1a1dFUd588029a7mm9PT04OBgRVEURfHz80tMTLxWy4MHDyYkJPTs2dPFxcXb27tv376LFi3SNiUkJCgN+uijj+ru6Pnnn5fuYtmyZYqiGAyGsLCwXbt2OWTAAIAOg5zUqs2ZMycjI0PvKq4jOjr65MmTISEh7u7u586d27Bhg7TZ4cOHo6Ki/Pz8tm/fXlJSkpGRMWLEiB07dtgabNu2rbi4uKqq6pdffhFCjBw5srKysqysLC8v77HHHqu7IyHEmjVrqqqq6u2ipqbm9ddfF0IMHTo0KytryJAhjhkxAKCjICe1BxUVFVFRUXpXcR1Lly718PBYvnx5UFCQ2Wy+5ZZbFi5c6Orqqm1VFOWee+5xd3c3Go22NSaTyWKx+Pj49O/fv25X/fv3P3fu3Pvvv19vF+np6d27d2+BsQAAOghyUnuwdu3avLw8vau4joKCgpKSksLCQtsaZ2fnrVu3aj9v3LjRYrFc67VTp0797W9/a1ucMWOGEGL16tX1mi1btmz27Nn2LBoA0LGRk9qYnTt33nnnnRaLxc3NLSIiorS0dNasWbNnzz5x4oSiKKGhocuXL7darQaDoX///r6+viaTyWq19uvXb/DgwT169DCbzR4eHnPnzm35ygcOHFhWVjZ06NCvvvrqBrsaOnRor169tm/fnp2dbVv51VdflZeXDx8+/AY7BwDAhpzUlpSVlY0cOTImJqawsPD48eO33HJLZWXl8uXLH3744ZCQEFVVf/zxx1mzZj399NOqqq5evfqnn346d+7ckCFDDhw48Oyzzx44cKCwsHDSpElLliw5ePBgCxc/d+7cAQMGHDx4cNCgQb1793711Vfrzi011bRp04QQdW9vf+2115566ik7FAoAwH+Rk9qSU6dOlZaW9u7d22w2+/r6pqene3t7X6txeHi4xWLp0qXL2LFjhRABAQHe3t4Wi0X7PlpWVlbL1S2EEMLV1TUjI+Ovf/1rWFjY0aNHk5KSevXqtXPnzub1NmnSJKvV+vbbb1dUVAghTp48uW/fvnHjxtm1ZABAR0dOakuCg4O7du2amJi4YMGCU6dONfJVzs7OQojq6mpt0WQyCSGu/rJYCzCZTDNnzjx27FhmZuaoUaPy8vJiY2OLioqa0ZW7u/u4ceOKioo2bdokhEhOTp4xY4Y2UgAA7IWc1Ja4urp+8cUXgwYNevHFF4ODgxMSErTZlDbnrrvu+te//jV9+vT8/Pzt27c3rxPtbu4333yzuLg4LS1NuxIHAIAdkZPamN69e2/dujU3NzcpKSklJWXp0qV6V9SQXbt2JScnaz9HR0fb5rQ0EyZMEEKUl5c3r/Pbb789MjLy66+/njp1amxsrKen5w1WCwBAPeSktiQ3N/fo0aNCCB8fn5dffrlfv37aYqv17bffWq1W7ecrV67Uq1b7ttptt93W7P61KaXNmzc/+eSTN1AmAABy5KS2JDc3d9q0aVlZWZWVlQcOHDh9+nRkZKQQwsvLKzc399SpUxcvXtTlxqOrVVVVnT9/fseOHbacJIQYPXp0ampqcXFxSUnJBx988Mwzz/zud7+7kZwUFxfn7e09evTo4OBge1QNAMD/UqGTlJSU6x7/1157zdfXVwhhtVrHjBlz6tSpqKgoT09PJyenm2666bnnnquurlZVdf/+/YGBga6uroMGDXr22We1BzYGBQXt3r37lVdecXd3F0L4+vq+++67mzZt0jr09PTcuHHjdYuMiYmJiYlpuM2WLVu0vyUitWXLFq3Ztm3b4uPjQ0JCXFxcnJ2db7311gULFly+fLluV6WlpUOGDPHy8hJCGAyG0NDQF1988eodeXt7P/7449rKuXPnZmRkaD/Pnz/fz89Pe214ePju3buvO0AhREpKynWbAQA6JkVV1RZIY7haampqfHx8Kz/+sbGxQoi0tDS9C3EURVFSUlLi4uL0LgQA0Bpx3Q0AAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAzqh3AR1damqq3iU05MyZM6LVFwkAgIOQk3QWHx+vdwnX1yaKBADA7hRVVfWuAW1VXFycYLYJANB+cX8SAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAICcUe8C0Jbs3LkzMzPTtpiVlSWEWLx4sW1NZGTkvffeq0NlAAA4gKKqqt41oM34z3/+M3z4cJPJZDDUn4msra2tqqratm3bsGHDdKkNAAC7IyehCWpqanx9fQsKCqRbPT098/LyjEYmKQEA7QT3J6EJnJycxo8f7+zsfPUmZ2fnCRMmEJIAAO0JOQlNM3bs2MrKyqvXV1ZWjh07tuXrAQDAcbjuhiYLDAzMycmpt9Lf3z8nJ0dRFF1KAgDAEZhPQpMlJiaaTKa6a5ydnSdNmkRIAgC0M8wnocmOHTsWHh5eb+Xhw4f79OmjSz0AADgIOQnNER4efuzYMdtiWFhY3UUAANoHrruhOSZOnGi79GYymSZNmqRvPQAAOALzSWiOnJycoKAg7eRRFOXkyZNBQUF6FwUAgJ0xn4TmCAgIGDBggMFgUBRl4MCBhCQAQLtETkIzTZw40WAwODk5TZgwQe9aAABwCK67oZny8/O7desmhDh79qyvr6/e5QAAYH/kJAdKTU2Nj4/XuwrckJSUlLi4OL2rAADog7/G5XApKSl6l+Ao8+bNE0K89NJLehfiKMRcAOjgyEkO145nI9577z3RrgdITgKADo6chOar99dLAABoZ/i+GwAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZN0tnTp0q5duyqK8uabb+pYRm1tbXJyclRUlN17Tk9PDw4OVhRFURQ/P7/ExMRrtTx48GBCQkLPnj1dXFy8vb379u27aNEibVNCQoLSoI8++qjujp5//nnpLpYtW6YoisFgCAsL27Vrl90HCwBoZ8hJOpszZ05GRoa+NRw/fnzIkCFPPfVUeXm53TuPjo4+efJkSEiIu7v7uXPnNmzYIG12+PDhqKgoPz+/7du3l5SUZGRkjBgxYseOHbYG27ZtKy4urqqq+uWXX4QQI0eOrKysLCsry8vLe+yxx+ruSAixZs2aqqqqeruoqal5/fXXhRBDhw7NysoaMmSI3QcLAGhnyEltQ0VFhSMme4QQBw8efOaZZ6ZPn3777bc7ov9GWrp0qYeHx/Lly4OCgsxm8y233LJw4UJXV1dtq6Io99xzj7u7u9FotK0xmUwWi8XHx6d///51u+rfv/+5c+fef//9ertIT0/v3r17C4wFANBukJPahrVr1+bl5Tmi5759+6anp48fP97FxcUR/TdSQUFBSUlJYWGhbY2zs/PWrVu1nzdu3GixWK712qlTp/72t7+1Lc6YMUMIsXr16nrNli1bNnv2bHsWDQBo78hJrc7OnTvvvPNOi8Xi5uYWERFRWlo6a9as2bNnnzhxQlGU0NDQ5cuXW61Wg8HQv39/X19fk8lktVr79es3ePDgHj16mM1mDw+PuXPn6j2Ophk4cGBZWdnQoUO/+uqrG+xq6NChvXr12r59e3Z2tm3lV199VV5ePnz48BvsHADQoZCTWpeysrKRI0fGxMQUFhYeP378lltuqaysXL58+cMPPxwSEqKq6o8//jhr1qynn35aVdXVq1f/9NNP586dGzJkyIEDB5599tkDBw4UFhZOmjRpyZIlBw8e1Hs0TTB37twBAwYcPHhw0KBBvXv3fvXVV+vOLTXVtGnThBB1b41/7bXXnnrqKTsUCgDoSMhJrcupU6dKS0t79+5tNpt9fX3T09O9vb2v1Tg8PNxisXTp0mXs2LFCiICAAG9vb4vFon2nLCsrq+XqvmGurq4ZGRl//etfw8LCjh49mpSU1KtXr507dzavt0mTJlmt1rfffruiokIIcfLkyX379o0bN86uJQMA2j9yUusSHBzctWvXxMTEBQsWnDp1qpGvcnZ2FkJUV1driyaTSQhx9Re+WjmTyTRz5sxjx45lZmaOGjUqLy8vNja2qKioGV25u7uPGzeuqKho06ZNQojk5OQZM2ZoRwkAgMYjJ7Uurq6uX3zxxaBBg1588cXg4OCEhARtRqRDueuuu/71r39Nnz49Pz9/+/btzetEu5v7zTffLC4uTktL067EAQDQJOSkVqd3795bt27Nzc1NSkpKSUlZunSp3hU5yq5du5KTk7Wfo6OjbfNhmgkTJgghmv1Ip9tvvz0yMvLrr7+eOnVqbGysp6fnDVYLAOiAyEmtS25u7tGjR4UQPj4+L7/8cr9+/bTFdunbb7+1Wq3az1euXKk3Uu3barfddluz+9emlDZv3vzkk0/eQJkAgI6LnNS65ObmTps2LSsrq7Ky8sCBA6dPn46MjBRCeHl55ebmnjp16uLFi23uxqOrVVVVnT9/fseOHbacJIQYPXp0ampqcXFxSUnJBx988Mwzz/zud7+7kZwUFxfn7e09evTo4OBge1QNAOh4VDhMSkrKdY/wa6+95uvrK4SwWq1jxow5depUVFSUp6enk5PTTTfd9Nxzz1VXV6uqun///sDAQFdX10GDBj377LPaQxeDgoJ27979yiuvuLu7CyF8fX3ffffdTZs2aR16enpu3LjxukXu2bPnnnvu6datm3Y++Pn5RUVF7dy5szEDjImJiYmJabjNli1btL8lIrVlyxat2bZt2+Lj40NCQlxcXJydnW+99dYFCxZcvny5blelpaVDhgzx8vISQhgMhtDQ0BdffPHqHXl7ez/++OPayrlz52ZkZGg/z58/38/PT3tteHj47t27rztAIURKSkpjDgUAoF1SVFV1cBLruFJTU+Pj49vxEY6NjRVCpKWl6V2IoyiKkpKSEhcXp3chAAB9cN0NAABAjpzUnmVlZSnXlpCQoHeBAAC0aka9C4ADhYWFteOrfgAAOBrzSQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQM+pdQPunKIreJThWux8gAKDDUlRV1buGduvMmTMZGRl6V+FAycnJQognn3xS70IcKCoqyt/fX+8qAAD6ICeh+eLi4oQQqampehcCAIBDcH8SAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5o94FoC25cOFCaWmpbbGsrEwIcfLkSdsaNzc3b29vHSoDAMABFFVV9a4BbcbatWsfffTRBhqsWbPmkUceabF6AABwKHISmqCoqMjX17eqqkq61WQynT9/3tPTs4WrAgDAQbg/CU3g6ek5YsQIo1FyudZoND7wwAOEJABAe0JOQtMkJibW1NRcvb6mpiYxMbHl6wEAwHG47oamuXz5cpcuXcrLy+utd3V1vXDhgsVi0aUqAAAcgfkkNI3ZbB49erTJZKq70mQyRUdHE5IAAO0MOQlNNm7cuHq3cldVVY0bN06vegAAcBCuu6HJqquru3btWlRUZFvj4eGRl5dXb5IJAIC2jvkkNJnRaExISHB2dtYWTSbTuHHjCEkAgPaHnITmGDt2bGVlpfZzVVXV2LFj9a0HAABH4LobmkNVVX9//9zcXCGEn59fbm6uoih6FwUAgJ0xn4TmUBQlMTHR2dnZZDJNnDiRkAQAaJfISWgm7dIb33QDALRjkj9AAUeLjY3VuwT76NSpkxBi0aJFehdiH2lpaXqXAABoXbg/SQeKokRGRvr7++tdSPNlZmYKIdzd3YUQvXr10rucG3XmzJnMzEzeCwCAeshJOlAUJSUlJS4uTu9Cmk+bEnvllVeEECEhIXqXc6NSU1Pj4+N5LwAA6uG6G5qvHSQkAAAawH3cAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTmoDHn300c6dOyuK8t133+ldSxOkp6cHBwcrdTg7O3ft2vW+++5bsmRJUVGR3gUCAHAd5KQ2YM2aNX//+9/1rqLJoqOjT548GRIS4u7urqpqbW1tXl5eampqz549k5KSevfu/c033+hdIwAADSEnoYUoiuLh4XHfffetW7cuNTX1/PnzDz30UElJid51AQBwTeSktkFRFL1LsKeYmJjJkyfn5eW9+eabetcCAMA1kZNaKVVVlyxZcuutt7q4uLi7uz/99NN1t9bU1LzwwgsBAQGurq633XZbSkqKEGLVqlVWq9VisXzwwQcPPPCAm5ubv7//xo0bba/auVxN2DIAACAASURBVHPnnXfeabFY3NzcIiIiSktLr9VVC5g8ebIQ4pNPPmk3IwIAtEMqWpwQIiUlpeE2zz33nKIor732WlFRUXl5+cqVK4UQBw4c0LbOmTPHxcVl8+bNRUVF8+bNMxgM+/bt014lhPj8889LSkry8vIGDx5stVorKytVVb106ZKbm9vixYsrKirOnTs3ZsyY/Pz8BrpqWExMTExMTGMGa7s/qR4t0/To0aM1jEjLUo0ZDgCgQ+F3gw6um5PKy8stFsuwYcNsa7RJFC0nVVRUWCyWhIQEW2MXF5cZM2ao/00VFRUV2iYtXf3444+qqn7//fdCiI8++qjujhroqmE3npNUVdXuWGoNIyInAQCkuO7WGv3444/l5eW/+tWvpFuzs7PLy8v79OmjLbq6uvr5+WVlZV3d0tnZWQhRVVUlhAgODu7atWtiYuKCBQtOnTrV1K7srqysTFVVNze3JpXRmkcEAGh/yEmt0ZkzZ4QQPj4+0q1lZWVCiPnz59ueS3T69Ony8vKG+3R1df3iiy8GDRr04osvBgcHJyQkVFRUNK8ru/jhhx+EEGFhYaK9jAgA0P6Qk1ojs9kshLhy5Yp0q5afkpOT604M7tmz57rd9u7de+vWrbm5uUlJSSkpKUuXLm12Vzfu//7v/4QQDzzwgGgvIwIAtD/kpNaoT58+BoNh586d0q09evQwm81NfTZ3bm7u0aNHhRA+Pj4vv/xyv379jh492ryubty5c+eSk5P9/f1///vfi3YxIgBAu0ROao18fHyio6M3b968du3a0tLSQ4cOvfXWW7atZrN5ypQpGzduXLVqVWlpaU1NzZkzZ3755ZeG+8zNzZ02bVpWVlZlZeWBAwdOnz4dGRnZvK6aSlXVS5cu1dbWqqqan5+fkpJyzz33ODk5vf/++9r9SW1uRACAjsJB94ejAaIRzwW4ePHio48+2qVLl06dOg0aNOiFF14QQvj7+x88eFBV1StXriQlJQUEBBiNRi1UHTlyZOXKlRaLRQhx8803nzhx4q233tJSSGBg4A8//HDq1KmoqChPT08nJ6ebbrrpueeeq66uvlZX1x1CY77v9uGHH952220Wi8XZ2dlgMIj/PpL7zjvv/Mtf/lJQUFC3sb4j4vtuAAApRVVV/UJaB6UoSkpKSlxcnN6FNF9sbKwQIi0tTe9C7CM1NTU+Pp73AgCgHq67AQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMgpqqrqXUOHoyhKZGSkv7+/3oU0X2ZmphAiMjJS70Ls48yZM5mZmbwXAAD1kJN0EBsbq3cJ9vHNN98IIQYMGKB3IfaRlpamdwkAgNaFnITmi4uLE0KkpqbqXQgAAA7B/UkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHKKqqp614A245///Ofy5ctramq0xfz8fCGEj4+Ptujk5DRr1qzJkyfrVR4AAPZFTkITZGdnh4WFNdDg2LFjDTcAAKAN4bobmuDWW2+NiIhQFOXqTYqiREREEJIAAO0JOQlNM3HiRCcnp6vXG43GSZMmtXw9AAA4Dtfd0DS5ubn+/v5XnzaKouTk5Pj7++tSFQAAjsB8EprmpptuioqKMhj+58wxGAxRUVGEJABAO0NOQpNNmDCh3i1KiqJMnDhRr3oAAHAQrruhyQoLC319faurq21rnJyczp8/36VLFx2rAgDA7phPQpN5eXkNGzbMaDRqi05OTsOGDSMkAQDaH3ISmiMxMbG2tlb7WVXVCRMm6FsPAACOwHU3NEdZWZm3t/fly5eFEC4uLhcuXOjUqZPeRQEAYGfMJ6E5rFbryJEjTSaT0WgcNWoUIQkA0C6Rk9BM48ePr66urqmpGTdunN61AADgEMbGNz1z5kxGRobjSkHbUlNTYzabVVW9dOlSamqq3uWgteBJWgDakybcn5SamhofH+/QagC0dSkpKXFxcXpXAQD20YT5JA33fcNm+/btiqKsXLlSCJGWlqZ3OdCf9G8kA0Dbxf1JaL577713yJAhelcBAICjNHk+CbCp91feAABoZ/g9BwAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADk7JyTBg4c6OTkdPvtt9u3W82UKVPMZrOiKJcvX3ZE/y1s6dKlXbt2VRTlzTff1Nb8+9//dnd337p1q136t29vNyg9PT04OFipw2g0ent7//rXv96yZYu99tLwGVK3hgkTJtTdNHz48M6dOzs5OfXu3Xv//v32qqdJOtT5AABthZ1z0r59++6//3779mmzbt26OXPmOKjzljdnzpyMjIy6a1RVtWP/9u3tBkVHR588eTIkJMTd3V1VVVVV8/PzU1JSzp49Gx0dnZKSYpe9NHyG2Gro0qXLhg0bPv74Y9umbdu2paWlPfzww0eOHOnXr59dimmqDnU+AEBb4ZDrboqiNPUlFRUVUVFRjiimDXnooYdKSkoefvjh5r283jG8wd4czdPT81e/+tVf//pXIURqaup129vxDHn99dcNBsPUqVNLSkrs0qGDdKjzAQBaJ4fkJJPJ1NSXrF27Ni8vr5GNm5HDOoImHcNWIigoSAhRXFx83ZZ2PEOioqJmzZp19uzZ9jQ9ebW2eD4AQGvjkJz0448/hoWFWa1WV1fXwYMHf/nll7ZNu3fvDg8Pd3d3N5vNERERn376qRBi1qxZs2fPPnHihKIooaGhWsv169cPGDDAbDZbrdagoKCFCxf+/xUbDB9//PEDDzzg7u7erVu3f/zjH40padWqVVar1WKxfPDBBw888ICbm5u/v//GjRttDVRVXbZsWa9evVxcXDw9PUeNGpWVlaVtevXVVy0WS+fOnfPy8mbPnt29e/fp06dbrVaDwdC/f39fX1+TyWS1Wvv16zd48OAePXqYzWYPD4+5c+c2POp6vvzyy4CAAEVR3njjDe0YKlf5z3/+08hjWK+3hgd43YPjOIcOHRJC3HvvvbY1LXOGLFq06JZbblmzZs1nn30mLYzzQZfzAQBaHbXRtJtIrtvsV7/6VXBw8E8//VRVVfX999/fddddZrP5hx9+0LampaUtWLCgsLCwoKAgMjKyS5cu2vro6OiQkBBbJ8nJyUKIl19+uaCgoLCw8G9/+9v48eNVVX3uueeEEJ9//nlxcXFhYeGDDz7o4uJSVlbWmPptry0pKcnLyxs8eLDVaq2srNS2vvDCC87OzuvXry8uLj506FC/fv28vb3PnTtX97VPPPHEihUrxowZc+zYsT/96U9CiL1795aVlV24cGHEiBFCiI8//jg/P7+srGzmzJlCiO+++67hUR8/flwIsXr1am3x559/FkKsWLFC2/TMM89oQ/vll188PT2joqJqamoafwzr9tbIAV7r4DQsJiYmJiamMS3r3p9UXl7+ySefBAYGDh8+/NKlS7Y2jj5DQkJCfvrpJ1VVMzIyDAZDUFCQtvdPPvnkd7/7na0Z50PzzgchREpKynWbAUBb4ZCc1LdvX9uiNmEwZ86cq1u+9NJLQoi8vDz1fz/TKysrPTw87r//flvL6urq5cuXq//9+K6oqNDWv/POO0KI77//vjH113vtypUrhRA//vijqqrl5eWdOnVKSEiwNf7666+FEH/5y1+kr1VVVfu9ePHiRW3x7bffFkIcPny47ss3bdrU8Kgb+L1Y1+jRo81mc1ZWVsO9NfB7sakDrHtwrqtJOaleTI+IiHj77bevXLkibe+IM8SWk1RVnT17thDi8ccfV/83J3E+NPt8ICcBaGcc/vykiIgId3d3LS3Vo93GVFNTU2/9oUOHiouLf/Ob39jWODk5PfHEE9fqoaqqqhmFOTs721575MiRS5cuDRgwwLZ14MCBzs7Oe/fubVJv1dXV1y3sWqO+ltTU1H/9619//vOfb7311mb31tQB1j049mWbT6qqqjpz5syTTz45c+bM22677cKFC1c3dvQZsmjRoltvvXXlypV1Lw0LzoerOO58AIBWriWeM2kymWyfsB9//PF9993n4+Pj4uJS946NukpLS4UQHh4eLVCbRruPuFOnTnVXenh4XLx40S79N2bUUgUFBX/84x8HDhyozXw0uzdHD7AZjEZj9+7dp0yZsnTp0uzs7Jdffllb35JniNlsXrdunaIov//97ysqKmzrOR8AABqH56Tq6urCwsKAgAAhRE5OzujRo/38/Pbu3VtSUrJ48WLpS2666SYhhHSCwUG037j1fkkUFxf7+/vfeOeNHLXUE088UVxcvG7dOicnpxvpzaEDvEERERFCiKNHjwo9zpC77777qaeeOn78uO02cMH5AAD4L4fnpO3bt9fW1mrP7jt8+HBVVdWMGTOCg4O15yZLXxIUFOTl5bVt2zZH12bTp0+fTp06ffPNN7Y1e/furays7N+//4133shRX+3jjz9+9913n3/++d69e2trnn766eb15tAB3qBvv/1WCKFdRdLlDFm4cGFYWNiBAwdsazgfAAAah+SkysrKkpKS6urq/fv3z5w5MzAwcPLkyUIIbVbps88+u3z58vHjx+veDOHl5ZWbm3vq1KmLFy8aDIZ58+bt2rVr5syZZ8+era2tvXjxojbf4CBms3n27NlbtmzZsGFDaWnp4cOHp0+f3q1bt6lTp9545w2MugGlpaXTpk27/fbbn3nmGSHE5cuXv/nmm++++66Rx7DerSQOHWBTVVRU1NbWqqqam5u7bt26+fPne3t7P/nkk0KnM0S7+maboRGcDwAAm8bf8t3I77utW7fu/vvv79q1q9Fo7NKly9ixY0+fPm3bmpSU5OXl5eHhERsbqz3KJSQkJCcnZ//+/YGBga6uroMGDdK+nPzGG29ERESYzWaz2XzHHXesXLly8eLFrq6uQoibb775xIkTGzZs8PT0FEL4+/tf9ytvK1eutFgstte+9dZbbm5uQojAwEDtmQW1tbVLliy5+eabTSaTp6fn6NGjs7Oztdfa9tujR4/169erqrp8+XKtt6CgoN27d7/yyivu7u5CCF9f33fffXfTpk2+vr5CCE9Pz40bN15r1LNmzdKaWa3WMWPGrFixws/PTwhhsVhGjhy5dOnSq/+xHnzwwUYew/nz59ftreEBXvfgNKwx33fbsmXL1V92c3Fxufnmm2fMmJGTk9MCZ4itBm9vb+07bnU9/fTTdZ8LwPnQvPNB8H03AO2Lojb6rz6lpqbGx8c3vj06iNjYWCFEWlqa3oVAf4qipKSkxMXF6V0IANhHS3zfDQAAoC1qJzkpKyvr6r/qYJOQkKB3gQAAoO0x6l2AfYSFhXFBEAAA2Fc7mU8CAACwO3ISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMgZm/qC1NRUR9SBtuvMmTOCEwMA0B41OSfFx8c7og60dZwYAID2R1FVVe8a0FbFxcUJZpIAAO0X9ycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMgZ9S4AbcnOnTszMzNti1lZWUKIxYsX29ZERkbee++9OlQGAIADKKqq6l0D2oz//Oc/w4cPN5lMBkP9mcja2tqqqqpt27YNGzZMl9oAALA7chKaoKamxtfXt6CgQLrV09MzLy/PaGSSEgDQTnB/EprAyclp/Pjxzs7OV29ydnaeMGECIQkA0J6Qk9A0Y8eOraysvHp9ZWXl2LFjW74eAAAch+tuaLLAwMCcnJx6K/39/XNychRF0aUkAAAcgfkkNFliYqLJZKq7xtnZedKkSYQkAEA7w3wSmuzYsWPh4eH1Vh4+fLhPnz661AMAgIOQk9Ac4eHhx44dsy2GhYXVXQQAoH3guhuaY+LEibZLbyaTadKkSfrWAwCAIzCfhObIyckJCgrSTh5FUU6ePBkUFKR3UQAA2BnzSWiOgICAAQMGGAwGRVEGDhxISAIAtEvkJDTTxIkTDQaDk5PThAkT9K4FAACH4Lobmik/P79bt25CiLNnz/r6+updDgAA9kdOkuA5QHAE3mtwHD610DwxMTFpaWl6V9Gq8de45GbNmnX33XfrXUUrFR8frx2fnTt3KooyZMgQvStq7fbs2bN8+XK9q0A71wE/tbR3VkpKit6FtFXJycl6l9AGkJPk7r777ri4OL2raKXi4+O14zNixAghhJubm94VtQHkJDhax/zUWr58eQcctb0wk9QY5CQ0HwkJANC+8X03AAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJ+nj3//+t7u7+9atW1t5n3bx3nvvKYoSFRV1I510qCMGOELrPOH/8pe/hIeHu7m5ubi4hIaGzp0799KlS3bsPzMzs1evXgaDQVEUX1/fRYsW2bHzhqWnpwcHByuKoiiKn59fYmJii+0admTUu4AOSlXVNtGnXbz33nshISF79uz58ccfQ0NDm9dJhzpigCO0zhP+iy++ePzxxxMSEkwm0yeffJKYmHj48OFPPvnEXv1HRkYeO3ZsxIgRn376aXZ2toeHh716vq7o6Ojo6OjQ0NALFy6cO3euxfYL+2I+qYVUVFTUnVB56KGHSkpKHn744dbWp90VFBQcPXr0z3/+sxDinXfeafwLO+wRAxykxU74em+0hnXq1Gnq1KleXl6dO3eOi4sbPXr0//3f//38888OrdBxmjR2tAnkpBaydu3avLy81t+n3aWmpj700EMjR440m83r169v/P9oO+wRA9q6Jr3RPvroIycnJ9uit7e3EKK8vNwhlTkeHzLtDzmpmXbv3h0eHu7u7m42myMiIj799FPbpvXr1w8YMMBsNlut1qCgoIULF86aNWv27NknTpxQFCU0NPTLL78MCAhQFOWNN94QQvTq1UtRFIPB0L9/f+3TYe7cuVrP//znP6+1r4b7FEKoqrps2bJevXq5uLh4enqOGjUqKytL27Rq1Sqr1WqxWD744IMHHnjAzc3N399/48aNjjhQ77333pgxYzp37jx8+PBTp07t3r376jYcMcDR6p3wDZ/Sr7/+utls7tq167Rp07p162Y2m6Oiovbu3attnTlzprOzs5+fn7b4hz/8wWq1Kopy4cIFcdUbral1nj171tXVtWfPnvYZtkxrG7v08+rRRx/VbmwKCQk5cOCAEGLKlCkWi8Xd3f3DDz8UQtTU1LzwwgsBAQGurq633XZbSkqKEOLVV1+1WCydO3fOy8ubPXt29+7ds7Oz7XnsOiYVVxFCpKSkNNwmLS1twYIFhYWFBQUFkZGRXbp00dYnJycLIV5++eWCgoLCwsK//e1v48ePV1U1Ojo6JCTE9nJtVnnFihWqqlZXVwcFBQUEBFRXV9saPPnkk8nJyQ3vq4E+VVV94YUXnJ2d169fX1xcfOjQoX79+nl7e587d07b+txzzwkhPv/885KSkry8vMGDB1ut1srKSnsdH83p06d9fHy0ca1fv14I8cgjj9Rr0xGOmPYR1piWQPM05l1Z74Rv+JSeOnWq1Wo9evTo5cuXjxw5MnDgwM6dO+fk5Ghbx48f7+vra+t5yZIlQoj8/Hxtsd4brfHKyso6d+48c+bMRrZv/DvrN7/5jRCiqKhIW2zJsYeEhLi7uzdQWwOfV05OTmfPnrW1HDdu3Icffqj9PGfOHBcXl82bNxcVFc2bN89gMOzbt882tCeeeGLFihVjxow5duxYA7uOiYmJiYm5zrHr8JhPaqaYmJg//elPnp6eXl5eI0eOLCgoyM/Pr6qq+vOf/3z//fc/88wzXl5enp6ejzzyyMCBAxvuysnJ6YknnsjJydmyZYu2pry8PD09/fe//30D+2q4z4qKimXLlo0ZMyYxMdHd3T0iIuLNN9+8cOHCW2+9VbdZVFSUm5ubj49PQkJCWVlZTk5Oc4+H3Hvvvffb3/5Wm1QfOXKki4tLWlpaRUWFrQFHDNBXA6e00WjUplfDw8NXrVp18eLFdevWObSYl156qVu3bi32lbRWMvZrfV5Nnz69pqbGtt/S0tJ9+/Y9+OCDQojLly+vWrVq9OjR0dHRHh4e8+fPN5lMdSt85ZVXHn/88fT09LCwMAeV3XGQk+zAZDIJIWpqag4dOlRcXKz9x0Wj/Ua/bg+PPvqou7v78uXLtcUNGzaMGjXKzc2tgX013OGRI0cuXbo0YMAA25qBAwc6OzvbZo/rcXZ2FkJUVVVdt9Qm0S66aT+7ubkNHz68tLT0gw8+sDXgiAGtRMOn9IABAywWi+1KtCNs2bIlNTX1008/7dy5s+P2IqX72G3qfl4NHTr0lltu+cc//qGqqhBi06ZNCQkJ2n87s7Ozy8vL+/Tpo73K1dXVz8+vZSrsgMhJzfTxxx/fd999Pj4+Li4uc+fO1VaWlpYKIZrxvdNOnTr9v//3/zIyMr7++mshxOrVq2fOnNnwvhpWXFysdVt3pYeHx8WLF5taW7N9//33hw8ffvjhh5X/0h7cUvdbbxwxoK1wcXG57rxss23atOmVV17ZsWNHUFCQg3ZxIxw69mt9XimKMm3atJMnT37++edCiHfeeeeRRx7RNpWVlQkh5s+fb/t0PX36dNu9+b2VIyc1R05OzujRo/38/Pbu3VtSUrJ48WJt/U033SSE0G7oa6qZM2eaTKbk5ORdu3b16NEjJCSk4X01TEse9X7HFxcX+/v7N6O25nn33XfHjh1b9ypvYWGhq6vrtm3bbI8S4YgBbUJVVZXj3g4rVqzYsGHDF198oX0gtDaOGPuuXbu0WzMb/ryaPHmy2Wxes2ZNdna2m5tbYGCgtt7Hx0cIYbsjU7Nnzx47VggbclJzHD58uKqqasaMGcHBwWazWVEUbX1QUJCXl9e2bdua0ae/v39cXNzmzZuff/75WbNmXXdfDevTp0+nTp2++eYb25q9e/dWVlb279+/GbU1g6qqmzZt+sMf/lB3paenZ2xsbE1NzXvvvaet4YgBbcKOHTtUVY2MjNQWjUajXS46q6qalJR0+PDh999/v95sbuvhiLF/++23VqtVXO/zytPTMz4+/v3331+6dOljjz1mW9+jRw+z2fzdd9/dYBloDHJScwQEBAghPvvss8uXLx8/ftx2C4uLi8u8efN27do1c+bMs2fP1tbWXrx48ejRo0IILy+v3NzcU6dOXbx48VrvsdmzZ1dXVxcVFQ0dOvS6+2q4T7PZPHv27C1btmzYsKG0tPTw4cPTp0/v1q3b1KlT7X0w5DIyMtzc3O65555666dPny7qXHrjiAGtVm1tbVFRUXV19aFDh2bNmhUQEDB58mRtU2hoaGFh4fvvv19VVZWfn3/69Om6L2zMm1dz9OjRV1999e9//7vJZFLqWLp0qePG1RiOG3tVVdX58+d37Nih5aQGPq8006dPv3LlykcffVT3AaFms3nKlCkbN25ctWpVaWlpTU3NmTNnfvnlF7seA/xXi32zrg0RjfiGbVJSkpeXl4eHR2xsrPY8kpCQEO2Lo2+88UZERITZbDabzXfcccfKlStVVd2/f39gYKCrq+ugQYPmz5+vPX7DYrGMHDmybrf333//mjVrGrmvhvusra1dsmTJzTffbDKZPD09R48enZ2drXW4cuVKi8UihLj55ptPnDjx1ltvaXdABwYG/vDDDzd+fB555BGr1Wo0Gvv27bt//37b+oULF3br1k078bp3764dmY5wxHguABztuu/KFStW1D3hr3tKT5061WQyde/e3Wg0urm5jRo16sSJE7beCgoK7r//frPZ3LNnzz/+8Y9PP/20ECI0NFT7DKz7RrM9WUPq8OHD0l9MS5YsacyoG/POyszM7N27t8FgEEL4+fm9+OKLLTb21atX2+4HuNqWLVu0Dhv4baK54447nn322XrjunLlSlJSUkBAgNFo9PHxiY6OPnLkyOLFi11dXYUQPXr00J7r2zCeC9AYitoq/+KPvhRFSUlJiYuL07uQVorj01Spqanx8fG81+A4dn9XTps2LS0traCgwF4dOoKD3lmtbewPPfTQG2+84Yhnb8bGxgoh0tLS7N5ze8J1NwCAxHWfptGO6T522zW7Q4cOaXNX+tbTkZGTAAAOkZWVpVxbQkKC3gW2XklJScePH//hhx+mTJmycOFCvcvp0MhJAID/MW/evHXr1pWUlPTs2XPz5s3N7icsLKyB2z42bdpkx5rtxV5jv0EWiyUsLOzXv/71ggULwsPD9SoDgpwEAKjnpZdeunLliqqqP/30U0xMjN7ltKhWMvZFixbV1NTk5OTU/ZobdEFOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkCZqMWgAAIABJREFUAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5RVVVvWtodRRF0bsEtEO81+A4fGqheWJiYtLS0vSuolUz6l1Aa5SSkqJ3CW1DcnKyEOLJJ5/UuxCgo+NT61r27NmzfPlyjs+19OjRQ+8SWjvmk9B8cXFxQojU1FS9CwEAudTU1Pj4eH7Todm4PwkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgBw5CQAAQI6cBAAAIEdOAgAAkCMnAQAAyJGTAAAA5MhJAAAAcuQkAAAAOXISAACAHDkJAABAjpwEAAAgR04CAACQIycBAADIkZMAAADkyEkAAABy5CQAAAA5chIAAIAcOQkAAECOnAQAACBHTgIAAJAjJwEAAMiRkwAAAOTISQAAAHLkJAAAADlyEgAAgJxR7wLQlly4cKG0tNS2WFZWJoQ4efKkbY2bm5u3t7cOlQGAEEKIioqKX375xbZ4/vx58b8fU05OToGBgTpUhrZJUVVV7xrQZqxdu/bRRx9toMGaNWseeeSRFqsHAOopKCjw8/Orrq6+VoMRI0Z88sknLVkS2jSuu6EJxowZYzKZrrXVZDKNGTOmJesBgHq6dOkybNgwg0H+201RlISEhBYuCW0aOQlN4OnpOeL/Y+++A6Oo8/+PfyZbsukJIdQ0CCXSg9QAHqigiPQAETiFEw9BDykinghfBcshnmDB8yjHKSgmBE6NonI2DiUJcvRqwKPEAKGlkUCS3fn9sb/bi8kQNiG7ny3Px1/ZmdnPvGfymc++MjM7ufdevV7jcq1erx88eHBYWJjzqwKAyiZOnHijSyV6vX7EiBFOrgdujZyE2pk4caLZbK4+3Ww2T5w40fn1AEAVw4cP9/X1rT5dr9cPGzYsJCTE+SXBfZGTUDvDhg3z8/OrPt1kMg0ZMsT59QBAFQEBAcOHD69+k4DZbJ4wYYKUkuC+yEmoHZPJNHLkyCoDkMFgGD16tL+/v6yqAKCyCRMmlJeXV5no5+c3ePBgKfXAfZGTUGvjx4+vMgCVl5ePHz9eVj0AUMW9994bHBxceYrBYBg3bpzJZJJVEtwUOQm1NmjQoCr3a4eGht59992y6gGAKgwGw9ixYyuf+ebPOdQNOQm1ptfrk5OTjUaj9aXBYBg/fnwNzwsAAOercuY7PDx8wIABEuuBmyInoS4eeOCBsrIy68/l5eUPPPCA3HoAoIrf/OY3jRo1sv5sNBonTpyo0+nklgR3RE5CXfTt27dZs2bWn5s0adKnTx+59QBAFT4+PhMnTrSe+S4rK+PPOdQNOQl1oSiKdQAyGAwPPvigoiiyKwKAqmxnviMjI3v06CG7HLglchLqyDoAcWskAJfVrVu3Fi1aCCEmTZrEn3OoG41/QIFbN2bMGNklOENgYKAQ4oUXXpBdiDNs3LhRdglAfXrttdcyMjJkV+Fw1ufi7ty50xuG5dmzZ/fu3Vt2FZ6G80kOkZaWlpOTI7sKh4uJiYmJiak+PTMzMzMz0/n1OEhOTk5aWprsKoB6lpGR4UnH6Y1ERUWFhIRUeZaS8MTjOi0t7cyZM7Kr8ECcT3KUWbNmjR07VnYVjnXixAkhRFxcXJXp1r/bPOYETGpq6rhx42RXAdS/Xr16ecxxWoMvv/zynnvuqTLRelx70uZzYdFByEmou+oJCQBcTfWQBNiP624AAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkAAADayEkuYcqUKUFBQYqi7N27V3Ytv2KxWJYtW5aYmFjvLW/atKlly5ZKJUajsVGjRv3791+6dOmVK1fqfY0AbpHLjlRW165di4+Pf/bZZ+urQYYpCHKSi1i9evWqVatkV1FVdnb2HXfcMXv27JKSknpvfPTo0T///HNcXFxISIiqqhaLJS8vLzU1tUWLFvPmzWvfvv2uXbvqfaUAboVrjlQ28+fPP3bsWD02yDAFQU7Cjezbt+/pp5+eNm1aly5dnLA6RVFCQ0P79++/du3a1NTU8+fPDxkypKCgwAmrBuABduzYcfDgQYeugmHKO5GTXIWiKLJL+JXOnTtv2rRpwoQJvr6+Tl51UlLSpEmT8vLy3nnnHSevGkDNXG2ksiotLZ07d+7y5cudtkaGKe9BTpJGVdWlS5e2bdvW19c3JCRk7ty5leeazeaFCxdGR0f7+fl16tQpJSVFCPH2228HBAT4+/t//PHHgwcPDg4OjoyM3LBhg+1d27Zt69Gjh7+/f3BwcMeOHQsLC2/UlIubNGmSEOLzzz+3vvTyvQFI5BYj1fz58x977LGIiIh62mi7MEx5CxUOIIRISUmpeZn58+crivLnP//5ypUrJSUlK1asEELs2bPHOvfJJ5/09fVNS0u7cuXKM8884+Pj8+OPP1rfJYT4+uuvCwoK8vLy+vXrFxAQUFZWpqpqcXFxcHDwkiVLSktLz507N2rUqAsXLtTQlJ169uzZuXPnWm1+UlJSUlKSPUvaLvxXYR0soqKirC/l7g3rIFWrPQC4PjuPU9cfqb7//vthw4apqnrhwgUhxPz58+15l/3HtVsMU6p9nzuoA0Z/h7hpfy0pKfH39x84cKBtivUvDOvoU1pa6u/vn5ycbFvY19d3+vTp6n8PudLSUuss65h1/PhxVVWt1+Y//fTTyiuqoSk7SclJqqpabwVQXWBvkJPgkew5Tl1/pCopKenWrVtOTo7q9JykutIwpZKTHIbrbnIcP368pKTkrrvu0px77NixkpKSDh06WF/6+fk1adLk6NGj1Zc0Go1CiPLyciFEy5YtGzVqNHHixOeee+7kyZO1bcqlXL16VVXV4OBgwd4A5HH9keqZZ575/e9/37x581pv2y1jmPIS5CQ5cnJyhBA3upp+9epVIcSzzz5re2jHqVOnbvrlfD8/v2+++aZv374vvvhiy5Ytk5OTS0tL69aUdD/99JMQIj4+XrA3AHlcfKT6/vvvDxw4MGXKlLps2y1jmPIS5CQ5TCaTEOL69euac62j0rJlyyqf+svIyLhps+3bt09PT8/NzZ03b15KSsqrr75a56bk+uKLL4QQgwcPFuwNQB4XH6nWrFnz9ddf+/j4WPOEtZEXX3xRURQnPNmIYcpLkJPk6NChg4+Pz7Zt2zTnRkVFmUym2j7xNjc39/Dhw0KIiIiIl19+uWvXrocPH65bU3KdO3du2bJlkZGRv/vd74TX7w1AIhcfqdauXVs5TFS+P6lbt261aqq2GKa8BzlJjoiIiNGjR6elpa1Zs6awsHD//v0rV660zTWZTJMnT96wYcPbb79dWFhoNptzcnLOnj1bc5u5ubmPPvro0aNHy8rK9uzZc+rUqV69etWtKWdSVbW4uNhisViHuZSUlD59+uh0uo8++sh64d+r9gbgUhiprBimvNrNbvRGXQg7vndQVFQ0ZcqU8PDwwMDAvn37Lly4UAgRGRm5b98+VVWvX78+b9686OhovV5vHaoOHTq0YsUKf39/IUTr1q1PnDixcuVK6yEaExPz008/nTx5MjExMSwsTKfTNWvWbP78+RUVFTdq6qabkJGR0adPn6ZNm1r7SZMmTRITE7dt22bP5tvzPZpPPvmkU6dO/v7+RqPRx8dH/PdZtz169Fi0aNGlS5cqLyx3b/B9N3gkO7+X6uIjVWX1/n03NxqmVL7v5jCKqqpOzWXeQVGUlJSUsWPHyi5EjjFjxgghNm7cKLuQ+pGamjpu3DiOFHgYDztOa8vzjmsv/9xxHK67AQAAaCMneaOjR48qN5acnCy7QABgpIJL0MsuABLEx8d70tlmAB6JkQqugPNJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2shJAAAA2vSyC/BYy5Yt27hxo+wq5MjMzBRCjBkzRnYh9SMnJ0d2CYBDZGZmesxxWlvW49prNx/2U1RVlV2DB/KSY2/Xrl1CiG7duskuxBm8NvXCU7322msZGRmyq3C43NzcXbt2DRs2THYhzjB79uzevXvLrsLTkJNQd2PHjhVCpKamyi4EALSlpqaOGzeOTzrUGfcnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaFNUVZVdA9zG3//+9+XLl5vNZuvLCxcuCCEiIiKsL3U63cyZMydNmiSrPAD45Zdfhg4dWl5ebn159erVCxcuxMbG2hbo0qXLunXr5BQHN6SXXQDcSe/evSdPnlxl4vnz520/9+rVy7kVAcCvNG/e/Nq1a0eOHKk88eDBg7afx40b5/Si4Ma47oZaaNu2bceOHRVFqT5LUZSOHTvGx8c7vyoAqOzBBx/U6294FoCchFohJ6F2HnzwQZ1OV326Xq9/6KGHnF8PAFQxfvx42+0BlSmK0rVr19atWzu/JLgvchJq50YDUEVFBX+lAXAF0dHR3bt39/Gp+gGn0+kefPBBKSXBfZGTUDvNmjVLTEysMgD5+PgkJiZGRkbKqgoAKnvwwQer3yFgNpvHjBkjpR64L3ISau23v/1tlQFIURT+SgPgOsaOHVtlik6n+81vftOsWTMp9cB9kZNQa2PGjKn+h9ro0aOlFAMA1UVERPTv37/KzZS//e1vZdUD90VOQq01aNBg4MCBtq+T6HS6gQMHhoeHy60KACr77W9/W/kBgT4+PqNGjZJYD9wUOQl1MXHiRIvFYv1ZVVX+SgPgakaNGmX7c06v1w8ePDg0NFRuSXBH5CTUxfDhw41Go/Vng8EwbNgwufUAQBVBQUH333+/wWAQQpjN5okTJ8quCG6JnIS6CAgIGDZsmMFg0Ov1I0aMCAwMlF0RAFQ1YcKEiooKIYTJZLr//vtllwO3RE5CHVkHILPZPH78eNm1AICG++67z9/fXwgxevRoPz8/2eXALf3qye45OTk7duyQVQrci9lsNplMqqoWFxenpqbKLgfuoV6es0V/g/26d+/+3XffRUVF0W1gp6ioqN69e//vtVpJSkqKvMIAeL6UlBT1lsneCACeLCkpqfKAo/GfAhmGYKdvv/1WUZT+/fvXsIz16bcbN250Uk1wYZr/QbluUlJSqj9IEKjObDa/9NJLCxYsqGGZ1NTUcePG8dkH8d/PrMpu+B+VgZv6zW9+I7sEAKiJTqf74x//KLsKuDFyEuqu+r+ZBABXY3uKElAHfM4BAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoq3VO6t69u06n69KliyOqmTx5sslkUhTl2rVrjmjfyV599dVGjRopivLOO+9Yp2zZsiUkJCQ9Pb1e2q/f1m7KYrEsW7YsMTGx3lvetGlTy5YtlUr0en3Dhg3vvvvuzZs319daau5dlWv47W9/W3nWoEGDgoKCdDpd+/btd+/eXV/11IqH9SVHY5iyn8d0rSVLlsTHx/v5+QUEBMTHxy9YsKCwsLAe22eYuimP6UtV1Don/fjjjwMGDHBEKUKItWvXPvnkkw5q3PmefPLJHTt2VJ6iqmo9tl+/rdUsOzv7jjvumD17dklJSb03Pnr06J9//jkuLi4kJERVVVVVL1y4kJKS8ssvv4wePTolJaVe1lJz77LVEB4evn79+s8++8w2a+vWrRs3bhw6dOihQ4e6du1aL8XUlif1JSdgmLKfx3St7du3P/LII6dPnz5//vzixYuXLFmSlJRUj+0zTN2Ux/SlKup43U1RlNq+pbS01BGnItzLkCFDCgoKhg4dWre3V9mHt9ia/fbt2/f0009PmzbNQX+gVxcWFnbXXXe9/vrrQojU1NSbLl+PveuNN97w8fGZOnVqQUFBvTToIG7al5yJYapu3LRrGY3Gxx57LCIiIjAwcMyYMSNGjPjnP/959uxZx62RYeqm3LQvVVHHnGQwGGr7ljVr1uTl5dm5cB0GOG9Qq31Yjzp37rxp06YJEyb4+vo6c72xsbFCiPz8/JsuWY+9KzExcebMmb/88osnnTOoTlZfciaGKSlkda3NmzebTCbby+bNmwshiouLHb1ehinHcZFhqo456fjx4/Hx8QEBAX5+fv369fv+++9ts7Zv396uXbuQkBCTydSxY8cvv/xSCDFz5sw5c+acOHFCUZRWrVpZl1y3bl23bt1MJlNAQEBsbOzixYv/f00+Pp999tngwYNDQkKaNm36t7/9zZ6S3n777YCAAH9//48//njw4MHBwcGRkZEbNmywLaCq6muvvXbbbbf5+vqGhYWNGDHi6NGj1lmvvPKKv79/UFBQXl7enDlzmjdvPm3atICAAB8fn9tvv71x48YGgyEgIKBr1679+vWLiooymUyhoaFPPfVUzVtdxffffx8dHa0oyltvvWXdh0o1//znP+3ch1Vaq3kDb7pzXNP+/fuFEL/5zW9sU5zTu1544YU2bdqsXr36q6++0iyMvuQWfYlhypu7VnZ2dmhoaExMTN3ebj+GKY/vS0KtxHqFVb2Zu+66q2XLlv/5z3/Ky8sPHjzYs2dPk8n0008/Wedu3Ljxueeeu3z58qVLl3r16hUeHm6dPnr06Li4OFsjy5YtE0K8/PLLly5dunz58l//+tcJEyaoqjp//nwhxNdff52fn3/58uX77rvP19f36tWrN62q8nsLCgry8vL69esXEBBQVlZmnbtw4UKj0bhu3br8/Pz9+/d37dq1YcOG586dq/zeJ5544s033xw1atSRI0f+7//+TwiRlZV19erVixcv3nvvvUKIzz777MKFC1evXp0xY4YQYu/evTVvdXZ2thDiL3/5i/XlmTNnhBBvvvmmddbTTz9t3bSzZ8+GhYUlJiaazWb792Hl1uzcwBvtHDv17Nmzc+fOtXpLUlJSUlKSPUtWvvBfUlLy+eefx8TEDBo0qLi42LaMo3tXXFzcf/7zH1VVd+zY4ePjExsba137559/Pnz4cNti9KW69SUhREpKyk0Xq5d2GKa8qmvZlJWV5eTkvPnmm76+vuvWrbPzXXZ+9qkMU17Ql6p/ZtUxJ1X+sLSm6SeffLL6ki+99JIQIi8vr8oGl5WVhYaGDhgwwLZkRUXF8uXLbdtWWlpqnf7ee+8JIQ4ePHjTqqq/d8WKFdYMq6pqSUlJYGBgcnKybeGdO3cKIRYtWqT5XlVVrZ2mqKjI+vLdd98VQhw4cKDy2z/88MOat7qGTlPZyJEjTSbT0aNHa26thk5T2w2svHPs5+icVCXEd+zY8d13371+/brm8o7oXbYBSFXVOXPmCCEef/xx9dcDEH2pzn3JyTmJYcp7upZN48aNhRDh4eGvv/66/QGrVjmJYaqGbfSAvlT9M6senp/UsWPHkJAQ6zBUhfX+ALPZXGX6/v378/Pz77nnHtsUnU73xBNP3KiF8vLyOhRmNBpt7z106FBxcXG3bt1sc7t37240GrOysmrVWkVFxU0Lu9FW30hqauo//vGP559/vm3btnVurbYbWHnnuA7bH2rl5eU5OTmzZs2aMWNGp06dLl68WH1hR/euF154oW3btitWrKh8vUbQl6pxzb5UBcOUZs2e17XOnDmTl5f3wQcfvPvuuwkJCY64u4VhSrNCz+tLNvXznEmDwWBb/Weffda/f/+IiAhfX9/KlzMrsz7WIjQ0tF7Wbg/rTXaBgYGVJ4aGhhYVFdVL+/ZstaZLly794Q9/6N69u/XPgjq35ugNdDK9Xt+8efPJkye/+uqrx44de/nll63Tndm7TCbT2rVrFUX53e9+V1paaptOX3JTDFPe0LUMBkNERMSgQYM+/PDDQ4cOWU9OOAjDlGf3JZt6yEkVFRWXL1+Ojo4WQpw+fXrkyJFNmjTJysoqKChYsmSJ5luaNWsmhNBM3w5i7Y5V9mB+fn5kZOStN27nVmt64okn8vPz165dq9PpbqU1h26gRB07dhRCHD58WMjoXb179549e3Z2drbt/kpBX3JPDFPe1rVatWql0+kOHTpU7y1XxzBl/3vdsS/VQ0769ttvLRaL9cFWBw4cKC8vnz59esuWLa0PFdV8S2xsbIMGDbZu3Xrra7dThw4dAgMDd+3aZZuSlZVVVlZ2++2333rjdm51dZ999tn777+/YMGC9u3bW6fMnTu3bq05dAMl+ve//y2EsJ6eldK7Fi9eHB8fv2fPHtsU+pI7Ypjy7K516dKl8ePHV56SnZ1tNpujoqJusWV7MEzZ+Ua36EvV1TEnlZWVFRQUVFRU7N69e8aMGTExMZMmTRJCWP9c++qrr65du5adnV35SmGDBg1yc3NPnjxZVFTk4+PzzDPP/Otf/5oxY8Yvv/xisViKioqsYdxBTCbTnDlzNm/evH79+sLCwgMHDkybNq1p06ZTp0699cZr2OoaFBYWPvroo126dHn66aeFENeuXdu1a9fevXvt3IdVrrM6dAOdqbS01GKxqKqam5u7du3aZ599tmHDhrNmzRKSepf1tLbtTx9BX3IfDFOVeXbXCggI2Lp16zfffFNYWFheXr5nz56HHnooICBg9uzZt9iyJoYp4bl9SUPlm7rtvOd/7dq1AwYMaNSokV6vDw8Pf+CBB06dOmWbO2/evAYNGoSGho4ZM8b6nIO4uLjTp0/v3r07JibGz8+vb9++1m/uvfXWWx07djSZTCaTKSEhYcWKFUuWLPHz8xNCtG7d+sSJE+vXrw8LCxNCREZG3vS7JCtWrPD397e9d+XKlcHBwUKImJgY65eBLRbL0qVLW7dubTAYwsLCRo4ceezYMet7beuNioqyfpV0+fLl1tZiY2O3b9/+pz/9KSQkRAjRuHHj999//8MPP7R+qyIsLGzDhg032uqZM2daFwsICBg1atSbb77ZpEkTIYS/v/+wYcNeffXV6r+O++67z859+Oyzz1ZureYNvOnOqVlGRkafPn2aNm1qLbJJkyaJiYnbtm276RtV+77vtnnz5urfIvH19W3duvX06dNPnz5tW9JxvctWQ8OGDa1fHqls7ty5lb9wS1+qW18STvy+G8OUV3UtVVWHDRvWokWLwMBAX1/fuLi45ORk23e1bsqezz6GKS/pS9U/sxS10j9MSU1NHTdunOpZ/+kJco0ZM0YIsXHjRtmFQD5FUVJSUsaOHesi7QBWfPbBpvpnVv183w0AAMDzuE1OOnr0aPVHntskJyfLLtBdsWOB+sLR5CDsWEikl12AveLj4zkp6gjsWKC+cDQ5CDsWErnN+SQAAAAnIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABo01eflJqa6vw64KlycnIEnQr1LSMjQ3YJ8BzW7sQwBSFETk5OZGTkryaplaSkpEgqDIBXSElJUW+Z7I0A4MmSkpIqDzgKgw6cr7S0tG/fvmazeceOHf7+/rLLAeDG1qxZM3369JycnIiICNm1wAORkyDHqVOnunXrNmjQoPfff192LQDcWK9evVq0aLFhwwbZhcAzcR835IiJidmwYUNKSsry5ctl1wLAXR04cCArK+uRRx6RXQg8FjkJ0tx9992LFy+eO3fud999J7sWAG5p5cqVcXFxAwYMkF0IPBbX3SCTqqrJyclff/31rl27YmNjZZcDwJ2UlpY2b9786aeffuqpp2TXAo9FToJkxcXFvXr1MhqNP/zwg5+fn+xyALiNd99995FHHjl16lTTpk1l1wKPRU6CfNnZ2T169Bg6dOh7770nuxYAbqNv377NmjXjuUdwKO5PgnytW7det27d+++//5e//EV2LQDcw5EjR3bs2MEd3HA0chJcwv33379gwYInnnhi+/btsmsB4Ab++te/xsbG3nXXXbILgYfjuhtchaqqSUlJO3bs2LVrV/PmzWWXA8B1Xb9+PTIyctasWc8884zsWuDhyElwIUVFRT179gwNDf322299fX1llwPARa1fv37y5MmnTp1q1qyZ7Frg4bjuBhcSFBT0j3/849ChQ7NmzZJdCwDXtWrVqqFDhxKS4ATkJLiWtm3bvvfee++8886aNWtk1wLAFR07dmz79u3cwQ3nICfB5QwfPnzevHmPP/74zp07ZdcCwOWsWrUqMjJy0KBBsguBV+D+JLgii8Vy//33Hzx4cNeuXY0aNZJdDgBXUVZWFhkZ+Yc//GHBggWya4FX4HwSXJGPj8/7779vNBpHjRpVVlYmuxwArmLz5s2XL19+6KGHZBcCb0FOgosKCwvbvHnz3r17582bJ7sWAK5i1apVQ4YMiY6Oll0IvAU5Ca6rU6dOq1atWr58+d///nfZtQCQ7+eff/7222+5gxvOpJddAFCTBx544Mcff5w2bVrHjh1vv/122eUAkGnlypXNmzcfPHiw7ELgRbiPG67ObDbfd999x44d27VrV8OGDWWXA0CO8vLymJiY3//+988995zsWuBFuO4GV6fT6T744AMfH5/k5GSz2Sy7HAByfPzxx+fPn588ebLsQuBdyElwA+Hh4Zs3b87IyJg/f77sWgDIsWrVqnvvvTcmJkZ2IfAu5CS4hy5duvz1r395li7iAAAgAElEQVR95ZVXUlNTZdcCwNn+85//fPXVV9zBDefjPm64jYkTJ2ZkZDz88MPt2rXr0KGD7HIAOM/q1asbNWo0ZMgQ2YXA63AfN9xJeXn53Xffffbs2Z07d4aGhsouB4AzVFRUxMTETJ48+YUXXpBdC7wO193gTgwGQ2pqaklJybhx47inG/AS6enpZ8+e5Q5uSEFOgptp3LhxWlratm3bFi1aJLsWAM6watWqgQMHxsXFyS4E3oicBPfTq1ev119/ffHixZs2bZJdCwDHOnPmzNatW7mDG7JwHzfc0tSpU3ft2jV58uTbbrutXbt2sssB4CirV69u2LDh8OHDZRcCL8V93HBX5eXlAwYMuHjxYlZWVkhIiOxyANQ/s9ncsmXLBx544E9/+pPsWuCluO4Gd2UwGDZu3FhYWPjQQw8R9wGPtGXLljNnzjz88MOyC4H3IifBjTVt2jQtLe3zzz9/+eWXZdcCoP6tWrXqzjvvbN26texC4L3ISXBviYmJS5cuXbBgwZYtW2TXAqA+5eTkbNmyhTu4IRc5CW5vxowZDz300MSJE48fPy67FgB198knnxQUFNhe/u1vfwsNDR0xYoTEkgByEjzB22+/HRcXN2rUqKtXr9omXrt27bHHHispKZFYGAD7zZ07t3HjxpMmTdqxY4fFYvnb3/42efJkX19f2XXBq/F9N3iI06dPd+vWrV+/fmlpaYqinD59eujQofv3709JSRk7dqzs6gDcXNOmTc+dO2cwGMrLy2NjYy9cuPDtt992795ddl3wapxPgoeIjo7esGHDJ5988tprr3377bddunQ5cuSITqd7//33ZZcGwC6lpaVCiPLyciHEqVOnrl271qdPn6SkpK+++oo/6SEL55PgUZYuXfraa69duHBBCGH9B3AGgyEvL49/mgu4PpPJdP369SoTraeXWrdu/c4779x5551SCoM343wSPMe1a9cOHjx4/vx5s9ls+y+5Fovlo48+klsYgJuyWCxlZWXVp5eXl+v1epPJ1KNHD+dXBZCT4CHOnDnTq1evDz74oPop0nXr1kkpCYD9SktLNa9v6PX6Bg0abNmyJTAw0PlVAeQkeIKtW7d26NDh8OHDFRUVVWaZzeZt27adP39eSmEA7FT5y6o2Pj4+RqNx69atkZGRzi8JEOQkeIaCggKj0XijuYqibNy40Zn1AKgtzUd4KIry0Ucfde7c2fn1AFbkJHiCMWPGZGdnP/roo4qi6PX6KnPNZvN7770npTAAdtI8n/TWW28NHDjQ+cUANuQkeIjQ0NA33nhj+/btLVu21Ol0lWepqrpr166TJ09KKg3AzVXJST4+PgsWLHj00Udl1QNYkZPgUfr06XPw4MEXX3zRaDQaDAbbdL1en5KSIrEwADWrfN1Nr9ePHj36+eefl1gPYEVOgqcxGAzz5s07dOhQnz59FEVRFEUIUV5e/u6778ouDcAN2c4nGQyG7t27r1u3znrwAnKRk+CZWrVq9c0336xatSowMNB6YunIkSNHjhyRXRcAbdbzSXq9Pjo6+rPPPuPfusFFkJPgsRRFefjhh7Ozs23/323Dhg1ySwJwI9bzSYGBgV988UVYWJjscoD/UuG5kpKSZPcv4FdSUlJkHxZ1wc1tcDVJSUmyDwtvUfUb1PAwvXr1mjVrluwqXEJZWdnHH3/co0ePmJiYW29t2bJlQgj2ba2MGzdOdgm3hLTkCBkZGcuXL09JSfn0008bNWrEPyexh3X8gXOQkzxcZGSk7aoTJk6caLFYfHzq4XKz9cGV7NtacfecxK/bQZYvXz527Ni77rorPDxcdi3ugQfnOhP3J8G71EtIAlDvCElwTXxmAAAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMnAQAAaCMn4VZt2bIlJCQkPT3dxdusgcViWbZsWWJiokPX8sEHHyiKcotr8YC9jRtx61/ukiVL4uPj/fz8AgIC4uPjFyxYUFhY6KB1cSjBmchJuFWqqrpFmzeSnZ19xx13zJ49u6SkxKEr+uCDD+Li4jIyMo4fP17nRtx9b6MGbv3L3b59+yOPPHL69Onz588vXrx4yZIlSUlJDloXhxKcSoXnSkpKSkpKqvdmS0pKevfu7fpt2mPv3r2jRo1av359ly5dOnfubP8ba7tvL1682KJFi/Xr1wshFixYYP8bPWlvCyFSUlKcv95bl5KS4ojR0pN+uSNHjiwtLbW9HDNmjBAiNzf3pm+s7b7lUFIdNrZDE+eTUGtr1qzJy8tz/Tbt0blz502bNk2YMMHX19ehK0pNTR0yZMiwYcNMJtO6detUu//u9KS9jSo86Ze7efNmk8lke9m8eXMhRHFxcb2viEMJTkZOgti+fXu7du1CQkJMJlPHjh2//PJL26x169Z169bNZDIFBATExsYuXrx45syZc+bMOXHihKIorVq1+v7776OjoxVFeeutt4QQt912m6IoPj4+t99+u/Uy1lNPPWVt+e9///uN1lVzm0IIVVVfe+212267zdfXNywsbMSIEUePHrXOevvttwMCAvz9/T/++OPBgwcHBwdHRkZu2LDBubvw5j744INRo0YFBQUNGjTo5MmT27dvr74Me9vdcSjZZGdnh4aGxsTE1H1v3gCHEpxN5sksOJid52Y3btz43HPPXb58+dKlS7169QoPD7dOX7ZsmRDi5ZdfvnTp0uXLl//6179OmDBBVdXRo0fHxcXZ3n7mzBkhxJtvvqmqakVFRWxsbHR0dEVFhW2BWbNmLVu2rOZ11dCmqqoLFy40Go3r1q3Lz8/fv39/165dGzZseO7cOevc+fPnCyG+/vrrgoKCvLy8fv36BQQElJWV1Wpf9ezZ03HX3U6dOhUREWHdJ+vWrRNCPPzww1WW8Ya9LTz9uhuHUllZWU5Ozptvvunr62s92XNTtbruxqFkxXU3ZyInebI6HEsvvfSSECIvL6+srCw0NHTAgAG2WRUVFcuXL1dvNjRYB6nU1FTry6tXr0ZHRxcUFNSwrprbLCkpCQwMTE5Ots3duXOnEGLRokXWl9bhxnZvxIoVK4QQx48fr9WGOzQnvfzyy5MnT7b+XFBQ4OvrGxwcXFJSYlvAS/a2x+ekyrzzUGrcuLEQIjw8/PXXX7fzI79W+5ZDyYqc5Excd8OvGAwGIYTZbN6/f39+fv4999xjm6XT6Z544ombtjBlypSQkJDly5dbX65fv37EiBHBwcE1rKvmBg8dOlRcXNytWzfblO7duxuNxqysLM3ljUajEKK8vPympTqN9UqB9efg4OBBgwYVFhZ+/PHHtgXY257HOw+lM2fO5OXlffDBB++++25CQkK937vDoQTnIydBfPbZZ/3794+IiPD19X3qqaesE63PPgkNDa1ta4GBgb///e937Nhh/ePpL3/5y4wZM2peV83y8/OtzVaeGBoaWlRUVNvapDh48OCBAweGDh2q/Jf18SrvvfeebRn2tmfgUDIYDBEREYMGDfrwww8PHTpkPfVSXziUIAU5ydudPn165MiRTZo0ycrKKigoWLJkiXV6s2bNhBAXL16sQ5szZswwGAzLli3717/+FRUVFRcXV/O6amYd8qoMLvn5+ZGRkXWozfnef//9Bx54oPJZ3MuXL/v5+W3duvXcuXPWZdjbHoBDqbJWrVrpdLpDhw7VY5scSpCCnOTtDhw4UF5ePn369JYtW5pMJkVRrNNjY2MbNGiwdevWOrQZGRk5duzYtLS0BQsWzJw586brqlmHDh0CAwN37dplm5KVlVVWVnb77bfXoTYnU1X1ww8/fOyxxypPDAsLGzNmjNls/uCDD6xT2NsewJsPpUuXLo0fP77ylOzsbLPZHBUVdYst23AoQRZykreLjo4WQnz11VfXrl3Lzs62XTv39fV95pln/vWvf82YMeOXX36xWCxFRUWHDx8WQjRo0CA3N/fkyZNFRUU3upo+Z86cioqKK1eu3HnnnTddV81tmkymOXPmbN68ef369YWFhQcOHJg2bVrTpk2nTp1a3zuj/u3YsSM4OLhPnz5Vpk+bNk1Uul7A3vYA3nwoBQQEbN269ZtvviksLCwvL9+zZ89DDz0UEBAwe/bsW2zZhkMJ0jjzpnE4mZ3fiZg3b16DBg1CQ0PHjBljffJHXFzc6dOnVVV96623OnbsaDKZTCZTQkLCihUrVFXdvXt3TEyMn59f3759n3322SZNmggh/P39hw0bVrnZAQMGrF692s511dymxWJZunRp69atDQZDWFjYyJEjjx07Zm1wxYoV/v7+QojWrVufOHFi5cqV1lsvY2Jifvrpp5tue0ZGRp8+fZo2bWo9HJo0aZKYmLht27Z62bcPP/xwQECAXq/v3Lnz7t27bdMXL15sW2Pz5s2te1X1gr0tPP37bt58KA0bNqxFixaBgYG+vr5xcXHJyckHDhyor33LoVQF33dzJkXl/9F4Luu/Dti4caPsQjwQ+7YOFEVJSUkZO3as7EJqLTU1ddy4cYyWjsC+rQPGH2fiuhsAAIA2chI81tGjR5UbS05Oll0g4B44lODN9LILABwlPj6ek/nAreNQgjfjfBIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2chIAAIA2vewC4FhpaWmKosiuwmOxb70Kv27HYd/WVlJSkuwSvIWiqqrsGuAoGRkZZ86ckV2Fp1mzZs1//vOfF154QXYhbikxMTEyMlJ2FbWWk5OzY8cO2VW4k5SUlO3bt7/11luyC/FYUVFRvXv3ll2FVyAnAbWzevXqJ554orCwUKfTya4FcFGdO3fu37//66+/LrsQ4FZxfxJQOwkJCSUlJT/99JPsQgAXdfr06QMHDgwdOlR2IUA9ICcBtdOxY0ej0bhnzx7ZhQAuKj09PSgo6I477pBdCFAPyElA7RiNxttuu42cBNxIenr6PffcYzQaZRcC1ANyElBrCQkJ5CRAU3Fx8XfffcdFN3gMchJQawkJCbt37+Y7EEB1X375ZUVFxeDBg2UXAtQPchJQawkJCVeuXOGZC0B16enpvXv3btiwoexCgPpBTgJqrXPnzj4+Plx6A6qwWCxffPEFF93gSchJQK0FBwe3bNmSnARUkZmZef78+WHDhskuBKg35CSgLriVG6guPT09Li4uPj5ediFAvSEnAXVBTgKqS09P52QSPAw5CaiLhISEM2fOXLhwQXYhgKv4+eefDx06xM1J8DDkJKAuunbtKoTYu3ev7EIAV5Genh4SEtK3b1/ZhQD1iZwE1EWjRo2aNm3KpTfAJj09ffDgwQaDQXYhQH0iJwF11LVrV3ISYFVYWLh9+3YuusHzkJOAOuJWbsDmiy++MJvN99xzj+xCgHpGTgLqKCEhITs7u7i4WHYhgHzp6en9+vULDw+XXQhQz8hJQB0lJCRYLJb9+/fLLgSQzGw28xhueCpyElBHsbGxYWFhXHoDfvjhh4sXL95///2yCwHqHzkJqCNFUTp37kxOAtLT09u2bdumTRvZhQD1j5wE1B23cgNCiPT0dC66wVORk4C6S0hIOHjwYFlZmexCAGlOnDhx7NgxchI8FTkJqLuEhISysrIjR47ILgSQ5uOPP27QoEFiYqLsQgCHICcBdXfbbbf5+/tz6Q3eLD09/b777tPr9bILARyCnATUnU6na9++PTkJXis/P/+HH37gohs8GDkJuCUJCQm7d++WXQUgx5YtW4QQgwYNkl0I4CjkJOCWJCQk7N2712KxyC4EkCA9Pf2OO+4IDQ2VXQjgKOQk4JYkJCQUFxefOHFCdiGAs1VUVHz55ZdcdINnIycBt6RTp056vZ5blOCFtm/ffuXKlSFDhsguBHAgchJwS/z8/Nq2bUtOghdKT09v3759q1atZBcCOBA5CbhVPJUb3unTTz/lohs8HjkJuFXkJHihI0eOZGdnk5Pg8chJwK1KSEjIy8vLzc2VXQjgQKWlpZVfpqenR0RE9OzZU1Y9gHPwBFXgViUkJCiKkpWVFRkZuWfPnj179uzevfvdd9+Nj4+XXRpQb5KTk8+ePTtq1Kj777+/Q4cO1sdw63Q62XUBjkVOAuooPz9/79691mAUERGRlJRksVj0er2qqhaLJSYmRnaBQH3y8/P78ccf9+zZ88c//rF58+YVFRV33nlneXm5wWCQXRrgQIqqqrJrANzP4sWLFy5cKIQwGAyqqlZUVFSe26RJk7Nnz0oqDXCIhx9++L333rN1daPRWFZWZjKZ7rzzzuHDhw8bNqxJkyZyKwQcgfuTgLqYPn16cHCwEKK8vLxKSBJCcMUNnicwMNDH538fGWVlZUKIa9euffnll1OnTp06daq80gAHIicBdREeHv7iiy9W/tiwMRgM7dq1c35JgEMFBAQoilJ9uqqqDRs2XL16tfNLApyAnATU0bRp09q0aaN5H2vr1q2dXw/gUP7+/prTVVXdsGFDRESEk+sBnIOcBNSRTqdbsWKF2WyuMr28vLxNmzZSSgIcJzAwsPr9rDqd7umnn7777rullAQ4ATkJqLs777xz2LBh1b/vQ06C5wkICLBYLJWn6PX6jh07Pv/887JKApyAnATckuXLl1eZotfrY2NjZdQCOFBAQEDls6eKovj6+m7evJnnAsCzkZOAW9KiRYu5c+fq9f97FFlUVFTll4BnqHLdTVXVlStXtmjRQmJJgBOQk4BbNX/+/IiICOt33xRFad++veyKgPoXEBBg+1mv10+ePHn8+PES6wGcg5wE3Cp/f/9XXnnF+qe2wWDg4UnwSLacpNfrIyMjX3/9dbn1AM5BTgLqwYQJE7p166bX6y0WCw8FgEcKDAy0/qAoykcffRQUFCS3HsA5yElAPVAU5Z133jGbzRUVFXzZDR7Jdj7pz3/+c+fOneUWAzgN/98NDpSRkfHaa6/JrsJ5du3adfLkySFDhvj5+cmuxSXMnj27d+/esqu4oTFjxsguwZ1cv349PT29SZMmffv2lV2LZL179549e7bsKuAknE+CA505cyYtLU12Fc7TsWNHPz8/Pz+/zMzMzMxM2eVIlpaWdubMGdlV1CQtLS0nJ0d2FW5Dp9MZjcZz587JLkSyzMzMjIwM2VXAefj2Mhxu48aNsktwnn/+858DBw60nqjwqg2vTvN/gbmaWbNmjR07VnYV7kFV1eeff/7555/38o7NaUhvw/kkoD4NHDhQdgmAQyiKwj94hhciJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJwEAAGgjJ8G1TJkyJSgoSFGUvXv3yq7FsTZt2tSyZUulEqPR2KhRo/79+y9duvTKlSuyC0RVHtY5LRbLsmXLEhMT67dZOjY8DDkJrmX16tWrVq2SXYUzjB49+ueff46LiwsJCVFV1WKx5OXlpaamtmjRYt68ee3bt9+1a5fsGvErntQ5s7Oz77jjjtmzZ5eUlNRvy3RseBhyEmCv0tLSev/j20ZRlNDQ0P79+69duzY1NfX8+fNDhgwpKChw0OrqzKE7AXVWq9/Lvn37nn766WnTpnXp0sWhVQk6NtwfOQkuR1EU2SVoW7NmTV5enhNWlJSUNGnSpLy8vHfeeccJq6sVp+0E1+QZnbNz586bNm2aMGGCr6+vQ6uqgo4Nd0ROgnyqqi5durRt27a+vr4hISFz5861zXrllVf8/f2DgoLy8vLmzJnTvHnzY8eOqar62muv3Xbbbb6+vmFhYSNGjDh69Kh1+TfeeMNkMjVq1OjRRx9t2rSpyWRKTEzMysqqvK4bvXfGjBlGo7FJkybWl4899lhAQICiKBcvXhRCzJw5c86cOSdOnFAUpVWrVo7eJ5MmTRJCfP755968E1wBnbN+0bHhflTAYVJSUuzpY/Pnz1cU5c9//vOVK1dKSkpWrFghhNizZ49trhDiiSeeePPNN0eNGnXkyJGFCxcajcZ169bl5+fv37+/a9euDRs2PHfunHX5qVOnBgQEHD58+Nq1a4cOHerevXtQUNDp06etc2t+74QJExo3bmwrbOnSpUKICxcuWF+OHj06Li7Ong1PSkpKSkqyZ0nbbRxVFBYWCiGioqLcdycIIVJSUuxZUhZ7KvS8zllZz549O3fubP/ydh7Rqkd3bPuPbngGchIcyJ5RtaSkxN/ff+DAgbYpGzZsqP5RVFpaals+MDAwOTnZtvzOnTuFEIsWLbK+nDp1auUB+scffxRCPP/88/a813Vykqqq1hs7rD+7407wgJzkkZ2zMufnJNX9OzY5ydtw3Q2SHT9+vKSk5K677rJz+UOHDhUXF3fr1s02pXv37kajsfLp98q6devm7+9vPf1e2/dKdPXqVVVVg4ODNed6yU6Qjs5Z7+jYcDvkJEiWk5MjhIiIiLBz+fz8fCFEYGBg5YmhoaFFRUU3eouvr++FCxfq9l5ZfvrpJyFEfHy85lwv2QnS0TnrHR0bboecBMlMJpMQ4vr163YuHxoaKoSoMvbl5+dHRkZqLl9eXm6bW9v3SvTFF18IIQYPHqw510t2gnR0znpHx4bbISdBsg4dOvj4+Gzbts3+5QMDAys/qi4rK6usrOz222/XXP67775TVbVXr172vFev15eXl9dxS+rPuXPnli1bFhkZ+bvf/U5zAW/YCa6Azlm/6NhwR+QkSBYRETF69Oi0tLQ1a9YUFhbu379/5cqVNSxvMpnmzJmzefPm9evXFxYWHjhwYNq0aU2bNp06daptGYvFcuXKlYqKiv3798+cOTM6Otr6beSbvrdVq1aXL1/+6KOPysvLL1y4cOrUqcqrbtCgQW5u7smTJ4uKiupxwFVVtbi42GKxqKp64cKFlJSUPn366HS6jz766Ea3cXjeTnBNdM5bQceGh5B1Azm8gZ3fjikqKpoyZUp4eHhgYGDfvn0XLlwohIiMjNy3b9+SJUv8/PyEEFFRUevWrbMub7FYli5d2rp1a4PBEBYWNnLkSOtjV6ymTp1qMBiaN2+u1+uDg4NHjBhx4sQJ29ya33vp0qUBAwaYTKYWLVr84Q9/sD4sp1WrVtYvHu/evTsmJsbPz69v3762LxtrsucbMZ988kmnTp38/f2NRqOPj4/475OLe/TosWjRokuXLtmWdNOdINz/+26qJ3ZOVVUzMjL69OnTtGlT66dAkyZNEhMTt23bdtM9Zs8R7fEdm++7eRtFVVXnBjN4kdTU1HHjxjm5jz366KMbN268dOmSM1daxZgxY4QQGzdulFWAK+wERVFSUlLGjh0rsYaaOb9CV/i93AopR3RlrrADpR/dcDKuu8EDmc1m2SXIx05wTfxebhE7EE5GTgIAz3H06FHlxpKTk2UXCLgZchI8yjPPPLN27dqCgoIWLVqkpaXJLkcOdoJrcs7vJT4+voY7LT788EMHrdcJ6NiQQi+7AKA+vfTSSy+99JLsKiRjJ7gmfi+3iB0IKTifBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoE0vuwB4vjFjxsguwdkyMzOFV26421m2bNnGjRtlVyGfqqqKotx0sZycHOH1HTszM7NXr16yq4Dz6J577jnZNcBjFRYWFhQUyK5CgsjIyMjISNvLPXv2nDx5MioqSmJJzteuXbt7773Xlbf60KFDwcHBsqtwCT/88EN+fn7jxo1rXiw4OLhdu3bOKcllRUZG9u7du3fv3rILgZMoqqrKrgHwcH/84x+/+OKLPXv2yC4E0KCqanh4+KJFix5//HHZtQAuh/uTAIeLiYk5deqU7CoAbUeOHLly5QrXkgBN5CTA4WJjY69cueKdlyDh+jIzM00mU6dOnWQXArgichLgcDExMUIITinBNWVlZXXr1s1oNMouBHBF5CTA4WJjYxVFOXnypOxCAA18gQuoATkJcDg/P7+IiAjOJ8EFFRUVHTp0qGfPnrILAVwUOQlwhtjYWHISXNDOnTvNZjPnk4AbIScBzhATE8N1N7igzMzMZs2aVX7cF4DKyEmAM3A+Ca4pKyurT58+sqsAXBc5CXAGzifBNe3cuZObk4AakJMAZ4iJibl48WJRUZHsQoD/OXHixPnz57k5CagBOQlwhtjYWCHE6dOnZRcC/E9mZqbBYOjatavsQgDXRU4CnIFHTcIFZWVldenSxc/PT3YhgOsiJwHOEBQUFB4ezi1KcCk8YRK4KXIS4CT8N1y4lNLS0n379nETN1AzchLgJDwaAC7l3//+d1lZGeeTgJqRkwAn4dEAcCmZmZmNGjWKi4uTXQjg0shJgJNw3Q0uJSsri5NJwE2RkwAniY2NPX/+fElJiexCACGEyMzM5OYk4KbISYCTxMTEqKp65swZ2YUAIjc3Nycnh/NJwE2RkwAnadGihRCCW5TgCnbs2OHj49OtWzfZhQCujpwEOElISEhISAi3KMEVZGVldejQITg4WHYhgKsjJwHOw6MB4CJ4wiRgJ3IS4Dw8GgCuoLy8fPfu3dzEDdiDnAQ4D+eT4Ar27t1bUlLC+STAHuQkwHk4nwRXkJmZGRoaGh8fL7sQwA2QkwDniYmJOXv27PXr12UXAq+WlZXVs2dPHx/Gf+DmOE4A54mNjbVYLDxCCXJxEzdgP3IS4DyxsbFCCG5RgkQXL178+eefuYkbsBM5CXCe8PDwoKAgblGCRBkZGUKIHj16yC4EcA/kJMCpoqOjOZ8EibKystq0aRMeHi67EMA9kJMAp+LRAJCLm5OAWiEnAU7FowEgkcVi+fHHH58PgG8AACAASURBVLk5CbAfOQlwqso56fLly3v27Pn222+lVgRPdvbs2YULF27ZsuXSpUtCiIMHDxYWFnI+CbCfXnYBgOc7f/78qf/64YcfSkpK2rRpk5OTU1paKoQYPnz4gAEDZNcIzxQYGLh48WLrz7GxsY0bNzYajRUVFRUVFXo94z9wcxwngGNduXKlTZs2hYWFiqIYDAYhRFlZ2cWLF61z9Xo9F0HgOEFBQUFBQUVFRUKIkydPWp/d1aNHD19f34SEhL59+w4dOvSOO+6QXSbgurjuBjhWWFjYjBkz9Hq9qqplZWVlZWWV51ZUVHARBA4VFRVl+9lsNpvNZiHE9evXMzMzX3311eLiYnmlAW6AnAQ43KxZs6xnkqrz8fG5/fbbnVwPvEqrVq0URak+3Wg0jhw58r777nN+SYAbIScBDtegQYOZM2dq3g7Stm3b4OBg55cE79GiRQvNmK7T6d544w3n1wO4F3IS4Axz5syp/lllMBj69esnpR54j5iYmOoTdTrdSy+9FBkZ6fx6APdCTgKcITw8/A9/+EOVU0oWi4WbuOFoMTEx5eXllafo9fo2bdo8/vjjskoC3Ag5CXCSuXPnVslJZrOZm7jhaDExMaqqVp5iNpvXrFnDcwEAe5CTACdp2LDh448/Xvnqm7+/f3x8vMSS4A2qXHczGAxTp07t3bu3rHoA96JU+TsDgOOcP38+Jibm+vXrQghFUfr37//NN9/ILgqez8/P79q1a0IIRVHCwsKOHz8eFhYmuyjAPXA+CXCexo0bT58+3XpKyWAw9O3bV3ZF8ArNmjWz/fzGG28QkgD7kZMAp3rqqad8fHyEEGVlZdzEDeeIi4sTQhgMhsTExPHjx8suB3An5CTAqZo0afLoo49an/vXo0cP2eXAK1hzkhBizZo1ms+cBHAjfN8BLio1NVV2CY5y22236XS6kJCQb7/9VnYtTjV27FjZJXhyv6pBQUGBEGL48OH79u3bt2+f7HLqmSv0K3gw7uOGi+KvXs/jCqMN/crzuEK/ggfjuhtcV0pKiuqhcnNzV61aVcMCSUlJSUlJTqvH0VJSUmT3pv/x4H51Iz/88MNnn32m0q+A2uO6GyBB06ZNJ02aJLsKeIuePXvqdDrZVQBuifNJgBw8DRlOQ0gC6oycBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBAAAoI2cBA8xZcqUoKAgRVH27t0ru5b/b9GiRe3atQsODvb19W3VqtVTTz1VXFxcj+1v2rSpZcuWSiVGo7FRo0b9+/dfunTplStX6nFdXssF+9ULL7yg/FqHDh3qsX36FVAZOQkeYvXq1atWrZJdxa988803jz/++MmTJy9evPjSSy8tX758zJgx9dj+6NGjf/7557i4uJCQEFVVLRZLXl5eampqixYt5s2b1759+127dtXj6ryTC/YrR6NfAZWRkwBHCQwMnDp1aoMGDYKCgsaOHTty5MgvvvjizJkzDlqdoiihoaH9+/dfu3Ztamrq+fPnhwwZUlBQ4KDVQaJ169aplRw8eNBx66JfwcuRk+A5FEWRXcKvfPrppzqdzvayYcOGQoiSkhInrDopKWnSpEl5eXnvvPOOE1bn2VytX0lEv4IXIifBjamqunTp0rZt2/r6+oaEhMydO7fyXLPZvHDhwujoaD8/v06dOqWkpAgh3n777YCAAH9//48//njw4MHBwcGRkZEbNmywvWvbtm09evTw9/cPDg7u2LFjYWHhjZqqrV9++cXPz69Fixa3ttH2mjRpkhDi888/t750tb3hytyrXzkZ/QpeRwVckhAiJSWl5mXmz5+vKMqf//znK1eulJSUrFixQgixZ88e69wnn3zS19c3LS3typUrzzzzjI+Pz48//mh9lxDi66+/LigoyMvL69evX0BAQFlZmaqqxcXFwcHBS5YsKS0tPXfu3KhRoy5cuFBDU/a7evVqUFDQjBkz7Fw+KSkpKSnJniVt95FUYf3siYqKsr6Uuzesn3l2brtDeUC/Wrx4cWRkZGhoqMFgiI2NHT58+M6dO+3cfPoVUFv0MLiom36elZSU+Pv7Dxw40DbF+ger9fOstLTU398/OTnZtrCvr+/06dPV/47gpaWl1lnWT8Hjx4+r/73P49NPP628ohqast/8+fPbtGlTWFho5/K3/nmmqqr1zhLVBfaG63yeeUC/On369O7du4uKiq5fv56RkZGQkODn53fw4EF7Np9+BdQW193gro4fP15SUnLXXXdpzj127FhJSYnt+9J+fn5NmjQ5evRo9SWNRqMQory8XAjRsmXLRo0aTZw48bnnnjt58mRtm7qRzZs3p6amfvnll0FBQfa/6xZdvXpVVdXg4GDhYnvDxbl+v4qKikpISAgMDDQajb169Vq7dm1paak1iDgB/QrehpwEd5WTkyOEiIiI0Jx79epVIcSzzz5rewbMqVOnbnoPtZ+f3zfffNO3b98XX3yxZcuWycnJpaWldWvK5sMPP/zTn/703XffxcbG2r91t+6nn34SQsTHxwtX2huuz136lU3Hjh11Op311+0E9Ct4G3IS3JXJZBJCXL9+XXOu9XNu2bJllU+fZmRk3LTZ9u3bp6en5+bmzps3LyUl5dVXX61zU0KIN998c/369d98802zZs1qsW314YsvvhBCDB48WLjM3nALbtGvKrNYLBaLxdfXt7ZvrBv6FbwNOQnuqkOHDj4+Ptu2bdOcGxUVZTKZavsM5dzc3MOHDwshIiIiXn755a5dux4+fLhuTamqOm/evAMHDnz00UeBgYG1eu+tO3fu3LJlyyIjI3/3u98JF9gbbsTF+5UQ4p577qn80nqzc+/evWvbTh3Qr+CFyElwVxEREaNHj05LS1uzZk1hYeH+/ftXrlxpm2symSZPnrxhw4a33367sLDQbDbn5OScPXu25jZzc3MfffTRo0ePlpWV7dmz59SpU7169apbU4cPH37llVdWrVplMBgq/wuIV199tR42/tdUVS0uLrZYLKqqXrhwISUlpU+fPjqd7qOPPrLeRyJ9b7gRF+9XQohffvnlww8/zM/PLy8vz8jImDJlSnR09LRp0251y6uhXwFC8E0BuCphx/e3i4qKpkyZEh4eHhgY2Ldv34ULFwohIiMj9+3bp6rq9evX582bFx0drdfrrR9+hw4dWrFihb+/vxCidevWJ06cWLlypXXEj4mJ+emnn06ePJmYmBgWFqbT6Zo1azZ//vyKioobNVVzbQcOHNA84pYuXWrP5tvzvaRPPvmkU6dO/v7+RqPRx8dH/PfRyT169Fi0aNGlS5cqLyx3b7jO95LcvV+pqjpnzpy4uLiAgAC9Xh8ZGfnII4/k5ubaufn0K6C2FFVVHZzEgLpQFCUlJWXs2LGyC5HD+p/gNm7cKLuQ+pGamjpu3DhXGG3oV4J+BdQG190AAAC0kZOAujh69KhyY8nJybILhFuiXwGuRi+7AMAtxcfHc7Yf9Y5+BbgazicBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABoIycBAABo08suALihjIwM2SVIk5OTI4RITU21Z2FVVRVFcXBFt8SlfpUuVYyVxWLx8XHGX6216leuzwV/lfA8iqqqsmsANLj4Bz/qwBVGG/qV53GFfgUPRk4C3Ftpaek999zz888///DDDzExMbLLQS2YzebHH3981apVb7zxxvTp02WXA0ADOQlwewUFBf3797969er27dsbN24suxzY5erVq+PGjfvuu+82bNgwdOhQ2eUA0EZOAjxBbm5u3759GzZs+PXXXwcFBckuBzdx7ty5+++//+TJk5988kliYqLscgDcEDkJ8BAnTpzo27dvu3bttmzZ4uvrK7sc3NDx48cHDx6squrnn3/eunVr2eUAqAnPBQA8RFxc3NatW3fv3p2cnGw2m2WXA20ZGRm9e/cODw/P+H/s3XlAlHXix/HvM8MxgDCA4sklZLIpZqatkiZmlnimgIOJrvbTLCtvw00zy8pcbbVDK1PZUtMBtFwzs3NdXcmyVDzyTglRUZRDQLme3x/Tzk74FRCBB4b36y/nOb7zeZ6ehg/P88xDcjIlCaj76EmA/QgNDf3kk0+++OKLp59+WusskNi4cWPv3r27d+/+3Xff+fj4aB0HQMXoSYBdCQ8PN5vNK1eufPHFF7XOgj948803o6Ojx40bt2HDBhcXF63jAKgU/dy5c7XOAKA6tW3btnXr1lOmTPHw8OjWrZvWcSBKSkomT548b968OXPmLFiwgGc4AfUIz+MG7NDIkSPT09OnTZvm7e39l7/8Res4Ddr169dHjRq1adOmjz/+OCYmRus4AG4NPQmwT3FxcZcuXRo3blzTpk0jIiK0jtNAXb58efDgwYcOHfryyy8feOABreMAuGU8FwCwW6qqjhs3bt26ddu2bevevbvWcRqcU6dO9evXr7Cw8PPPPw8JCdE6DoCq4D5uwG4pivL+++/37dt3wIAB+/fv1zpOw/LDDz9069bN2dl5x44dlCSg/qInAfZMr9evWbPm7rvv7tev3+nTp7WO01Bs2rSpV69eHTt23LlzZ6tWrbSOA6Dq6EmAnXNxcdm8eXOzZs369Olz4cIFrePYvxUrVkRFRcXExHz22Wf8DRmgvqMnAfbPw8Nj27ZtOp3ukUceycrK0jqO3VJVde7cuU888cSsWbNWrlzp6OiodSIAt4v7uIGG4tSpU927dw8JCfn8888NBoPWcexNYWHhmDFjkpKSVq5cGRsbq3UcANWDngQ0IAcOHOjZs+cDDzyQlJTk4MBjQapNVlbWkCFD9uzZk5iY2LdvX63jAKg2XHcDGpDQ0NDPP//866+/Hjt2LL8jVZezZ8+Gh4cfO3Zsx44dlCTAztCTgIala9eu69evX7t27ezZs7XOYg8OHDjQtWvXkpKS5OTkjh07ah0HQDWjJwENzoABA+Lj419//fU33nhD6yz129dff929e/c777xz586d/v7+WscBUP24QQFoiGJjY7OysiZOnOjt7T1mzBit49RL//jHP5544omYmJgVK1Y4OTlpHQdAjaAnAQ3UM888k5aWNm7cOE9PzyFDhmgdp55ZsGDBX//612effXbJkiWKomgdB0BN4ftuQMOlquoTTzyxdu3abdu29ejRQ+s49UNxcfHTTz+9cuXKd95558knn9Q6DoCaRU8CGrSSkpKYmJivvvrqX//6F7chV+jq1asmk2n79u3r168fMGCA1nEA1Dh6EtDQFRYWDhgw4NChQzt37mzdurXWcequc+fODRgwID09/bPPPrv33nu1jgOgNtCTAIicnJxevXplZ2fv3LmzefPmWsepiw4fPtyvXz9HR8etW7fecccdWscBUEt4LgAA4eHh8cUXXzg4OPAH4KR27dr1wAMPtGjRIjk5mZIENCj0JABCCOHj4/PVV19duXJlyJAh165d0zpOHZKUlNS7d++ePXt+++23TZo00ToOgFpFTwLwOz8/v88//zwlJcVkMhUXF2sdp0548803TSbTE088kZiY6OLionUcALWNngTgf9q3b//5559/8803jz/+eAO/ebGkpOSZZ56ZMmXK/Pnz33zzTZ2OT0ugIeI5kwD+4M9//vMnn3wyYMCAli1bvv7661rH0UZ+fv7w4cO3bdu2bt06k8mkdRwAmqEnASirT58+8fHxI0eObNKkyfTp07WOU9syMzMHDx78yy+/fPXVVzx+E2jg6EkAJB577LErV648++yzXl5e//d//6d1nNpz8uTJfv36FRUV7dq1q23btlrHAaAxehIAuaeffjo9PX38+PFeXl5Dhw7VOk5t2L1798CBAwMDAzdv3tysWTOt4wDQHncmAripV199dcKECbGxsf/+97/LzEpOTi4pKdEkVQ359NNPH3zwwU6dOn3zzTeUJAAW9CQA5VmyZMmAAQMGDhy4d+9e68SNGzeGh4dv3rxZw2BV9vzzz1+6dKnMxLfeeisyMnL48OGfffaZu7u7JsEA1EH0JADl0el0a9as6dat2yOPPHLs2DEhxAcffBAdHV1UVPTGG29one6W/ec//3n99df79+9fUFBgmaKq6ty5cydPnvzCCy+sWLHCwYG7EQD8D3/fDUDFcnNzH3zwwcuXL48ePfrFF1+0fm7s37+/Q4cO2marPFVVO3fuvH//fkVR+vfvv3HjxqKiojFjxmzYsGHVqlUjRozQOiCAOoeeBKBSMjIyOnXqdPbsWesUR0fH0aNHL1++XMNUt2TNmjWjRo2yfOjpdLpRo0adOnUqJSXlk08+CQ8P1zodgLqIngSgYiUlJWPHjv3oo49KS0ttpzs5OaWnpzdu3FirYJVXUFBwxx13nD9/3roJiqJ4enru2LGjXbt22mYDUGdxfxKACly/fj0yMnL16tVlSpIQorS0dOXKlZqkulVvvPHGhQsXbDdBVdWsrKx9+/ZpmApAHcf5JADlycrK6tevX3Jy8s0WaNmyZWpqql6vr81UtyojI6N169b5+fllpiuKotfrt23b9uCDD2oSDEAdx/kkAOXR6/V9+vRxcXFxdHSULnDu3LlNmzbVcqpbNWvWrKKiohunq6qqqurQoUOPHj1a+6kA1H30JADlcXd3f+mll1JTU6dOnero6HhjW9LpdHX8AQEpKSmrVq2S9iQhhE6ny83NXbp0aS2nAlAvcN0NQGWlpqbOmzdv1apVer2+TO3Yt2/f3XffrVWw8vXu3XvHjh1lAuv1+tLSUi8vr3Hjxo0fP75169ZaxQNQl3E+CUBl+fv7f/DBBykpKQMGDBBCWB/J6Ojo+NZbb2ka7aY+++yzb7/91rYkOTo6KorSvXt3s9l8/vz5119/nZIE4GY4nwSgKnbt2jVt2rTvv/9er9eXlJQ4OjqmpaU1bdpU61x/UFxc3K5du5MnT5aUlOh0OiGEq6vrY489NmnSpLvuukvrdADqAc4nAaiKsLCwXbt2bdiwITAwUAhRVFS0atUqrUOV9f777x87dkxVVUVRunXrtnbt2kuXLr3//vuUJACVxPkkoKGIjo5OSkrSOkX9Zjabhw0bpnUKALWHv/gINCBdu3adMmVKTYxcWFj4xRdfBAUFtW/f/lbXNZlMkydP7tatW/VG+v777wsLC7t27erk5FQtA5pMpmoZB0A9wvkkoKGIjo4WQiQmJmodpCxFUerFeZr6khNANeL+JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMA3LKxY8e6u7srirJv375bnXv7Pv74Y0VRwsLCKlxS25wA7AA9CcAtW7FixQcffFC1ubfv448/Dg4OTk5OPnHiRPlLapsTgB2gJwGoTzIzMw8fPvzSSy8JIT766COt4wCwc/QkAFWhKEqV596OhISE/v37Dxo0yGAwrF69WlXV8pfXKicA+0BPAvAHO3bsuOuuu4xGo8FgCA0N3bZtm2W6qqoLFy5s27ats7Oz0WicMWOG7Vrlz61GH3/88dChQ93d3R9++OHTp0/v2LGjzAJ1JCcA+0BPAvAHFy5cMJlMp0+fTk9Pb9So0YgRIyzTX3jhhbi4uPHjx1+4cOH8+fMzZ860Xav8udUlNTX16NGjDzzwgBAiOjpayC691YWcAOwGPQnAH0RFRb344oteXl7e3t6DBg3KzMy8ePFiQUHB4sWLH3rooalTp3p6erq4uHh7e1tXKX9uNfr4448HDBig1+uFEIMGDXJ2dk5MTCwoKKhkklrLCcBu0JMA3JSjo6MQoqSk5MSJE/n5+b1795YuVv7camS56Gb5t4eHx8MPP5yTk7Np06ZKJqm1nADshoPWAQDULVu2bFm4cOGhQ4dycnKKioosE9PS0oQQPj4+0lXKn1tdDh48eODAgYEDB5aZ/tFHH8XExFQmSe3kBGBPOJ8E4H9SU1OHDBnSvHnz3bt3Z2dnL1iwwDLdYDAIIa5fvy5dq/y51WXt2rXDhw9XbVy+fNnFxeXLL788f/583ckJwJ7QkwD8z4EDB4qKiiZMmBAUFGQwGKxfm2/fvr1Op9u+fbt0rfLnVgtVVdevX//000/bTvTy8oqOji4pKfn444/rSE4AdoaeBOB//P39hRBff/31tWvXjh8/vnv3bst0Hx+fyMjIpKSklStX5uTkpKSkLF++3LpW+XOrxa5duzw8PO6///4y05966ilh8603zXMCsDcqgIYhKioqKiqqwsXi4uK8vb09PT2jo6PfeecdIURwcHBqampubu7YsWMbN27cqFGj7t27z5kzRwjh6+u7f/9+VVXLn1s+IYTZbC5ngf/7v/9zc3NzcHC4++67f/75Z+v0efPmtWjRwvJR1qpVq6VLl1aYpEZzArA/ilrR02wB2AfLA4cSExO1DlKWoihms3nYsGFaB6lAfckJoBpx3Q0AAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAzkHrAABqT1JSkqIoWqeQMJlMJpNJ6xQAUJaiqqrWGQDUhuTk5N9++03rFDeVnJy8ZMkSs9msdZDyhIWF+fr6ap0CQO2hJwGoExISEkwmE59IAOoU7k8CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACDnoHUAAA1UQUHBuXPnrC8vXLgghDh16pR1il6vDwgI0CAZAPyXoqqq1hkANESZmZnNmzcvLi6+2QJ9+/bdunVrbUYCgDK47gZAG40bN+7Tp49OJ/8UUhQlJiamliMBQBn0JACaiY2NvdkpbQcHh0cffbSW8wBAGfQkAJoZPHiws7PzjdMdHBwGDRpkNBprPxIA2KInAdCMm5vb4MGDHR0dy0wvKSkZMWKEJpEAwBY9CYCWRowYUVRUVGaii4tLRESEJnkAwBY9CYCW+vbt6+HhYTvF0dHRZDIZDAatIgGAFT0JgJYcHR2HDRtme+mtqKjoscce0zASAFjx/CQAGvvuu+8efPBB68vGjRtfuHBBr9drGAkALDifBEBjPXv2bNq0qeXfTk5OsbGxlCQAdQQ9CYDGdDpdbGysk5OTEKKwsHD48OFaJwKA33HdDYD29uzZ06VLFyGEr69vamqqoihaJwIAITifBKAu6Ny5c+vWrYUQo0ePpiQBqDsctA4AoAJ///vfk5OTtU5R41xcXIQQP/zwQ3R0tNZZatzUqVO7deumdQoAFeN8ElDXJScnf//991qnqHF+fn5Go7HMs5SEEGlpaUlJSZpEqiFJSUm//fab1ikAVArnk4B6oGvXromJiVqnqHHbtm175JFHykxMSEgwmUz2tPlcWATqEc4nAagrbixJAKAtehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTADs0duxYd3d3RVH27dundZb/KSoqeu211+644w4nJydPT8/27dufPn26WkbesGFDUFCQYsPJyalp06bh4eELFy68cuVKtbwLgAaIngTYoRUrVnzwwQdapyjLZDJ99NFHa9euzc/P/+WXX4KDg69evVotI0dGRp46dSo4ONhoNKqqWlpampGRkZCQ0Lp167i4uHbt2u3Zs6da3ghAQ+OgdQAADcL69es//fTT/fv3h4aGCiFatGixadOmGnovRVE8PT3Dw8PDw8P79+9vMpn69+9/7Ngxo9FYQ+8IwF5xPgmwT4qiaB3hD959991OnTpZSlJtioqKGj16dEZGxnvvvVfLbw3ADtCTADuhqurChQvbtm3r7OxsNBpnzJhhO7ekpGTOnDn+/v4uLi4dOnQwm81CiGXLlrm5ubm6um7atCkiIsLDw8PX13fdunXWtbZv337fffe5urp6eHiEhobm5OTcbKjyFRYWfv/99x07dqzuja6U0aNHCyG2bt1qeantrgBQz6gA6raoqKioqKgKF5s1a5aiKG+88caVK1fy8/OXLl0qhNi7d69l7vTp052dnZOSkq5cufL888/rdLoff/zRspYQ4ptvvsnOzs7IyOjRo4ebm1thYaGqqlevXvXw8FiwYEFBQcH58+eHDh168eLFcoYqx6+//iqE6NixY3h4ePPmzZ2dnUNCQt55553S0tIKt8tSPipcTFVV6/1JZVg6jZ+fX13YFaqqCiHMZnNltgiA5uhJQF1XmZ6Un5/v6urap08f6xTLuRBLTyooKHB1dY2JibEu7OzsPGHCBPW/5aCgoMAyy9KuTpw4oarqwYMHhRCfffaZ7RuVM1Q5Dhw4IITo06fPf/7zn8zMzKysrJkzZwoh1qxZU+Hm335PUlXVcsdS+flrZ1eo9CSgXuG6G2APTpw4kZ+f37t3b+nco0eP5ufnt2/f3vLSxcWlefPmR44cuXFJJycnIURRUZEQIigoqGnTprGxsXPnzrV+gb/yQ9lydnYWQrRr1y4sLMzb29toNL700ktGo3H58uVV2NhblZeXp6qqh4eHqAO79KxUIAAAIABJREFUAkD9Qk8C7EFaWpoQwsfHRzo3Ly9PCDF79mzr44XOnDmTn59f/pguLi7ffvtt9+7dX3311aCgoJiYmIKCgqoN1aJFCyHEpUuXrFOcnJwCAgJOnjx5K1tZRceOHRNChISEiDqwKwDUL/QkwB4YDAYhxPXr16VzLf1p8eLFtieTk5OTKxy2Xbt2mzdvTk9Pj4uLM5vNixYtqtpQjRo1atOmzeHDh20nFhcX184X9b/44gshREREhKgDuwJA/UJPAuxB+/btdTrd9u3bpXP9/PwMBsOtPps7PT3d0mx8fHzmz5/fqVOnw4cPV20oIYTJZNq7d++pU6csL/Pz88+cOVMLjwk4f/784sWLfX19H3/8cVE3dgWAeoSeBNgDHx+fyMjIpKSklStX5uTkpKSk2N76YzAYxowZs27dumXLluXk5JSUlKSlpZ07d678MdPT05988skjR44UFhbu3bv3zJkzXbt2rdpQQoipU6cGBASMHj06NTU1MzMzLi6uoKDAcjd3NVJV9erVq5av0V28eNFsNt9///16vf7TTz+13J9UF3YFgPqkhu4PB1BdKvlcgNzc3LFjxzZu3LhRo0bdu3efM2eOEMLX13f//v2qql6/fj0uLs7f39/BwcFSqg4dOrR06VJXV1chRJs2bU6ePLl8+XJLmQgICDh27Njp06fDwsK8vLz0en3Lli1nzZpVXFx8s6EqsyG//fbb8OHDvby8nJ2d77vvvq1bt1Zmrcp83+2f//xnhw4dXF1dnZycdDqd+O8jue+7776XX345MzPTdmHNd4Xg+25A/aGoqqpdSQNQsejoaCFEYmKi1kG0kZCQYDKZ7OmTSlEUs9k8bNgwrYMAqBjX3QAAAOToSQBu15EjR5Sbi4mJ0TogAFSRg9YBANR7ISEh9nRdDACsOJ8EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADkHrQMAqNj3338fHR2tdQptpKWlCSEa7OYD0BY9CajrunXrpnWE2pCenr5nz55BgwaVme7r6xsVFaVJpBoSFRXl5+endQoAlaKoqqp1BgAQCQkJJpOJTyQAdQr3JwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyCmqqmqdAUBDdPbs2YEDBxYVFVle5uXlXbx4MTAw0LpAx44dV69erU04ABBCCOGgdQAADVSrVq2uXbv2yy+/2E48ePCg9d8mk6nWQwHAH3DdDYBmRo0a5eBw09/W6EkANMd1NwCaSU1NDQwMvPFTSFGUe+6556efftIkFQBYcT4JgGb8/f27dOmi05X9INLr9aNGjdIkEgDYoicB0NKoUaMURSkzsaSkJDo6WpM8AGCLngRAS8OGDSszRa/X9+zZs2XLlprkAQBb9CQAWvLx8QkPD9fr9bYTR44cqVUeALBFTwKgsZEjR9reyq3T6YYOHaphHgCwoicB0NjQoUOtTwdwcHCIiIjw9PTUNhIAWNCTAGjM3d19wIABjo6OQoiSkpLY2FitEwHA7+hJALQ3YsSI4uJiIYTBYBgwYIDWcQDgd/QkANrr16+fq6urECIyMtLFxUXrOADwO/6+G2pQQkKC1hFQb3Tp0uVf//qXn58fhw0qyc/Pr1u3blqngJ3j75agBt34/EAAqC5RUVGJiYlap4Cd43wSapbZbL7xQYLAjUpKSl577bUXXnihnGUSEhJMJhO/3UEIwRPbUTu4PwlAnaDX6//6179qnQIA/oCeBKCusD5FCQDqCHoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJ0FLXbp00ev1HTt2rInBx4wZYzAYFEW5du1aTYxfyxYtWtS0aVNFUd577z3LlM8//9xoNG7evLlaxq/e0Srp2rVrISEhs2fPrsYxN2zYEBQUpNhwcHBo0qTJQw89tHHjxup6l/KPLtsMI0eOtJ318MMPu7u76/X6du3a/fzzz9WV55bY5bEE1BB6ErT0448/9urVq4YGj4+Pnz59eg0NXvumT5++a9cu2ymqqlbj+NU7WiXNmjXr6NGj1TtmZGTkqVOngoODjUajqqqqql68eNFsNp89ezYyMtJsNlfLu5R/dFkzNG7ceM2aNVu2bLHO+vLLLxMTEwcOHHjo0KFOnTpVS5hbZZfHElBD6EnQnqIot7pKQUFBWFhYTYSpR/r375+dnT1w4MCqrV5mH97maFWwa9eugwcP1sIbeXl59e7d+8033xRCJCQkVLh8NR5db731lk6nGz9+fHZ2drUMWEPq+7EE1Bx6ErTn6Oh4q6usXLkyIyOjkgtXoYc1BLe0D6tdQUHBjBkzlixZUmvvGBgYKITIysqqcMlqPLrCwsImT5589uxZezq1eSNtjyWgRtGToL0TJ06EhIS4ubm5uLj06NFj586d1lk7duy46667jEajwWAIDQ3dtm2bEGLy5MnTpk07efKkoih33HGHZcnVq1d37tzZYDC4ubkFBgbOmzfPMl2n023ZsiUiIsJoNLZo0WLVqlWVibRs2TI3NzdXV9dNmzZFRER4eHj4+vquW7fOuoCqqn//+9//9Kc/OTs7e3l5Pfroo0eOHLHM+tvf/ubq6uru7p6RkTFt2rRWrVo99dRTbm5uOp3u3nvvbdasmaOjo5ubW6dOnXr06OHn52cwGDw9PZ977rnyt7qMnTt3+vv7K4ryzjvvWPahcoOvvvqqkvuwzGjlb2CFO6cyZs2a9fTTT/v4+NzSWrcjJSVFCNGzZ0/rlNo5ul555ZU777xzxYoVX3/9tTQYx9JtHktAzVKBGiOEMJvN5S/Tu3fvoKCgX3/9taio6ODBg3/+858NBsOxY8cscxMTE+fOnXv58uXMzMyuXbs2btzYMj0yMjI4ONg6yOLFi4UQ8+fPz8zMvHz58vvvvz9ixAhVVWfNmiWE+Oabb7Kysi5fvtyvXz9nZ+e8vLzKhLeum52dnZGR0aNHDzc3t8LCQsvcOXPmODk5rV69OisrKyUlpVOnTk2aNDl//rztupMmTXr77beHDh36yy+/vPjii0KI3bt35+XlXbp0qW/fvkKILVu2XLx4MS8vb+LEiUKIffv2lb/Vx48fF0K8++67lpe//fabEOLtt9+2zJo5c6Zl086dO+fl5RUWFlZSUlL5fWg7WiU38GY7p0I7d+4cNGiQqqoXL14UQsyaNauSK1ruLqrMkrb3J+Xn52/dujUgIODhhx++evWqdZmaPrqCg4N//fVXVVV37dql0+kCAwMt775169bBgwdbF+NYqtqxFBUVFRUVVeFiwG2iJ6EGVbIn3X333daXll/6p0+ffuOSr732mhAiIyND/ePncmFhoaenZ69evaxLFhcXL1myRP3vR3BBQYFl+kcffSSEOHjwYGXCl1l36dKlQogTJ06oqpqfn9+oUaOYmBjrwj/88IMQ4uWXX5auq6qq5Wdbbm6u5eWHH34ohDhw4IDt6uvXry9/q8v52WZryJAhBoPhyJEj5Y9Wzs+2W91A251Tofz8/M6dO6elpak13JPK/E4YGhr64YcfXr9+Xbp8TRxd1p6kquq0adOEEM8884z6x57EsVTlY4mehNrBdTfULaGhoUaj0dKWyrDcxlRSUlJmekpKSlZW1iOPPGKdotfrJ02adLMRioqKqhDMycnJuu6hQ4euXr3auXNn69wuXbo4OTnt3r37lkYrLi6uMNjNtvpmEhISPvnkk5deeqlt27ZVHu1WN9B251To+eeff+KJJ1q1alWZhW+H9XxSUVFRWlralClTJk6c2KFDh0uXLt24cE0fXa+88krbtm2XLl1qe1lZcCzd4JaOJaAW0JNQ5zg6Olo/Jbds2RIeHu7j4+Ps7Gx714WtnJwcIYSnp2etJbTcC9yoUSPbiZ6enrm5udUyfmW2WiozM/PZZ5/t0qWL5exFlUeruQ3cuXPngQMHxo4de5vj3BIHB4dWrVqNGTNm0aJFR48enT9/vmV6bR5dBoMhPj5eUZTHH3+8oKDAOp1jCajj6EmoW4qLiy9fvuzv7y+ESE1NHTJkSPPmzXfv3p2dnb1gwQLpKi1bthRCSE8S1BDLT80yH/RZWVm+vr63P3glt1pq0qRJWVlZ8fHxer3+dkaruQ1cuXLlN998o9PpLHcHW+7jfvXVVxVF2bNnz20OXqHQ0FAhxOHDh4UWR1e3bt2mTp16/Phx623ggmMJqPPoSahbvvvuu9LSUsvz9w4cOFBUVDRhwoSgoCDLs4+lqwQGBnp7e3/55Ze1FrJ9+/aNGjWy/bm+e/fuwsLCe++99/YHr+RW32jLli1r16594YUX2rVrZ5kyY8aMqo1WcxsYHx9ve+Hf9v4k20szNeSnn34SQliuImlydM2bNy8kJGTv3r3WKRxLQB1HT4L2CgsLs7Ozi4uLf/7554kTJwYEBIwePVoIYTmr9PXXX1+7du348eO2NzR4e3unp6efPn06NzdXp9M9//zz//73vydOnHj27NnS0tLc3FzLOYMaYjAYpk2btnHjxjVr1uTk5Bw4cOCpp55q0aLF+PHjb3/wcra6HDk5OU8++WTHjh1nzpwphLh27dqePXv27dtXyX1Y5naQGt3A2lRQUFBaWqqqanp6enx8/OzZs5s0aTJlyhSh0dFlufpmPUMjOJaAuq/W7xxHAyIq8X23+Pj4Xr16NW3a1MHBoXHjxsOHDz9z5ox1blxcnLe3t6enZ3R0tOVxLMHBwampqT///HNAQICLi0v37t0tXzB+5513QkNDDQaDwWC45557li5dumDBAhcXFyFEmzZtTp48uWbNGi8vLyGEr69vhV95W7p0qaurq3Xd5cuXe3h4CCECAgIszywoLS1duHBhmzZtHB0dvby8hgwZcvToUcu61vf18/NbvXq1qqpLliyxjBYYGLhjx47XX3/daDQKIZo1a7Z27dr169c3a9ZMCOHl5bVu3bqbbfXkyZMti7m5uQ0dOvTtt99u3ry5EMLV1XXQoEGLFi268f/ufv36VXIfzp4923a08jewwp1TeTXxfbeNGzfe+GU3Z2fnNm3aTJgwITU11bpkzR1d1gxNmjSxfMfN1owZM2yfC8CxVLVjie+7oXYoKn+IBzVGURSz2Txs2DCtg8BOJCQkmEwmPrUghIiOjhZCJCYmah0Edo7rbgAAAHL0JDRER44cufEvM1jFxMRoHbC+YscCsDMOWgcANBASEsK1m5rAjgVgZzifBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5B60DwM4lJydrHQH2w3I4JSQkaB0E2ktLS/P19dU6Beyfoqqq1hlgtxRF0ToCALsVFRWVmJiodQrYOXoSgDohISHBZDLxiQSgTuH+JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOQetAwBooC5cuPCPf/zD+jIlJUUIsWDBAusULy+vJ554ovaDAYCVoqqq1hkANETFxcXNmjXLzs52cPj9FzZVVRVFsfz7+vXr48aNW758uXYBAYDrbgA04uDgEBMTo9Pprv9XYWGh9d9CiMcee0zrjAAaOs4nAdDMzp07e/ToIZ3l4+Nz7tw5vV5fy5EAwBbnkwBo5v7772/ZsuWN052cnEaNGkVJAqA5ehIAzSiKEhsb6+joWGZ6YWHh8OHDNYkEALa47gZAS/v27bvnnnvKTAwICDh9+rQWcQDgDzifBEBLHTt2bNOmje0UJyen0aNHaxQHAP6AngRAY6NGjbK99FZYWGgymTTMAwBWXHcDoLGTJ0+2adPG8lmkKEpoaOj+/fu1DgUAQnA+CYDmgoODO3bsqNPphBAODg6jRo3SOhEA/I6eBEB7o0aNsvSk4uJiLroBqDu47gZAe+fOnfP19S0tLQ0LC/vPf/6jdRwA+B3nkwBor0WLFpYHc//lL3/ROgsA/A/nk4C6Ljo6OikpSesUqE5ms3nYsGFapwBQMQetAwCoWNeuXadMmaJ1ipqVl5e3fPnyGzczOTl5yZIlZrNZk1Q1gRuwgHqEngTUA76+vg3h9EOfPn18fX1vnL5kyRJ72nx6ElCPcH8SgLpCWpIAQEP0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBdmjs2LHu7u6Kouzbt0/rLL8LDw9XbtCoUaNqGXzDhg1BQUG2Izs5OTVt2jQ8PHzhwoVXrlyplncB0ADRkwA7tGLFig8++EDrFBXr3r17tYwTGRl56tSp4OBgo9GoqmppaWlGRkZCQkLr1q3j4uLatWu3Z8+eankjAA0NPQlAbTAYDDk5OaqN8ePHP/fcczXxXoqieHp6hoeHx8fHJyQkXLhwoX///tnZ2TXxXgDsGz0JsE+Komgd4Q+++OILd3d368vffvvt4MGDDz74YE2/b1RU1OjRozMyMt57772afi8A9oeeBNgJVVUXLlzYtm1bZ2dno9E4Y8YM27klJSVz5szx9/d3cXHp0KGD2WwWQixbtszNzc3V1XXTpk0REREeHh6+vr7r1q2zrrV9+/b77rvP1dXVw8MjNDQ0JyfnZkPdqtdff33SpEm3t8WVNXr0aCHE1q1bLS/r2q4AUKepAOq2qKioqKioChebNWuWoihvvPHGlStX8vPzly5dKoTYu3evZe706dOdnZ2TkpKuXLny/PPP63S6H3/80bKWEOKbb77Jzs7OyMjo0aOHm5tbYWGhqqpXr1718PBYsGBBQUHB+fPnhw4devHixXKGqry0tLS77rqrpKSkMgtbykdllrTen1SGpdP4+flZXmq+K4QQZrO5MlsEQHP0JKCuq0xPys/Pd3V17dOnj3WK5VyIpScVFBS4urrGxMRYF3Z2dp4wYYL633JQUFBgmWVpVydOnFBV9eDBg0KIzz77zPaNyhmq8p555pl33323kgvffk9SVdVyx5JaN3YFPQmoR7juBtiDEydO5Ofn9+7dWzr36NGj+fn57du3t7x0cXFp3rz5kSNHblzSyclJCFFUVCSECAoKatq0aWxs7Ny5c0+fPn2rQ91Menr6P//5T8u1sNqRl5enqqqHh4eoY7sCQN1HTwLsQVpamhDCx8dHOjcvL08IMXv2bOvjhc6cOZOfn1/+mC4uLt9++2337t1fffXVoKCgmJiYgoKCqg1la8GCBePGjTMYDJVf5TYdO3ZMCBESEiLq2K4AUPfRkwB7YKkd169fl8619KfFixfbnkxOTk6ucNh27dpt3rw5PT09Li7ObDYvWrSoykNZnD9//uOPP54wYUJlN6w6fPHFF0KIiIgIUZd2BYB6gZ4E2IP27dvrdLrt27dL5/r5+RkMhlt9Nnd6evrhw4eFED4+PvPnz+/UqdPhw4erNpTVggULYmNjvb29q7Z6FZw/f37x4sW+vr6PP/64qEu7AkC9QE8C7IGPj09kZGRSUtLKlStzcnJSUlKWL19unWswGMaMGbNu3bply5bl5OSUlJSkpaWdO3eu/DHT09OffPLJI0eOFBYW7t2798yZM127dq3aUBYXLlxYtWrVlClTbmtTy6Wq6tWrV0tLS1VVvXjxotlsvv/++/V6/aeffmq5P6mO7AoA9UYN3R8OoLpU8rkAubm5Y8eObdy4caNGjbp37z5nzhwhhK+v7/79+1VVvX79elxcnL+/v4ODg6VUHTp0aOnSpa6urkKINm3anDx5cvny5ZYyERAQcOzYsdOnT4eFhXl5een1+pYtW86aNau4uPhmQ1VmQ6ZOnRobG3urm1+Z77v985//7NChg6urq5OTk06nE/99JPd999338ssvZ2Zm2i6s+a4QfN8NqD8UVVW1K2kAKhYdHS2ESExM1DqINhISEkwmkz19UimKYjabhw0bpnUQABXjuhsAAIAcPQnA7Tpy5IhyczExMVoHBIAqctA6AIB6LyQkxJ6uiwGAFeeTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACDnoHUAABVLSkpSFEXrFFpq4JsPQCuKqqpaZwBQnuTk5N9++03rFDUuOTl5yZIlZrNZ6yC1ISwszNfXV+sUACpGTwJQJyQkJJhMJj6RANQp3J8EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAEDOQesAABqogoKCc+fOWV9euHBBCHHq1CnrFL1eHxAQoEEyAPgvRVVVrTMAaIgyMzObN29eXFx8swX69u27devW2owEAGVw3Q2ANho3btynTx+dTv4ppChKTExMLUcCgDLoSQA0Exsbe7NT2g4ODo8++mgt5wGAMuhJADQzePBgZ2fnG6c7ODgMGjTIaDTWfiQAsEVPAqAZNze3wYMHOzo6lpleUlIyYsQITSIBgC16EgAtjRgxoqioqMxEFxeXiIgITfIAgC16EgAt9e3b18PDw3aKo6OjyWQyGAxaRQIAK3oSAC05OjoOGzbM9tJbUVHRY489pmEkALDi+UkANPbdd989+OCD1peNGze+cOGCXq/XMBIAWHA+CYDGevbs2bRpU8u/nZycYmNjKUkA6gh6EgCN6XS62NhYJycnIURhYeHw4cO1TgQAv+O6GwDt7dmzp0uXLkIIX1/f1NRURVG0TgQAQnA+CUBd0Llz59atWwshRo8eTUkCUHc4aB0A9iw6OlrrCKg3XFxchBA//PADhw0qqVu3blOnTtU6Bewc55NQg5KSktLS0rROgfrBz8/PaDSWeZZSGWlpaUlJSbUWCXXZ999/n5ycrHUK2D/uT0INUhTFbDYPGzZM6yCoH7Zt2/bII4+Us0BCQoLJZOJTC+K/p6sTExO1DgI7x/kkAHVF+SUJAGofPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJ0FKXLl30en3Hjh1rYvAxY8YYDAZFUa5du1YT49eyRYsWNW3aVFGU9957zzLl888/NxqNmzdvrpbxq3e0crzyyivKH7Vv374ax9+wYUNQUJDt+A4ODk2aNHnooYc2btxYXe9S/tFlm2HkyJG2sx5++GF3d3e9Xt+uXbuff/65uvLcErs5loBaQE+Cln788cdevXrV0ODx8fHTp0+vocFr3/Tp03ft2mU7RVXVahy/ekfTUGRk5KlTp4KDg41Go6qqqqpevHjRbDafPXs2MjLSbDZXy7uUf3RZMzRu3HjNmjVbtmyxzvryyy8TExMHDhx46NChTp06VUuYW8WxBFQePQnaUxTlVlcpKCgICwuriTD1SP/+/bOzswcOHFi11cvsw9sc7ZasXr1atXHw4MEafTsvL6/evXu/+eabQoiEhIQKl6/Go+utt97S6XTjx4/Pzs6ulgFrSP09loCaRk+C9hwdHW91lZUrV2ZkZFRy4Sr0sIbglvahHQgMDBRCZGVlVbhkNR5dYWFhkydPPnv2rD2d2rxRQzuW0KDQk6C9EydOhISEuLm5ubi49OjRY+fOndZZO3bsuOuuu4xGo8FgCA0N3bZtmxBi8uTJ06ZNO3nypKIod9xxh2XJ1atXd+7c2WAwuLm5BQYGzps3zzJdp9Nt2bIlIiLCaDS2aNFi1apVlYm0bNkyNzc3V1fXTZs2RUREeHh4+Pr6rlu3zrqAqqp///vf//SnPzk7O3t5eT366KNHjhyxzPrb3/7m6urq7u6ekZExbdq0Vq1aPfXUU25ubjqd7t57723WrJmjo6Obm1unTp169Ojh5+dnMBg8PT2fe+658re6jJ07d/r7+yuK8s4771j2oXKDr776qpL7sMxo5W9ghTunbkpJSRFC9OzZ0zqldo6uV1555c4771yxYsXXX38tDcaxVO+OJTQsKlBjhBBms7n8ZXr37h0UFPTrr78WFRUdPHjwz3/+s8FgOHbsmGVuYmLi3LlzL1++nJmZ2bVr18aNG1umR0ZGBgcHWwdZvHixEGL+/PmZmZmXL19+//33R4wYoarqrFmzhBDffPNNVlbW5cuX+/Xr5+zsnJeXV5na1ZS6AAARIUlEQVTw1nWzs7MzMjJ69Ojh5uZWWFhomTtnzhwnJ6fVq1dnZWWlpKR06tSpSZMm58+ft1130qRJb7/99tChQ3/55ZcXX3xRCLF79+68vLxLly717dtXCLFly5aLFy/m5eVNnDhRCLFv377yt/r48eNCiHfffdfy8rfffhNCvP3225ZZM2fOtGzauXPnvLy8wsLCSkpKKr8PbUer5AbebOeUb968eb6+vp6eno6OjoGBgYMHD/7hhx8qs6Kqqpa7iyqzpO39Sfn5+Vu3bg0ICHj44YevXr1qXaamj67g4OBff/1VVdVdu3bpdLrAwEDLu2/dunXw4MHWxTiWqnYsRUVFRUVFVbgYcJvoSahBlexJd999t/Wl5Zf+6dOn37jka6+9JoTIyMhQ//i5XFhY6Onp2atXL+uSxcXFS5YsUf/7EVxQUGCZ/tFHHwkhDh48WJnwZdZdunSpEOLEiROqqubn5zdq1CgmJsa68A8//CCEePnll6Xrqqpq+dmWm5trefnhhx8KIQ4cOGC7+vr168vf6nJ+ttkaMmSIwWA4cuRI+aOV87PtVjfQdudUKDU19eeff87Nzb1+/XpycvI999zj4uJSyf8ot9STyvxOGBoa+uGHH16/fl26fE0cXdaepKrqtGnThBDPPPOM+seexLFU5WOJnoTawXU31C2hoaFGo9HSlsqw3MZUUlJSZnpKSkpWVtYjjzxinaLX6ydNmnSzEYqKiqoQzMnJybruoUOHrl692rlzZ+vcLl26ODk57d69+5ZGKy4urjDYzbb6ZhISEj755JOXXnqpbdu2VR7tVjfQdudUyM/P75577mnUqJGTk1PXrl3j4+MLCgosPx2rl/V8UlFRUVpa2pQpUyZOnNihQ4dLly7duHBNH12vvPJK27Ztly5dantZWXAs3eCWjiWgFtCTUOc4OjpaPyW3bNkSHh7u4+Pj7Oxse9eFrZycHCGEp6dnrSW03AvcqFEj24menp65ubnVMn5ltloqMzPz2Wef7dKli+XsRZVHq+kNtBUaGqrX648dO1btI1s5ODi0atVqzJgxixYtOnr06Pz58y3Ta/PoMhgM8fHxiqI8/vjjBQUF1ukcS0AdR09C3VJcXHz58mV/f38hRGpq6pAhQ5o3b7579+7s7OwFCxZIV2nZsqUQQnqSoIZYfmqW+aDPysry9fW9/cErudVSkyZNysrKio+P1+v1tzNajW5gGaWlpaWlpc7OztU+8o1CQ0OFEIcPHxZaHF3dunWbOnXq8ePHrbeBC44loM6jJ6Fu+e6770pLSy3P3ztw4EBRUdGECROCgoIszz6WrhIYGOjt7f3ll1/WWsj27ds3atRoz5491im7d+8uLCy89957b3/wSm71jbZs2bJ27doXXnihXbt2likzZsyo2mg1uoG217CEED/++KOqqt26dbv9kSv0008/CSEsV5E0ObrmzZsXEhKyd+9e6xSOJaCOoydBe4WFhdnZ2cXFxT///PPEiRMDAgJGjx4thLCcVfr666+vXbt2/Phx2xsavL2909PTT58+nZubq9Ppnn/++X//+98TJ048e/ZsaWlpbm6u5ZxBDTEYDNOmTdu4ceOaNWtycnIOHDjw1FNPtWjRYvz48bc/eDlbXY6cnJwnn3yyY8eOM2fOFEJcu3Ztz549+/btq+Q+LHM7SI1u4NmzZ9evX5+VlVVUVJScnDx27Fh/f/+nnnrq9ke+UUFBQWlpqaqq6enp8fHxs2fPbtKkyZQpU4RGR5fl6pv1DI3gWALqPi1vIoe9E5X4vlt8fHyvXr2aNm3q4ODQuHHj4cOHnzlzxjo3Li7O29vb09MzOjra8jiW4OBgyxemAgICXFxcunfvbvmC8TvvvBMaGmowGAwGwz333LN06dIFCxa4uLgIIdq0aXPy5Mk1a9Z4eXkJIXx9fSv8dtXSpUtdXV2t6y5fvtzDw0MIERAQYHlmQWlp6cKFC9u0aePo6Ojl5TVkyJCjR49a1rW+r5+fn+XB00uWLLGMFhgYuGPHjtdff91oNAohmjVrtnbt2vXr1zdr1kwI4eXltW7duptt9eTJky2Lubm5DR069O23327evLkQwtXVddCgQYsWLbrx/+5+/fpVch/Onj3bdrTyN7DCnVO+adOmBQcHu7m5OTg4+Pr6jhs3Lj09vcK1LCrzfbeNGzfe+GU3Z2fnNm3aTJgwITU11bpkzR1d1gxNmjSxfMfN1owZM2yfC8CxVLVjie+7oXYoKn+IBzVGURSz2Txs2DCtg8BOJCQkmEwmPrUghIiOjhZCJCYmah0Edo7rbgAAAHL0JDRER44cufEvM1jFxMRoHbC+YscCsDMOWgcANBASEsK1m5rAjgVgZzifBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5B60DwM4tXrw4MTFR6xSwE2lpaUKI6OhorYNAe99//33Xrl21TgH7p6iqqnUG2C1+nqHy0tPT9+zZM2jQIK2DoN7o1q3b1KlTtU4BO0dPAlAnJCQkmEwmPpEA1CncnwQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIEdPAgAAkKMnAQAAyNGTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQkAAECOngQAACBHTwIAAJCjJwEAAMjRkwAAAOToSQAAAHL0JAAAADl6EgAAgBw9CQAAQI6eBAAAIKeoqqp1BgAN0dmzZwcOHFhUVGR5mZeXd/HixcDAQOsCHTt2XL16tTbhAEAIIYSD1gEANFCtWrW6du3aL7/8Yjvx4MGD1n+bTKZaDwUAf8B1NwCaGTVqlIPDTX9boycB0BzX3QBoJjU1NTAw8MZPIUVR7rnnnp9++kmTVABgxfkkAJrx9/fv0qWLTlf2g0iv148aNUqTSABgi54EQEujRo1SFKXMxJKSkujoaE3yAIAtehIALQ0bNqzMFL1e37Nnz5YtW2qSBwBs0ZMAaMnHxyc8PFyv19tOHDlypFZ5AMAWPQmAxkaOHGl7K7dOpxs6dKiGeQDAip4EQGNDhw61Ph3AwcEhIiLC09NT20gAYEFPAqAxd3f3AQMGODo6CiFKSkpiY2O1TgQAv6MnAdDeiBEjiouLhRAGg2HAgAFaxwGA39GTAGivX79+rq6uQojIyEgXFxet4wDA7/j7bkC9l5aWtmvXLq1T3K4uXbr861//8vPzS0hI0DrL7brxYQcA6in+bglQ7yUkJPCn0OoUPlcBu8F1N8BOqPVTVFRUVFSUqqrFxcUvv/yy1nFul9ls1vpAAFCd6EkA6gS9Xv/Xv/5V6xQA8Af0JAB1hfUpSgBQR9CTAAAA5OhJAAAAcvQkAAAAOXoSAACAHD0JAABAjp4EAAAgR08CAACQoycBAADI0ZMAAADk6EkAAABy9CQAAAA5ehIAAIAcPQloiMaOHevu7q4oyr59+25/tDFjxhgMBkVRrl27dvuj3WjDhg1BQUGKDScnp6ZNm4aHhy9cuPDKlSs18aYAIOhJQMO0YsWKDz74oLpGi4+Pnz59enWNdqPIyMhTp04FBwcbjUZVVUtLSzMyMhISElq3bh0XF9euXbs9e/bU3LsDaMjoSQCqoqCgICwsTJO3VhTF09MzPDw8Pj4+ISHhwoUL/fv3z87O1iQMAPtGTwIaKEVRbmf1lStXZmRkVO+YVRAVFTV69OiMjIz33nuvlt8aQENATwIaClVVFy5c2LZtW2dnZ6PROGPGDNu5JSUlc+bM8ff3d3Fx6dChg9lstkzfsWPHXXfdZTQaDQZDaGjotm3bhBCTJ0+eNm3ayZMnFUW54447LEvqdLotW7ZEREQYjcYWLVqsWrWqdrZr9OjRQoitW7eWsyHLli1zc3NzdXXdtGlTRESEh4eHr6/vunXrrINs3779vvvuc3V19fDwCA0NzcnJKWefAGg46ElAQ/HCCy/ExcWNHz/+woUL58+fnzlzpu3cmTNn/u1vf1u8ePG5c+cGDhz42GOPWW76uXDhgslkOn36dHp6eqNGjUaMGCGEWLJkycCBA4ODg1VVPXHihGWE0tJST0/P9evXnz59ulOnThMmTMjPz6+F7erYsaMQ4tSpU+VsyIQJE6ZMmVJQUODu7m42m0+ePBkUFDRu3LiioiIhRF5e3qBBg6Kioi5fvnz8+PE777yzsLCwnH0CoOGgJwENQkFBweLFix966KGpU6d6enq6uLh4e3tb5167dm3ZsmVDhgyJjIz09PScPXu2o6NjfHy8ECIqKurFF1/08vLy9vYeNGhQZmbmxYsXb/YuYWFhRqPRy8srJibm+vXrv/76ay1smuWLe7m5ueVviDWhh4eHj49PTExMXl5eamqqEOL06dM5OTnt2rUzGAzNmjXbsGFDkyZNKhwKQENATwIahBMnTuTn5/fu3Vs69+jRo/n5+e3bt7e8dHFxad68+ZEjR8os5ujoKIQoKSmp8O0sS1rO1tS0vLw8VVU9PDxEpTdECOHk5GRNGBQU1LRp09jY2Llz554+fdqyQOWHAmDH6ElAg5CWliaE8PHxkc7Ny8sTQsyePdv6gKIzZ85Yrppt2bIlPDzcx8fH2dn5ueeeq83MlXTs2DEhREhIiCh3Q8rh4uLy7bffdu/e/dVXXw0KCoqJiSkoKKjaUADsDD0JaBAMBoMQ4vr169K5lv60ePFi1UZycnJqauqQIUOaN2++e/fu7OzsBQsW1Groyvniiy+EEBEREeLmG1LhIO3atdu8eXN6enpcXJzZbF60aFGVhwJgT+hJQIPQvn17nU63fft26Vw/Pz+DwXDjs7kPHDhQVFQ0YcKEoKAgyxO3az7prTl//vzixYt9fX0ff/xxcfMNKV96evrhw4eFED4+PvPnz+/UqdPhw4erNhQAO0NPAhoEHx+fyMjIpKSklStX5uTkpKSkLF++3DrXYDCMGTNm3bp1y/6/nTtWaSuKAzh8akRIcDBxE0kGcXUU0TxGQl7Awdklg+DgM2gHZxfjIs7u4qIICqIIUUIcxMU4qKinQ2gp9NSClaaR75vPPfzvvQR+kMP9+vXu7u7l5aXVal1fXxeLxRDC7u7uw8PD+fn5/v7+j0sKhUK73W42m51O59+cQwohxBjv7+9fX19jjDc3N5ubm3Nzc5lMZnt7u3s+6Xc38va27XZ7YWHh9PT06enp8PDw8vJyZmbmfVsBn00E+lz3uz5/XNbpdObn50dHR4eHh8vl8vLycghhfHz86Ogoxvj4+Fiv14vF4uDgYDeqTk5OYoz1er1QKIyMjFSr1dXV1RDCxMTE1dXVwcFBqVTKZrPlcnlxcTGbzYYQJicnLy4uNjY28vl8d/Pj4+O3p6pUKpVK5e01Ozs7U1NTuVxuaGhoYGAgfP8k9/T09MrKyu3t7c+LkzeytraWy+V+TLi+vt7tqlKpdHZ21mw2Z2dn8/l8JpMZGxtbWlp6fn5+45n8/bsA+sWXGGPPGg34CI1Go1ar9elvuVqthhC2trZ6PcjH6Ot3AfzK/24AAGk6CQAgTScBAKTpJACANJ0EAJCmkwAA0nQSAECaTgIASNNJAABpOgkAIE0nAQCk6SQAgDSdBACQppMAANJ0EgBAmk4CAEjTSQAAaYO9HgD4GI1Go9cjvEer1Qp9O/yv9vb2ej0C8JF0EnwStVqt1yO8X18PD3xiX2KMvZ4BAOB/5HwSAECaTgIASNNJAABpOgkAIO0bpsGnFKBQ9zEAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<IPython.core.display.Image object>"
            ]
          },
          "metadata": {},
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "history_lstm_re = model4.fit(death_train_loader,validation_data=death_test_loader,epochs=500,callbacks=callback,batch_size=64)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4txryKSswht1",
        "outputId": "c6b4fbf3-ffc9-4ef1-ffb5-36579cb169f4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/500\n",
            "455/455 [==============================] - 13s 17ms/step - loss: 0.4057 - auc: 0.7064 - val_loss: 0.3591 - val_auc: 0.7717\n",
            "Epoch 2/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3638 - auc: 0.7666 - val_loss: 0.3540 - val_auc: 0.7798\n",
            "Epoch 3/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3584 - auc: 0.7755 - val_loss: 0.3587 - val_auc: 0.7818\n",
            "Epoch 4/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3555 - auc: 0.7820 - val_loss: 0.3637 - val_auc: 0.7641\n",
            "Epoch 5/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3530 - auc: 0.7846 - val_loss: 0.3534 - val_auc: 0.7874\n",
            "Epoch 6/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3511 - auc: 0.7896 - val_loss: 0.3449 - val_auc: 0.7923\n",
            "Epoch 7/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3500 - auc: 0.7902 - val_loss: 0.3495 - val_auc: 0.7896\n",
            "Epoch 8/500\n",
            "455/455 [==============================] - 6s 14ms/step - loss: 0.3476 - auc: 0.7928 - val_loss: 0.3480 - val_auc: 0.7906\n",
            "Epoch 9/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3463 - auc: 0.7962 - val_loss: 0.3434 - val_auc: 0.7961\n",
            "Epoch 10/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3439 - auc: 0.7994 - val_loss: 0.3565 - val_auc: 0.7733\n",
            "Epoch 11/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3425 - auc: 0.8015 - val_loss: 0.3507 - val_auc: 0.7899\n",
            "Epoch 12/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3418 - auc: 0.8033 - val_loss: 0.3470 - val_auc: 0.7902\n",
            "Epoch 13/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3402 - auc: 0.8035 - val_loss: 0.3546 - val_auc: 0.7851\n",
            "Epoch 14/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3397 - auc: 0.8056 - val_loss: 0.3483 - val_auc: 0.7898\n",
            "Epoch 15/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3380 - auc: 0.8077 - val_loss: 0.3503 - val_auc: 0.7789\n",
            "Epoch 16/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3372 - auc: 0.8076 - val_loss: 0.3458 - val_auc: 0.7992\n",
            "Epoch 17/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3352 - auc: 0.8105 - val_loss: 0.3520 - val_auc: 0.7834\n",
            "Epoch 18/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3326 - auc: 0.8141 - val_loss: 0.3578 - val_auc: 0.7855\n",
            "Epoch 19/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3321 - auc: 0.8148 - val_loss: 0.3501 - val_auc: 0.7901\n",
            "Epoch 20/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3312 - auc: 0.8169 - val_loss: 0.3717 - val_auc: 0.7766\n",
            "Epoch 21/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3298 - auc: 0.8194 - val_loss: 0.3542 - val_auc: 0.7916\n",
            "Epoch 22/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3280 - auc: 0.8194 - val_loss: 0.3413 - val_auc: 0.8020\n",
            "Epoch 23/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3260 - auc: 0.8229 - val_loss: 0.3508 - val_auc: 0.7854\n",
            "Epoch 24/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3249 - auc: 0.8241 - val_loss: 0.3516 - val_auc: 0.7887\n",
            "Epoch 25/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3229 - auc: 0.8263 - val_loss: 0.3713 - val_auc: 0.7664\n",
            "Epoch 26/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3196 - auc: 0.8297 - val_loss: 0.3528 - val_auc: 0.7902\n",
            "Epoch 27/500\n",
            "455/455 [==============================] - 6s 14ms/step - loss: 0.3192 - auc: 0.8312 - val_loss: 0.3595 - val_auc: 0.7824\n",
            "Epoch 28/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3171 - auc: 0.8328 - val_loss: 0.3528 - val_auc: 0.7869\n",
            "Epoch 29/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3156 - auc: 0.8341 - val_loss: 0.3543 - val_auc: 0.7939\n",
            "Epoch 30/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3130 - auc: 0.8373 - val_loss: 0.3557 - val_auc: 0.7831\n",
            "Epoch 31/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3127 - auc: 0.8383 - val_loss: 0.3664 - val_auc: 0.7942\n",
            "Epoch 32/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3119 - auc: 0.8394 - val_loss: 0.3586 - val_auc: 0.7897\n",
            "Epoch 33/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3090 - auc: 0.8435 - val_loss: 0.3662 - val_auc: 0.7723\n",
            "Epoch 34/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.3060 - auc: 0.8447 - val_loss: 0.3658 - val_auc: 0.7745\n",
            "Epoch 35/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3041 - auc: 0.8456 - val_loss: 0.3714 - val_auc: 0.7689\n",
            "Epoch 36/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.3022 - auc: 0.8481 - val_loss: 0.3695 - val_auc: 0.7728\n",
            "Epoch 37/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.2987 - auc: 0.8530 - val_loss: 0.3799 - val_auc: 0.7688\n",
            "Epoch 38/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.2956 - auc: 0.8557 - val_loss: 0.3702 - val_auc: 0.7659\n",
            "Epoch 39/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.2969 - auc: 0.8555 - val_loss: 0.3845 - val_auc: 0.7646\n",
            "Epoch 40/500\n",
            "455/455 [==============================] - 7s 15ms/step - loss: 0.2908 - auc: 0.8611 - val_loss: 0.3888 - val_auc: 0.7536\n",
            "Epoch 41/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.2881 - auc: 0.8653 - val_loss: 0.3786 - val_auc: 0.7656\n",
            "Epoch 42/500\n",
            "455/455 [==============================] - 7s 14ms/step - loss: 0.2865 - auc: 0.8651 - val_loss: 0.3927 - val_auc: 0.7570\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from matplotlib import pyplot as plt\n",
        "plt.plot(history_lstm_re.history['auc'])\n",
        "plt.plot(history_lstm_re.history['val_auc'])\n",
        "plt.title('model auc')\n",
        "plt.ylabel('auc')\n",
        "plt.xlabel('epoch')\n",
        "plt.legend(['train', 'val'], loc='lower left',bbox_to_anchor=(1, 0))\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "LTt2vZO8NisT",
        "outputId": "5072016d-0b2c-4081-f94b-5330c53ec631"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 바로 사망 예측 모델"
      ],
      "metadata": {
        "id": "yiy4XVO6ZoYg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# ## 사망예측 모델\n",
        "# model1 = keras.Sequential([\n",
        "#    layers.LSTM(16, input_shape=(13,16)),\n",
        "#    layers.Dense(7, activation='relu')\n",
        "# ])\n",
        "\n",
        "# model2 = keras.Sequential([\n",
        "#    layers.Dense(16, activation='relu',input_shape=[2])\n",
        "# ])\n",
        "\n",
        "# # death_lstm = layers.concatenate([model1, model2])\n",
        "# # death_lstm = layers.Dense(1, activation=\"sigmoid\")(death_lstm)\n",
        "\n",
        "# # death_lstm = keras.Sequential()\n",
        "# # death_lstm.add(layers.Merge([model1, model2], mode='concat', concat_axis=-1))\n",
        "\n",
        "# # death_lstm = keras.Sequential()\n",
        "# # death_lstm.add()([model1, model2])\n",
        "\n",
        "# death_lstm = keras.Sequential(\n",
        "#    layers.Concatenate([model1, model2]),\n",
        "#    layers.Dense(1, activation='sigmoid')\n",
        "# )\n",
        "# # merge_f = layers.Concatenate(axis=-1)([rnn_f,demographic_dropout])\n",
        "# death_lstm.summary()\n",
        "\n",
        "# def lstm_model(tem_train, dem_train):\n",
        "#     temporal_input_layer = Input(shape=(13 , 16))\n",
        "#     main_rnn_layer = layers.LSTM(64, return_sequences=True)(temporal_input_layer) #recurrent_dropout=0.2\n",
        "#     rnn_f = layers.LSTM(32)(main_rnn_layer)\n",
        "\n",
        "#     demographic_input_layer = Input(shape=(2))\n",
        "#     demographic_dense = layers.Dense(16)(demographic_input_layer)\n",
        "#     demographic_dropout = layers.Dropout(0.2)(demographic_dense)\n",
        "\n",
        "#     #fatality output branch\n",
        "#     merge_f = layers.Concatenate(axis=-1)([rnn_f,demographic_dropout])\n",
        "#     dense_f = layers.Dense(128)(merge_f)\n",
        "#     dropout_f = layers.Dropout(0.2)(dense_f)\n",
        "#     output = layers.Dense(1, activation='sigmoid', name=\"output\")(dropout_f)\n",
        "\n",
        "#     model = keras.Model([temporal_input_layer,demographic_input_layer], output)\n",
        "\n",
        "#     model.summary()\n",
        "#     return model\n",
        "\n",
        "# ## 사망예측 모델\n",
        "# model1 = keras.Sequential([\n",
        "#    layers.LSTM(16, input_shape=(13,16)),\n",
        "#    layers.Dense(7, activation='relu')\n",
        "# ])\n",
        "\n",
        "# model2 = keras.Sequential([\n",
        "#    layers.Dense(16, activation='relu',input_shape=[2])\n",
        "# ])\n",
        "\n",
        "# # death_lstm = layers.concatenate([model1, model2])\n",
        "# # death_lstm = layers.Dense(1, activation=\"sigmoid\")(death_lstm)\n",
        "\n",
        "# # death_lstm = keras.Sequential()\n",
        "# # death_lstm.add(layers.Merge([model1, model2], mode='concat', concat_axis=-1))\n",
        "\n",
        "# # death_lstm = keras.Sequential()\n",
        "# # death_lstm.add()([model1, model2])\n",
        "\n",
        "# death_lstm = keras.Sequential(\n",
        "#    layers.Concatenate([model1, model2]),\n",
        "#    layers.Dense(1, activation='sigmoid')\n",
        "# )\n",
        "# # merge_f = layers.Concatenate(axis=-1)([rnn_f,demographic_dropout])\n",
        "# death_lstm.summary()"
      ],
      "metadata": {
        "id": "qZXSUUef6lT2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "## 사망예측 모델\n",
        "#death_lstm = keras.Sequential([\n",
        "#    layers.LSTM(25, input_shape=(13,16)),\n",
        "#    layers.Dense(125, activation='relu'),\n",
        "#    layers.Dense(1, activation='sigmoid')\n",
        "#])\n",
        "#death_lstm.summary()\n",
        "\n",
        "## 사망예측 모델\n",
        "#death_lstm = keras.Sequential([\n",
        "#    layers.LSTM(25, input_shape=(13,16)),\n",
        "#    layers.Dense(125),\n",
        "#    layers.BatchNormalization(),\n",
        "#    layers.Activation('relu'),\n",
        "#    layers.Dropout(0.2),\n",
        "#    #batch normalization, dropout,optimizer deat\n",
        "#    layers.Dense(1, activation='sigmoid')\n",
        "#])\n",
        "#death_lstm.summary()\n",
        "\n",
        "# ## 사망예측 모델\n",
        "# death_lstm_re = keras.Sequential([\n",
        "#     layers.LSTM(64, input_shape=(13,27), return_sequences=True),\n",
        "#     layers.LSTM(64),\n",
        "#     layers.Dense(32),\n",
        "#     layers.BatchNormalization(),\n",
        "#     layers.Activation('tanh'),\n",
        "#     layers.Dropout(0.1),\n",
        "#     layers.Dense(1, activation='sigmoid')\n",
        "# ])\n",
        "# death_lstm_re.summary()\n",
        "\n",
        "# ## 사망예측 모델\n",
        "# death_lstm_re = keras.Sequential([\n",
        "#     layers.LSTM(16, input_shape=(13,27), return_sequences=True),\n",
        "#     layers.LSTM(16, return_sequences=True),\n",
        "#     layers.LSTM(16, return_sequences=True),\n",
        "#     layers.LSTM(16),\n",
        "#     layers.Dense(16),\n",
        "#     layers.BatchNormalization(),\n",
        "#     layers.Activation('tanh'),\n",
        "#     layers.Dropout(0.1),\n",
        "#     #batch normalization, dropout,optimizer deat\n",
        "#     layers.Dense(1, activation='sigmoid')\n",
        "# ])\n",
        "# death_lstm_re.summary()\n",
        "\n",
        "# ## 사망예측 모델\n",
        "# death_lstm_re = keras.Sequential([\n",
        "#     layers.LSTM(256, input_shape=(13,16), return_sequences=True),\n",
        "#     layers.LSTM(256),\n",
        "#     layers.Dense(128),\n",
        "#     layers.BatchNormalization(),\n",
        "#     layers.Activation('relu'),\n",
        "#     layers.Dropout(0.2),\n",
        "#     layers.Dense(128),  \n",
        "#     layers.BatchNormalization(),\n",
        "#     layers.Activation('relu'),\n",
        "#     layers.Dropout(0.2),\n",
        "#     #batch normalization, dropout,optimizer deat\n",
        "#     layers.Dense(1, activation='sigmoid')\n",
        "# ])\n",
        "# death_lstm_re.summary()\n",
        "\n",
        "## 사망예측 모델\n",
        "#death_lstm_re = keras.Sequential([\n",
        "#    layers.LSTM(256, input_shape=(13,16), return_sequences=True),\n",
        "#    layers.LSTM(256, return_sequences=True),\n",
        "#    layers.LSTM(256),\n",
        "#    layers.Dense(128),\n",
        "#    layers.BatchNormalization(),\n",
        "#    layers.Activation('relu'),\n",
        "#    layers.Dropout(0.1),\n",
        "#    layers.Dense(128),\n",
        "#    layers.BatchNormalization(),\n",
        "#    layers.Activation('relu'),\n",
        "#    layers.Dropout(0.1),\n",
        "#    #batch normalization, dropout,optimizer deat\n",
        "#    layers.Dense(1, activation='sigmoid')\n",
        "#])\n",
        "#death_lstm_re.summary()\n",
        "\n",
        "## 사망예측 모델 학습\n",
        "# #death_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "# #keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)\n",
        "# adam = keras.optimizers.Adam(learning_rate=0.01, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-6, amsgrad=False)\n",
        "# #adam = keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-6, amsgrad=False)\n",
        "# #adam = keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-5, amsgrad=False)\n",
        "# #adam = keras.optimizers.Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=1e-4, amsgrad=False)\n",
        "\n",
        "# death_lstm_re.compile(loss='binary_crossentropy', optimizer=adam, metrics=['AUC'])\n",
        "\n",
        "# #num_epochs = 100\n",
        "# num_epochs = 70 \n",
        "# #num_epochs = 200\n",
        "# # history = death_lstm_re.fit(death_train_loader, validation_data=death_test_loader, epochs=num_epochs, verbose=2, validation_split=0.1)\n",
        "# history = death_lstm_re.fit(death_train_loader, validation_data=death_test_loader, epochs=num_epochs, verbose=2, validation_split=0.1)"
      ],
      "metadata": {
        "id": "9XPIB81hIQRU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 약제별 분석 사망자 예측"
      ],
      "metadata": {
        "id": "zQ-RYaQS6GOr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "cepha_dataset = dict({\n",
        "    'HADM_IDS': list(),\n",
        "    'LABEL': list(),\n",
        "    'DATA': list()\n",
        "})\n",
        "\n",
        "glyco_dataset = dict({\n",
        "    'HADM_IDS': list(),\n",
        "    'LABEL': list(),\n",
        "    'DATA': list()\n",
        "})\n",
        "\n",
        "peni_dataset = dict({\n",
        "    'HADM_IDS': list(),\n",
        "    'LABEL': list(),\n",
        "    'DATA': list()\n",
        "})\n",
        "\n",
        "fluoro_dataset = dict({\n",
        "    'HADM_IDS': list(),\n",
        "    'LABEL': list(),\n",
        "    'DATA': list()\n",
        "})\n",
        "\n",
        "macro_dataset = dict({\n",
        "    'HADM_IDS': list(),\n",
        "    'LABEL': list(),\n",
        "    'DATA': list()\n",
        "})\n",
        "list_glyco=[]\n",
        "for i in id_glyco['hadm_id']:\n",
        "  list_glyco.append(i)\n",
        "\n",
        "list_cepha=[]\n",
        "for i in id_cepha['hadm_id']:\n",
        "  list_cepha.append(i)\n",
        "\n",
        "list_peni=[]\n",
        "for i in id_peni['hadm_id']:\n",
        "  list_peni.append(i)\n",
        "\n",
        "list_fluoro=[]\n",
        "for i in id_fluoro['hadm_id']:\n",
        "  list_fluoro.append(i)\n",
        "\n",
        "list_macro=[]\n",
        "for i in id_macro['hadm_id']:\n",
        "  list_macro.append(i)\n",
        "\n",
        "for i in tqdm(range(len(death_dataset['HADM_IDS'])), desc='Make Glycopeptides Dataset', ncols = 700):\n",
        "  if (death_dataset['HADM_IDS'][i] in list_glyco) == True:\n",
        "      glyco_dataset['HADM_IDS'].append(death_dataset['HADM_IDS'][i])\n",
        "      glyco_dataset['LABEL'].append(death_dataset['LABEL'][i])\n",
        "      glyco_dataset['DATA'].append(death_dataset['DATA'][i])\n",
        "\n",
        "for i in tqdm(range(len(death_dataset['HADM_IDS'])), desc='Make Cephalosporins Dataset', ncols = 700):\n",
        "  if (death_dataset['HADM_IDS'][i] in list_cepha) == True:\n",
        "      cepha_dataset['HADM_IDS'].append(death_dataset['HADM_IDS'][i])\n",
        "      cepha_dataset['LABEL'].append(death_dataset['LABEL'][i])\n",
        "      cepha_dataset['DATA'].append(death_dataset['DATA'][i])\n",
        "\n",
        "for i in tqdm(range(len(death_dataset['HADM_IDS'])), desc='Make Penicillins Dataset', ncols = 700):\n",
        "  if (death_dataset['HADM_IDS'][i] in list_peni) == True:\n",
        "      peni_dataset['HADM_IDS'].append(death_dataset['HADM_IDS'][i])\n",
        "      peni_dataset['LABEL'].append(death_dataset['LABEL'][i])\n",
        "      peni_dataset['DATA'].append(death_dataset['DATA'][i])\n",
        "\n",
        "for i in tqdm(range(len(death_dataset['HADM_IDS'])), desc='Make Fluoroquinolones Dataset', ncols = 700):\n",
        "  if (death_dataset['HADM_IDS'][i] in list_fluoro) == True:\n",
        "      fluoro_dataset['HADM_IDS'].append(death_dataset['HADM_IDS'][i])\n",
        "      fluoro_dataset['LABEL'].append(death_dataset['LABEL'][i])\n",
        "      fluoro_dataset['DATA'].append(death_dataset['DATA'][i])\n",
        "\n",
        "for i in tqdm(range(len(death_dataset['HADM_IDS'])), desc='Make Macrolides Dataset', ncols = 700):\n",
        "  if (death_dataset['HADM_IDS'][i] in list_macro) == True:\n",
        "      macro_dataset['HADM_IDS'].append(death_dataset['HADM_IDS'][i])\n",
        "      macro_dataset['LABEL'].append(death_dataset['LABEL'][i])\n",
        "      macro_dataset['DATA'].append(death_dataset['DATA'][i])\n",
        "\n",
        "print(len(glyco_dataset['HADM_IDS']))\n",
        "print(len(cepha_dataset['HADM_IDS']))\n",
        "print(len(peni_dataset['HADM_IDS']))\n",
        "print(len(fluoro_dataset['HADM_IDS']))\n",
        "print(len(macro_dataset['HADM_IDS']))"
      ],
      "metadata": {
        "id": "xRlqLTdh6C2x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_lstm = keras.Sequential([\n",
        "    layers.LSTM(25, input_shape=(13,16)),\n",
        "    layers.Dense(125, activation='relu'),\n",
        "    layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "cepha_lstm = keras.Sequential([\n",
        "    layers.LSTM(25, input_shape=(13,16)),\n",
        "    layers.Dense(125, activation='relu'),\n",
        "    layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "peni_lstm = keras.Sequential([\n",
        "    layers.LSTM(25, input_shape=(13,16)),\n",
        "    layers.Dense(125, activation='relu'),\n",
        "    layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "fluoro_lstm = keras.Sequential([\n",
        "    layers.LSTM(25, input_shape=(13,16)),\n",
        "    layers.Dense(125, activation='relu'),\n",
        "    layers.Dense(1, activation='sigmoid')\n",
        "])\n",
        "\n",
        "macro_lstm = keras.Sequential([\n",
        "    layers.LSTM(25, input_shape=(13,16)),\n",
        "    layers.Dense(125, activation='relu'),\n",
        "    layers.Dense(1, activation='sigmoid')\n",
        "])"
      ],
      "metadata": {
        "id": "tbVJEpm5JBkW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title 약제별 분석\n",
        "\n",
        "\n",
        "glyco_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "num_epochs = 100\n",
        "history = glyco_lstm.fit(glyco_train_loader, validation_data=glyco_test_loader, epochs=num_epochs, verbose=2)\n",
        "\n",
        "\n",
        "cepha_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "num_epochs = 100\n",
        "history = cepha_lstm.fit(cepha_train_loader, validation_data=cepha_test_loader, epochs=num_epochs, verbose=2)\n",
        "\n",
        "\n",
        "peni_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "num_epochs = 100\n",
        "history = peni_lstm.fit(peni_train_loader, validation_data=peni_test_loader, epochs=num_epochs, verbose=2)\n",
        "\n",
        "fluoro_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "num_epochs = 100\n",
        "history = fluoro_lstm.fit(fluoro_train_loader, validation_data=fluoro_test_loader, epochs=num_epochs, verbose=2)\n",
        "\n",
        "macro_lstm.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n",
        "num_epochs = 100\n",
        "history = macro_lstm.fit(macro_train_loader, validation_data=macro_test_loader, epochs=num_epochs, verbose=2)"
      ],
      "metadata": {
        "id": "lVk2_qOiSNvq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_lstm.save('/content/gdrive/MyDrive/sepsis_model_weight/model_glyco.h5')\n",
        "cepha_lstm.save('/content/gdrive/MyDrive/sepsis_model_weight/model_cepha.h5')\n",
        "peni_lstm.save('/content/gdrive/MyDrive/sepsis_model_weight/model_peni.h5')\n",
        "fluoro_lstm.save('/content/gdrive/MyDrive/sepsis_model_weight/model_fluoro.h5')\n",
        "macro_lstm.save('/content/gdrive/MyDrive/sepsis_model_weight/model_macro.h5')"
      ],
      "metadata": {
        "id": "ruT8Z7iSN4Dg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_label=pd.DataFrame(glyco_test['LABEL'])\n",
        "\n",
        "death_predict=pd.DataFrame(death_lstm.predict(glyco_test_loader))\n",
        "glyco_predict=pd.DataFrame(glyco_lstm.predict(glyco_test_loader))\n",
        "cepha_predict=pd.DataFrame(cepha_lstm.predict(glyco_test_loader))\n",
        "peni_predict=pd.DataFrame(peni_lstm.predict(glyco_test_loader))\n",
        "fluoro_predict=pd.DataFrame(fluoro_lstm.predict(glyco_test_loader))\n",
        "macro_predict=pd.DataFrame(macro_lstm.predict(glyco_test_loader))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_UMxzcetOvVi",
        "outputId": "425023c3-bf63-4de3-a03b-1f2f303a69dd"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19/19 [==============================] - 0s 4ms/step\n",
            "19/19 [==============================] - 0s 4ms/step\n",
            "19/19 [==============================] - 0s 4ms/step\n",
            "19/19 [==============================] - 0s 4ms/step\n",
            "19/19 [==============================] - 0s 3ms/step\n",
            "19/19 [==============================] - 0s 4ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_total=pd.concat([glyco_label,death_predict,glyco_predict,cepha_predict,peni_predict,fluoro_predict,macro_predict],axis=1)\n",
        "glyco_total.columns=['label','death_model','glyco_model','cepha_model','peni_model','fluoro_model','macro_model']"
      ],
      "metadata": {
        "id": "LF8Mrk2rVCmU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_total"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "7O0m9XqOPFNS",
        "outputId": "92fbe5ee-85ed-4002-f8eb-14cab220803f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "      label  death_model  glyco_model  cepha_model  peni_model  fluoro_model  \\\n",
              "0         1     0.014108     0.223974     0.092540    0.349622      0.311748   \n",
              "1         1     0.485061     0.470382     0.522545    0.205113      0.142648   \n",
              "2         1     0.356203     0.426065     0.678691    0.231644      0.217998   \n",
              "3         1     0.195743     0.163080     0.122726    0.144958      0.110240   \n",
              "4         1     0.193229     0.137318     0.205912    0.104218      0.109623   \n",
              "...     ...          ...          ...          ...         ...           ...   \n",
              "2347      0     0.157966     0.136068     0.127145    0.076348      0.094608   \n",
              "2348      0     0.152380     0.152679     0.114211    0.131388      0.103832   \n",
              "2349      0     0.262742     0.167690     0.180576    0.158227      0.145779   \n",
              "2350      0     0.186726     0.192592     0.222549    0.164990      0.206763   \n",
              "2351      0     0.195743     0.163080     0.122726    0.144958      0.110240   \n",
              "\n",
              "      macro_model  \n",
              "0        0.180778  \n",
              "1        0.128929  \n",
              "2        0.113417  \n",
              "3        0.103486  \n",
              "4        0.064443  \n",
              "...           ...  \n",
              "2347     0.062250  \n",
              "2348     0.099097  \n",
              "2349     0.119568  \n",
              "2350     0.104039  \n",
              "2351     0.103486  \n",
              "\n",
              "[2352 rows x 7 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-8fc051e9-8a5a-4f5e-8bb8-d186cdf92a25\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>death_model</th>\n",
              "      <th>glyco_model</th>\n",
              "      <th>cepha_model</th>\n",
              "      <th>peni_model</th>\n",
              "      <th>fluoro_model</th>\n",
              "      <th>macro_model</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>0.014108</td>\n",
              "      <td>0.223974</td>\n",
              "      <td>0.092540</td>\n",
              "      <td>0.349622</td>\n",
              "      <td>0.311748</td>\n",
              "      <td>0.180778</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0.485061</td>\n",
              "      <td>0.470382</td>\n",
              "      <td>0.522545</td>\n",
              "      <td>0.205113</td>\n",
              "      <td>0.142648</td>\n",
              "      <td>0.128929</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>0.356203</td>\n",
              "      <td>0.426065</td>\n",
              "      <td>0.678691</td>\n",
              "      <td>0.231644</td>\n",
              "      <td>0.217998</td>\n",
              "      <td>0.113417</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.110240</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1</td>\n",
              "      <td>0.193229</td>\n",
              "      <td>0.137318</td>\n",
              "      <td>0.205912</td>\n",
              "      <td>0.104218</td>\n",
              "      <td>0.109623</td>\n",
              "      <td>0.064443</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2347</th>\n",
              "      <td>0</td>\n",
              "      <td>0.157966</td>\n",
              "      <td>0.136068</td>\n",
              "      <td>0.127145</td>\n",
              "      <td>0.076348</td>\n",
              "      <td>0.094608</td>\n",
              "      <td>0.062250</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2348</th>\n",
              "      <td>0</td>\n",
              "      <td>0.152380</td>\n",
              "      <td>0.152679</td>\n",
              "      <td>0.114211</td>\n",
              "      <td>0.131388</td>\n",
              "      <td>0.103832</td>\n",
              "      <td>0.099097</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2349</th>\n",
              "      <td>0</td>\n",
              "      <td>0.262742</td>\n",
              "      <td>0.167690</td>\n",
              "      <td>0.180576</td>\n",
              "      <td>0.158227</td>\n",
              "      <td>0.145779</td>\n",
              "      <td>0.119568</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2350</th>\n",
              "      <td>0</td>\n",
              "      <td>0.186726</td>\n",
              "      <td>0.192592</td>\n",
              "      <td>0.222549</td>\n",
              "      <td>0.164990</td>\n",
              "      <td>0.206763</td>\n",
              "      <td>0.104039</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2351</th>\n",
              "      <td>0</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.110240</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>2352 rows × 7 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8fc051e9-8a5a-4f5e-8bb8-d186cdf92a25')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-8fc051e9-8a5a-4f5e-8bb8-d186cdf92a25 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-8fc051e9-8a5a-4f5e-8bb8-d186cdf92a25');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_total.to_csv('glyco_total.csv')"
      ],
      "metadata": {
        "id": "HjfziTwyQv4L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "glyco_total.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "UEbvszS1c_AG",
        "outputId": "3a3bd87d-bfc6-467d-8ca1-72a9c50faea7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "             label  death_model  glyco_model  cepha_model   peni_model  \\\n",
              "count  2352.000000  2352.000000  2352.000000  2352.000000  2352.000000   \n",
              "mean      0.215986     0.196350     0.214887     0.186830     0.198750   \n",
              "std       0.411592     0.170452     0.158309     0.153455     0.152484   \n",
              "min       0.000000     0.001662     0.015854     0.000040     0.003022   \n",
              "25%       0.000000     0.106631     0.149175     0.122726     0.139193   \n",
              "50%       0.000000     0.164574     0.163080     0.135749     0.144958   \n",
              "75%       0.000000     0.195743     0.181829     0.198761     0.177399   \n",
              "max       1.000000     0.999955     0.999038     0.994983     0.988274   \n",
              "\n",
              "       fluoro_model  macro_model  \n",
              "count   2352.000000  2352.000000  \n",
              "mean       0.176921     0.142387  \n",
              "std        0.155931     0.126896  \n",
              "min        0.043336     0.002842  \n",
              "25%        0.108697     0.096551  \n",
              "50%        0.112443     0.103486  \n",
              "75%        0.180022     0.125479  \n",
              "max        0.999859     0.991618  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-1b54843d-56f8-48b1-9f93-faee84152d07\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>death_model</th>\n",
              "      <th>glyco_model</th>\n",
              "      <th>cepha_model</th>\n",
              "      <th>peni_model</th>\n",
              "      <th>fluoro_model</th>\n",
              "      <th>macro_model</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>2352.000000</td>\n",
              "      <td>2352.000000</td>\n",
              "      <td>2352.000000</td>\n",
              "      <td>2352.000000</td>\n",
              "      <td>2352.000000</td>\n",
              "      <td>2352.000000</td>\n",
              "      <td>2352.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>0.215986</td>\n",
              "      <td>0.196350</td>\n",
              "      <td>0.214887</td>\n",
              "      <td>0.186830</td>\n",
              "      <td>0.198750</td>\n",
              "      <td>0.176921</td>\n",
              "      <td>0.142387</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>0.411592</td>\n",
              "      <td>0.170452</td>\n",
              "      <td>0.158309</td>\n",
              "      <td>0.153455</td>\n",
              "      <td>0.152484</td>\n",
              "      <td>0.155931</td>\n",
              "      <td>0.126896</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.001662</td>\n",
              "      <td>0.015854</td>\n",
              "      <td>0.000040</td>\n",
              "      <td>0.003022</td>\n",
              "      <td>0.043336</td>\n",
              "      <td>0.002842</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.106631</td>\n",
              "      <td>0.149175</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.139193</td>\n",
              "      <td>0.108697</td>\n",
              "      <td>0.096551</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.164574</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.135749</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.112443</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.181829</td>\n",
              "      <td>0.198761</td>\n",
              "      <td>0.177399</td>\n",
              "      <td>0.180022</td>\n",
              "      <td>0.125479</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.999955</td>\n",
              "      <td>0.999038</td>\n",
              "      <td>0.994983</td>\n",
              "      <td>0.988274</td>\n",
              "      <td>0.999859</td>\n",
              "      <td>0.991618</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-1b54843d-56f8-48b1-9f93-faee84152d07')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-1b54843d-56f8-48b1-9f93-faee84152d07 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-1b54843d-56f8-48b1-9f93-faee84152d07');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cepha_label=pd.DataFrame(cepha_test['LABEL'])\n",
        "\n",
        "death_predict=pd.DataFrame(death_lstm.predict(cepha_test_loader))\n",
        "glyco_predict=pd.DataFrame(glyco_lstm.predict(cepha_test_loader))\n",
        "cepha_predict=pd.DataFrame(cepha_lstm.predict(cepha_test_loader))\n",
        "peni_predict=pd.DataFrame(peni_lstm.predict(cepha_test_loader))\n",
        "fluoro_predict=pd.DataFrame(fluoro_lstm.predict(cepha_test_loader))\n",
        "macro_predict=pd.DataFrame(macro_lstm.predict(cepha_test_loader))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ao_qiRBFcAHR",
        "outputId": "b814daec-a1f4-407b-bf2c-4ff3dea3d03a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "18/18 [==============================] - 0s 4ms/step\n",
            "18/18 [==============================] - 0s 3ms/step\n",
            "18/18 [==============================] - 0s 3ms/step\n",
            "18/18 [==============================] - 0s 4ms/step\n",
            "18/18 [==============================] - 0s 3ms/step\n",
            "18/18 [==============================] - 0s 4ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cepha_total=pd.concat([cepha_label,death_predict,glyco_predict,cepha_predict,peni_predict,fluoro_predict,macro_predict],axis=1)\n",
        "cepha_total.columns=['label','death_model','glyco_model','cepha_model','peni_model','fluoro_model','macro_model']"
      ],
      "metadata": {
        "id": "82y7lKLXcJqt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "cepha_total"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        },
        "id": "5ewxY3jEcdBt",
        "outputId": "a2ef83d7-f2c1-442b-f27e-9794d6ed3dae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "      label  death_model  glyco_model  cepha_model  peni_model  fluoro_model  \\\n",
              "0         1     0.236570     0.148248     0.279651    0.132168      0.122248   \n",
              "1         1     0.410458     0.297525     0.233613    0.239752      0.316624   \n",
              "2         1     0.999856     0.895030     0.984093    0.980664      0.999827   \n",
              "3         1     0.195743     0.163080     0.122726    0.144958      0.110240   \n",
              "4         1     0.237204     0.201668     0.251227    0.167174      0.294863   \n",
              "...     ...          ...          ...          ...         ...           ...   \n",
              "2187      0     0.077487     0.146791     0.097477    0.153996      0.095492   \n",
              "2188      0     0.263328     0.408858     0.108774    0.162515      0.205582   \n",
              "2189      0     0.195743     0.163080     0.122726    0.144958      0.110240   \n",
              "2190      0     0.195743     0.163080     0.122726    0.144958      0.110240   \n",
              "2191      0     0.015855     0.146331     0.036363    0.114590      0.101359   \n",
              "\n",
              "      macro_model  \n",
              "0        0.086393  \n",
              "1        0.117778  \n",
              "2        0.656816  \n",
              "3        0.103486  \n",
              "4        0.145911  \n",
              "...           ...  \n",
              "2187     0.111025  \n",
              "2188     0.099497  \n",
              "2189     0.103486  \n",
              "2190     0.103486  \n",
              "2191     0.072932  \n",
              "\n",
              "[2192 rows x 7 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-95d59a96-4be6-47ec-a6b0-b4f8b1c5158e\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>death_model</th>\n",
              "      <th>glyco_model</th>\n",
              "      <th>cepha_model</th>\n",
              "      <th>peni_model</th>\n",
              "      <th>fluoro_model</th>\n",
              "      <th>macro_model</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1</td>\n",
              "      <td>0.236570</td>\n",
              "      <td>0.148248</td>\n",
              "      <td>0.279651</td>\n",
              "      <td>0.132168</td>\n",
              "      <td>0.122248</td>\n",
              "      <td>0.086393</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>0.410458</td>\n",
              "      <td>0.297525</td>\n",
              "      <td>0.233613</td>\n",
              "      <td>0.239752</td>\n",
              "      <td>0.316624</td>\n",
              "      <td>0.117778</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>0.999856</td>\n",
              "      <td>0.895030</td>\n",
              "      <td>0.984093</td>\n",
              "      <td>0.980664</td>\n",
              "      <td>0.999827</td>\n",
              "      <td>0.656816</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.110240</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>1</td>\n",
              "      <td>0.237204</td>\n",
              "      <td>0.201668</td>\n",
              "      <td>0.251227</td>\n",
              "      <td>0.167174</td>\n",
              "      <td>0.294863</td>\n",
              "      <td>0.145911</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2187</th>\n",
              "      <td>0</td>\n",
              "      <td>0.077487</td>\n",
              "      <td>0.146791</td>\n",
              "      <td>0.097477</td>\n",
              "      <td>0.153996</td>\n",
              "      <td>0.095492</td>\n",
              "      <td>0.111025</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2188</th>\n",
              "      <td>0</td>\n",
              "      <td>0.263328</td>\n",
              "      <td>0.408858</td>\n",
              "      <td>0.108774</td>\n",
              "      <td>0.162515</td>\n",
              "      <td>0.205582</td>\n",
              "      <td>0.099497</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2189</th>\n",
              "      <td>0</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.110240</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2190</th>\n",
              "      <td>0</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.110240</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2191</th>\n",
              "      <td>0</td>\n",
              "      <td>0.015855</td>\n",
              "      <td>0.146331</td>\n",
              "      <td>0.036363</td>\n",
              "      <td>0.114590</td>\n",
              "      <td>0.101359</td>\n",
              "      <td>0.072932</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>2192 rows × 7 columns</p>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-95d59a96-4be6-47ec-a6b0-b4f8b1c5158e')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-95d59a96-4be6-47ec-a6b0-b4f8b1c5158e button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-95d59a96-4be6-47ec-a6b0-b4f8b1c5158e');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 121
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cepha_total.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "GbdMUJGjdRz_",
        "outputId": "6a9b93e6-32e8-4365-d4b6-ea0136b1b3f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "             label  death_model  glyco_model  cepha_model   peni_model  \\\n",
              "count  2192.000000  2192.000000  2192.000000  2192.000000  2192.000000   \n",
              "mean      0.148266     0.153331     0.193897     0.146789     0.186245   \n",
              "std       0.355445     0.141966     0.128466     0.128426     0.124085   \n",
              "min       0.000000     0.004505     0.014203     0.000041     0.003430   \n",
              "25%       0.000000     0.071000     0.145172     0.085396     0.136709   \n",
              "50%       0.000000     0.128333     0.163080     0.122726     0.144958   \n",
              "75%       0.000000     0.195743     0.174878     0.166112     0.178013   \n",
              "max       1.000000     0.999952     0.998940     0.993771     0.988274   \n",
              "\n",
              "       fluoro_model  macro_model  \n",
              "count   2192.000000  2192.000000  \n",
              "mean       0.165484     0.136834  \n",
              "std        0.127099     0.117513  \n",
              "min        0.041863     0.002022  \n",
              "25%        0.108039     0.091566  \n",
              "50%        0.115422     0.103486  \n",
              "75%        0.180804     0.127038  \n",
              "max        0.999858     0.989579  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-d3c83ad7-de8e-4262-93bc-a0f93a3c24a1\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>death_model</th>\n",
              "      <th>glyco_model</th>\n",
              "      <th>cepha_model</th>\n",
              "      <th>peni_model</th>\n",
              "      <th>fluoro_model</th>\n",
              "      <th>macro_model</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>2192.000000</td>\n",
              "      <td>2192.000000</td>\n",
              "      <td>2192.000000</td>\n",
              "      <td>2192.000000</td>\n",
              "      <td>2192.000000</td>\n",
              "      <td>2192.000000</td>\n",
              "      <td>2192.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>0.148266</td>\n",
              "      <td>0.153331</td>\n",
              "      <td>0.193897</td>\n",
              "      <td>0.146789</td>\n",
              "      <td>0.186245</td>\n",
              "      <td>0.165484</td>\n",
              "      <td>0.136834</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>0.355445</td>\n",
              "      <td>0.141966</td>\n",
              "      <td>0.128466</td>\n",
              "      <td>0.128426</td>\n",
              "      <td>0.124085</td>\n",
              "      <td>0.127099</td>\n",
              "      <td>0.117513</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.004505</td>\n",
              "      <td>0.014203</td>\n",
              "      <td>0.000041</td>\n",
              "      <td>0.003430</td>\n",
              "      <td>0.041863</td>\n",
              "      <td>0.002022</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.071000</td>\n",
              "      <td>0.145172</td>\n",
              "      <td>0.085396</td>\n",
              "      <td>0.136709</td>\n",
              "      <td>0.108039</td>\n",
              "      <td>0.091566</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.128333</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.115422</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.174878</td>\n",
              "      <td>0.166112</td>\n",
              "      <td>0.178013</td>\n",
              "      <td>0.180804</td>\n",
              "      <td>0.127038</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.999952</td>\n",
              "      <td>0.998940</td>\n",
              "      <td>0.993771</td>\n",
              "      <td>0.988274</td>\n",
              "      <td>0.999858</td>\n",
              "      <td>0.989579</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-d3c83ad7-de8e-4262-93bc-a0f93a3c24a1')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-d3c83ad7-de8e-4262-93bc-a0f93a3c24a1 button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-d3c83ad7-de8e-4262-93bc-a0f93a3c24a1');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 124
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "peni_label=pd.DataFrame(peni_test['LABEL'])\n",
        "\n",
        "death_predict=pd.DataFrame(death_lstm.predict(peni_test_loader))\n",
        "glyco_predict=pd.DataFrame(glyco_lstm.predict(peni_test_loader))\n",
        "cepha_predict=pd.DataFrame(cepha_lstm.predict(peni_test_loader))\n",
        "peni_predict=pd.DataFrame(peni_lstm.predict(peni_test_loader))\n",
        "fluoro_predict=pd.DataFrame(fluoro_lstm.predict(peni_test_loader))\n",
        "macro_predict=pd.DataFrame(macro_lstm.predict(peni_test_loader))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pP5bZHfSdhZj",
        "outputId": "4c04cbce-5519-4a37-83e5-5202c827119f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10/10 [==============================] - 0s 3ms/step\n",
            "10/10 [==============================] - 0s 3ms/step\n",
            "10/10 [==============================] - 0s 4ms/step\n",
            "10/10 [==============================] - 0s 4ms/step\n",
            "10/10 [==============================] - 0s 4ms/step\n",
            "10/10 [==============================] - 0s 4ms/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "peni_total=pd.concat([peni_label,death_predict,glyco_predict,cepha_predict,peni_predict,fluoro_predict,macro_predict],axis=1)\n",
        "peni_total.columns=['label','death_model','glyco_model','cepha_model','peni_model','fluoro_model','macro_model']"
      ],
      "metadata": {
        "id": "fGo7HZm5ds_U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "peni_total.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "id": "7d5igRVOd5NJ",
        "outputId": "565d1383-8f81-4527-8b6c-cb4d874358e4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "             label  death_model  glyco_model  cepha_model   peni_model  \\\n",
              "count  1213.000000  1213.000000  1213.000000  1213.000000  1213.000000   \n",
              "mean      0.206101     0.185862     0.207560     0.182194     0.188175   \n",
              "std       0.404670     0.161580     0.148215     0.141028     0.136850   \n",
              "min       0.000000     0.006523     0.013199     0.000043     0.000992   \n",
              "25%       0.000000     0.100963     0.147211     0.122726     0.134231   \n",
              "50%       0.000000     0.141116     0.163080     0.138982     0.144958   \n",
              "75%       0.000000     0.195743     0.182099     0.195352     0.174253   \n",
              "max       1.000000     0.999936     0.998780     0.994983     0.988192   \n",
              "\n",
              "       fluoro_model  macro_model  \n",
              "count   1213.000000  1213.000000  \n",
              "mean       0.174800     0.137230  \n",
              "std        0.147643     0.122632  \n",
              "min        0.032825     0.001846  \n",
              "25%        0.107627     0.092442  \n",
              "50%        0.117527     0.103486  \n",
              "75%        0.183134     0.127393  \n",
              "max        0.999842     0.994304  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-0b5964c3-931a-4cf8-a11b-4e4f491ee79c\">\n",
              "    <div class=\"colab-df-container\">\n",
              "      <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>label</th>\n",
              "      <th>death_model</th>\n",
              "      <th>glyco_model</th>\n",
              "      <th>cepha_model</th>\n",
              "      <th>peni_model</th>\n",
              "      <th>fluoro_model</th>\n",
              "      <th>macro_model</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>count</th>\n",
              "      <td>1213.000000</td>\n",
              "      <td>1213.000000</td>\n",
              "      <td>1213.000000</td>\n",
              "      <td>1213.000000</td>\n",
              "      <td>1213.000000</td>\n",
              "      <td>1213.000000</td>\n",
              "      <td>1213.000000</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>mean</th>\n",
              "      <td>0.206101</td>\n",
              "      <td>0.185862</td>\n",
              "      <td>0.207560</td>\n",
              "      <td>0.182194</td>\n",
              "      <td>0.188175</td>\n",
              "      <td>0.174800</td>\n",
              "      <td>0.137230</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>std</th>\n",
              "      <td>0.404670</td>\n",
              "      <td>0.161580</td>\n",
              "      <td>0.148215</td>\n",
              "      <td>0.141028</td>\n",
              "      <td>0.136850</td>\n",
              "      <td>0.147643</td>\n",
              "      <td>0.122632</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>min</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.006523</td>\n",
              "      <td>0.013199</td>\n",
              "      <td>0.000043</td>\n",
              "      <td>0.000992</td>\n",
              "      <td>0.032825</td>\n",
              "      <td>0.001846</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>25%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.100963</td>\n",
              "      <td>0.147211</td>\n",
              "      <td>0.122726</td>\n",
              "      <td>0.134231</td>\n",
              "      <td>0.107627</td>\n",
              "      <td>0.092442</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>50%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.141116</td>\n",
              "      <td>0.163080</td>\n",
              "      <td>0.138982</td>\n",
              "      <td>0.144958</td>\n",
              "      <td>0.117527</td>\n",
              "      <td>0.103486</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>75%</th>\n",
              "      <td>0.000000</td>\n",
              "      <td>0.195743</td>\n",
              "      <td>0.182099</td>\n",
              "      <td>0.195352</td>\n",
              "      <td>0.174253</td>\n",
              "      <td>0.183134</td>\n",
              "      <td>0.127393</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>max</th>\n",
              "      <td>1.000000</td>\n",
              "      <td>0.999936</td>\n",
              "      <td>0.998780</td>\n",
              "      <td>0.994983</td>\n",
              "      <td>0.988192</td>\n",
              "      <td>0.999842</td>\n",
              "      <td>0.994304</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "      <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-0b5964c3-931a-4cf8-a11b-4e4f491ee79c')\"\n",
              "              title=\"Convert this dataframe to an interactive table.\"\n",
              "              style=\"display:none;\">\n",
              "        \n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M0 0h24v24H0V0z\" fill=\"none\"/>\n",
              "    <path d=\"M18.56 5.44l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94zm-11 1L8.5 8.5l.94-2.06 2.06-.94-2.06-.94L8.5 2.5l-.94 2.06-2.06.94zm10 10l.94 2.06.94-2.06 2.06-.94-2.06-.94-.94-2.06-.94 2.06-2.06.94z\"/><path d=\"M17.41 7.96l-1.37-1.37c-.4-.4-.92-.59-1.43-.59-.52 0-1.04.2-1.43.59L10.3 9.45l-7.72 7.72c-.78.78-.78 2.05 0 2.83L4 21.41c.39.39.9.59 1.41.59.51 0 1.02-.2 1.41-.59l7.78-7.78 2.81-2.81c.8-.78.8-2.07 0-2.86zM5.41 20L4 18.59l7.72-7.72 1.47 1.35L5.41 20z\"/>\n",
              "  </svg>\n",
              "      </button>\n",
              "      \n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      flex-wrap:wrap;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "      <script>\n",
              "        const buttonEl =\n",
              "          document.querySelector('#df-0b5964c3-931a-4cf8-a11b-4e4f491ee79c button.colab-df-convert');\n",
              "        buttonEl.style.display =\n",
              "          google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "        async function convertToInteractive(key) {\n",
              "          const element = document.querySelector('#df-0b5964c3-931a-4cf8-a11b-4e4f491ee79c');\n",
              "          const dataTable =\n",
              "            await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                     [key], {});\n",
              "          if (!dataTable) return;\n",
              "\n",
              "          const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "            '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "            + ' to learn more about interactive tables.';\n",
              "          element.innerHTML = '';\n",
              "          dataTable['output_type'] = 'display_data';\n",
              "          await google.colab.output.renderOutput(dataTable, element);\n",
              "          const docLink = document.createElement('div');\n",
              "          docLink.innerHTML = docLinkHtml;\n",
              "          element.appendChild(docLink);\n",
              "        }\n",
              "      </script>\n",
              "    </div>\n",
              "  </div>\n",
              "  "
            ]
          },
          "metadata": {},
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cepha_total.to_csv('glyco_total.csv')"
      ],
      "metadata": {
        "id": "-Q5jR_D6caVF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lvP-e_o2XmpP"
      },
      "outputs": [],
      "source": [
        "diagnoses_icd = pd.merge(left = diagnoses_icd, right = sepsis[['subject_id','sepsis3']], how='inner', left_on='subject_id', right_on='subject_id')"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2kh5mwWUZI-S"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "0GVYcex1OddI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ABTMAjyBXfd-"
      },
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "lWCgxDDqYNn2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "752d4f41-b23b-4a5b-9674-f6b1a3157afd"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.15838639569908872"
            ]
          },
          "metadata": {},
          "execution_count": 108
        }
      ],
      "source": [
        "sum(death_train['LABEL'])/len(death_train['LABEL'])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bp43b-ctXfbj"
      },
      "source": [
        "모델 저장과\n",
        "test data로 test( 5개 모델간 차이가 있는지)"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "iSVsO4EkOi9R"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "collapsed_sections": [
        "zQ-RYaQS6GOr"
      ],
      "machine_shape": "hm",
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "premium",
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}