From 05c663b0b9c6f6c1262a65b13cc02b285f8897dc Mon Sep 17 00:00:00 2001 From: Yiquan Date: Wed, 2 Feb 2022 23:43:36 -0600 Subject: [PATCH] update RBD-HA model --- code/CoV_Encoder/RBD_HA_classifier.ipynb | 2 +- graph/model_comparison.png | Bin 44369 -> 44362 bytes result/model_comparison.xlsx | Bin 9386 -> 9464 bytes 3 files changed, 1 insertion(+), 1 deletion(-) diff --git a/code/CoV_Encoder/RBD_HA_classifier.ipynb b/code/CoV_Encoder/RBD_HA_classifier.ipynb index 98b1163..2864bbf 100644 --- a/code/CoV_Encoder/RBD_HA_classifier.ipynb +++ b/code/CoV_Encoder/RBD_HA_classifier.ipynb @@ -1 +1 @@ -{"nbformat":4,"nbformat_minor":0,"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.6.2"},"colab":{"name":"RBD_HA_classifier.ipynb","provenance":[],"collapsed_sections":["8LlD-Llz0SdA","DasHlLjt467U","EvI27BXG0SdB","TFSz2Fl9ZKeu"]},"accelerator":"GPU"},"cells":[{"cell_type":"code","metadata":{"id":"EMWCby8OfwMI","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642739898329,"user_tz":360,"elapsed":19804,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"af63e906-c990-4783-eed0-adc0bd3a330d"},"source":["#set the colab to access the google drive\n","from google.colab import drive\n","drive.mount('/content/drive/')\n","import os\n","os.chdir(\"drive/MyDrive/Colab Notebooks/CoV_Encoder\")"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive/\n"]}]},{"cell_type":"code","metadata":{"collapsed":true,"id":"yzYyFtE90Sc1"},"source":["#import package\n","import tensorflow as tf\n","from tensorflow import keras\n","\n","import os\n","import tempfile\n","\n","import matplotlib as mpl\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import pandas as pd\n","import seaborn as sns\n","import sklearn\n","\n","from sklearn.metrics import confusion_matrix\n","from sklearn.model_selection import train_test_split\n","from keras.preprocessing.sequence import pad_sequences\n","from keras.models import Sequential\n","from keras.layers import Dense\n","\n","from sklearn.preprocessing import LabelEncoder\n","from tensorflow.keras.utils import to_categorical\n","from tensorflow.keras import layers\n","from tensorflow.keras.layers import Concatenate\n","\n","%matplotlib inline"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"JaZYMn1l0SdA","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642741616876,"user_tz":360,"elapsed":3823,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"7451201f-0a1d-4334-ed18-f75e137c9ddb"},"source":["# Read a file and split into train,validation,test sets\n","\n","data_path = 'data/RBD-HA_new_full_CDR.xlsx'\n","raw_df = pd.read_excel(data_path)\n","raw_df=raw_df[raw_df[['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA']].notnull().all(1)]\n","cleaned_df = raw_df[['Name','cluster','Antigen','Resources','CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA','VH Genbank ID','VL Genbank ID']].copy()\n","\n","#deduplication\n","cleaned_df = cleaned_df.drop_duplicates(subset=['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA'])\n","\n","# Use a utility from sklearn to split and shuffle your dataset.\n","train_df, test_df = train_test_split(cleaned_df, test_size=0.2)\n","train_df, val_df = train_test_split(train_df, test_size=0.2)\n","\n","# # Over sampling for training set HA Abs\n","# S_train_df = train_df[train_df.Antigen == 'Spike']\n","# S_num = len(S_train_df)\n","# HA_train_df = train_df[train_df.Antigen == 'HA']\n","# print(HA_train_df)\n","# HA_train_df=HA_train_df.sample(S_num, replace=True) \n","# print(HA_train_df)\n","# train_df = pd.concat([S_train_df,HA_train_df])\n","\n","print(len(train_df))\n","print(len(val_df))\n","print(len(test_df))\n"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["2963\n","741\n","927\n"]}]},{"cell_type":"code","metadata":{"id":"Q-gHvUw7LtSV"},"source":["# save train_df, val_df, test_df\n","train_df['dataset']='train set'\n","val_df['dataset']='val set'\n","test_df['dataset']='test set'\n","dataset_df = df=pd.concat([train_df,val_df,test_df])\n","dataset_df.to_csv('result/dataset/RBD_new_dataset.csv')\n"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"8LlD-Llz0SdA"},"source":["# Data processing"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"dlKyWvIxc26n","executionInfo":{"status":"ok","timestamp":1642741660827,"user_tz":360,"elapsed":110,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"173efbfb-a43d-4294-ce63-e26a890993c9"},"source":["\n","codes = ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L',\n"," 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y']\n","\n","def create_dict(codes):\n"," char_dict = {}\n"," for index, val in enumerate(codes):\n"," char_dict[val] = index+1\n","\n"," return char_dict\n","\n","char_dict = create_dict(codes)\n","\n","print(char_dict)\n","print(\"Dict Length:\", len(char_dict))"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["{'A': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'K': 9, 'L': 10, 'M': 11, 'N': 12, 'P': 13, 'Q': 14, 'R': 15, 'S': 16, 'T': 17, 'V': 18, 'W': 19, 'Y': 20}\n","Dict Length: 20\n"]}]},{"cell_type":"code","metadata":{"id":"74hboteHc57v"},"source":["def integer_encoding(data,CDR):\n"," \"\"\"\n"," - Encodes code sequence to integer values.\n"," - 20 common amino acids are taken into consideration\n"," and rests are categorized as 21.\n"," \"\"\"\n"," \n"," encode_list = []\n"," for row in data[CDR].values:\n"," row_encode = []\n"," for code in row:\n"," row_encode.append(char_dict.get(code, 21))\n"," encode_list.append(np.array(row_encode))\n"," \n"," return encode_list"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"lkU0B3GCWjdB"},"source":["def encode_six_CDR(data,max_length = 30):\n"," \"\"\"\n"," - Encodes code sequence to integer values.\n"," - add post-padding\n"," \"\"\"\n"," cdr_list = ['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA']\n"," encoded_cdr_list=[]\n"," for cdr in cdr_list:\n"," encoded_cdr=integer_encoding(data,cdr)\n"," pad_cdr=pad_sequences(encoded_cdr,maxlen=max_length, padding='post', truncating='post')\n"," encoded_cdr_list.append(pad_cdr)\n"," return encoded_cdr_list"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"uBA1-IL8Xpj_","executionInfo":{"status":"ok","timestamp":1642741661223,"user_tz":360,"elapsed":281,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"3b00a61c-742c-4c2a-b023-b0f04dacf71b"},"source":["[train_x1,train_x2,train_x3,train_x4,train_x5,train_x6]=encode_six_CDR(train_df)\n","[val_x1,val_x2,val_x3,val_x4,val_x5,val_x6]=encode_six_CDR(val_df)\n","[test_x1,test_x2,test_x3,test_x4,test_x5,test_x6]=encode_six_CDR(test_df)\n","print(train_x1.shape, val_x1.shape, test_x1.shape)\n","print(test_x1[0])"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["(2963, 30) (741, 30) (927, 30)\n","[ 6 5 17 5 15 15 20 6 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n"," 0 0 0 0 0 0]\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"IAc2Vwt3dAS5","executionInfo":{"status":"ok","timestamp":1642741661224,"user_tz":360,"elapsed":7,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"769b2788-e93c-429a-e053-028d0b494232"},"source":["# label/integer encoding output variable: (y)\n","le = LabelEncoder()\n","\n","y_train = le.fit_transform(train_df['Antigen'])\n","y_val = le.transform(val_df['Antigen'])\n","y_test = le.transform(test_df['Antigen'])\n","\n","print(y_train.shape, y_val.shape, y_test.shape)\n","print('Total classes: ', len(le.classes_))"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["(2963,) (741,) (927,)\n","Total classes: 2\n"]}]},{"cell_type":"markdown","metadata":{"id":"DasHlLjt467U"},"source":["# Basic statistics"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"uhdgojQx4_i4","executionInfo":{"status":"ok","timestamp":1642741665260,"user_tz":360,"elapsed":115,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"f6c90d3e-523e-4451-8965-43ca240b1bd0"},"source":["def Count_Abs_bycls(train, test, val):\n"," \"\"\"\n"," Prints # Antibody number in different classes in data sets.\n"," \"\"\"\n"," train_count = train['Antigen'].value_counts()\n"," val_count = val['Antigen'].value_counts()\n"," test_count = test['Antigen'].value_counts()\n","\n"," print('Number of Abs in different classes in Train:\\n',train_count,'\\n')\n"," print('Number of Abs in different classes in Val:\\n',val_count,'\\n')\n"," print('Number of Abs in different classes in Test:\\n',test_count,'\\n')\n"," \n","\n","Count_Abs_bycls(train_df,test_df,val_df)"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Number of Abs in different classes in Train:\n"," S:RBD 2102\n","HA 861\n","Name: Antigen, dtype: int64 \n","\n","Number of Abs in different classes in Val:\n"," S:RBD 526\n","HA 215\n","Name: Antigen, dtype: int64 \n","\n","Number of Abs in different classes in Test:\n"," S:RBD 647\n","HA 280\n","Name: Antigen, dtype: int64 \n","\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":282},"id":"4GnknUOX61mk","executionInfo":{"status":"ok","timestamp":1642741666020,"user_tz":360,"elapsed":650,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"6303a4bf-8a5b-495e-ab1b-4a451b1dfb60"},"source":["def plot_cluster_count(df, data_name):\n"," sns.histplot(df['cluster'].values,binwidth=5)\n"," plt.title(f'Cluster char count: {data_name}')\n"," plt.grid(True)\n","\n","plt.subplot(1, 3, 1)\n","plot_cluster_count(train_df, 'Train')\n","\n","plt.subplot(1, 3, 2)\n","plot_cluster_count(val_df, 'Val')\n","\n","plt.subplot(1, 3, 3)\n","plot_cluster_count(test_df, 'Test')\n","\n","plt.subplots_adjust(right=3.0)\n","plt.show()"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAABRQAAAEJCAYAAADl4au+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdf3QU9b3/8ddmdyFAINllQzQgSgR/URQ1KIoSLqxWxV6pbbFCbFWsl6Kg+AukFmjRmluFxB9wrUpBxV6rR0lrj/V60wjWS7GBiD+CIiC0eEBCyBKDBMgmn+8flHyJ5Mdk2ezMLM/HOZ7j7s7OvD6TZd+Zd2Y+4zHGGAEAAAAAAACABSl2BwAAAAAAAADgHjQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEJdeONNyocDtsdI+48Ho+WLVtmdwxIWrFihTwej7744gu7owA4jlHvEG9bt26Vx+PRu+++a3cUAMcJahmAttBQRNzs3r1b9913n04//XSlpqaqT58+GjlypJ5//nlFo9FO2+7AgQM1d+7cTls/2hYOh3XjjTd2+H0ej6fN/0455ZSY8lx88cXasWOHsrOzY3o/ALSHend8irXeXXPNNbrgggtafG3//v0KBoN64IEHjjEdAHQMtez45LRjt8P4XLiTz+4ASA7btm3TJZdcIp/Pp1/+8pc699xz5ff7tWrVKj366KM6++yzNXToULtjtskYo2g0Kr/fb3eUJgcPHlSXLl3sjtEpduzY0fT/q1at0ve+9z2Vl5frxBNPlCR5vd5my1vdF126dNEJJ5wQ37AA8C/Uu86RzPXu1ltv1dVXX60PPvhA55xzTrPXXn31VdXU1OiWW26xKR2A4xG1rHMkcy3r6LEbjhMGiIOrr77aZGVlmT179hz12sGDB83evXuNMcb8+Mc/NmPGjGl67ZuPjTHmhRdeMEd+NLdt22auvfZa07t3b9O1a1czYMAA8+tf/9oYY0xeXp6R1Oy/LVu2GGOM2bhxo7n22mtNenq6ycjIMJdddpn58MMPm9a7ZMkS4/V6TWlpqRk6dKjx+/3mjTfeaHF89fX1Zu7cuSYnJ8d06dLFZGdnm9tvv73pdUlm4cKFJj8/36SlpZm+ffuaX/3qV83W8eKLL5oLLrjA9OrVy/Tu3dtcddVVZsOGDU2vb9myxUgyy5YtM1deeaXp3r27ue+++1rd5y+99JI577zzTNeuXU0wGDRXXHGFqa6ubtrnM2bMMNnZ2cbv95szzzzTvPjii83eL8m88MILzZ4bM2aM+fGPf9z0+OSTTzY///nPzbRp00wgEDB9+vQxd955p6mvrzfGHPr5fXP/v/32261mbs3bb79tJJlt27Y1y/fYY4+Z66+/3vTq1cuMHz/eGGPMrFmzzBlnnGG6detm+vXrZ/7jP/6j2efum+s6/Pitt94yl156qenWrZs588wzW/1ZA0BbqHfUu47Wu4aGBtO/f39z2223HfVaXl6eueKKK4wxxhQVFZlzzjnH9OjRw2RlZZnrrrvObN++/aj99te//tXSdgGgNdQyalm8j93WrFljLrvsMtOjRw8TCoXMd7/7XbN169am12P9XMDZuOQZx6y6ulpvvPGGbr/9dqWnpx/1ut/vV48ePWJe/5QpU1RTU6OSkhJ9+umnWrx4sfr16ydJeu2113TKKafo7rvv1o4dO7Rjxw6ddNJJ2rlzpy655BL16dNHf/3rX7V69WqdfvrpGjVqlHbt2tW07sbGRs2YMUMLFizQp59+qtzc3BYzTJo0SQsXLtTcuXO1fv16vfrqq8rJyWm2zC9+8QuNHDlS69at0/33369Zs2bpL3/5S9PrBw4c0AMPPKDy8nL97//+r7xer8aOHauDBw82W8+MGTM0ceJEffzxx5o8eXKLeZYsWaL8/HyNGzdO5eXlevvtt3XFFVeooaFBkjRr1iw988wzKioq0scff6z8/Hzl5+c3y2PVE088oRNPPFHvvfeennjiCT355JN67rnnJEmPPfaYLr30Uo0fP75p/1988cWSpFGjRmnUqFEd3t6RfvGLX+jiiy9WeXm5HnzwQUlSt27d9PTTT2v9+vVaunSpVqxYoWnTprW7rnvuuUezZs3SBx98oAsvvFDXXXedIpHIMeUDcHyh3h1CvetYvUtJSdGkSZP04osvqq6urun5jRs3auXKlbr11lubnnv00Uf10Ucfafny5frnP/+pH/7whx0eBwC0hVp2CLUsfsdu69evV15eni666CKtWbNGpaWl8nq9uuyyy7R//35JsX0u4AJ2dzThfu+9956RZF599dV2l43lr1xnn322mTNnTqvrPPXUU496fc6cOebCCy9s9lxjY6PJyckxhYWFxphDf+WSZN555502M2/cuNFIMq+88kqry0gyU6dObfbcGWecYWbOnNnqe3bv3m0kmXfffdcY8///yvXLX/6yzTzGGHPSSSe1eKaDMcZ8/fXXpkuXLmbhwoXNnh83bpz5t3/7t2aZrfyV6zvf+U6zZa644grzwx/+sNX3HHbDDTeYG264od2xGNP6GYo333xzu+997bXXTJcuXUxDQ0OL6zr8+MjP55dffmkkmTfffNNSPgAwhnpnDPUu1nr3xRdfGK/Xa5577rmm5+677z5z4oknNp058k3l5eVGkvniiy+MMZyhCCA+qGXUsngfu/34xz821113XbNl9u/fb7p162aWL19ujIntcwHn4wxFHDNjTKeu/84779SvfvUrXXjhhZoxY4beeeeddt9TVlamtWvXKi0trem/nj17auvWrdq4cWOzZYcNG9bmusrLyyVJl19+eZvLfXOekezsbO3cubPp8bp16/Td735XAwYMUM+ePdW/f39J0j/+8Y9m72tt4vbDKisrtW3btlbzbNq0SQcPHtTIkSObPZ+Xl6eKioo2192S9sbVmueff17PP/98h7d3pJb2xWuvvaaRI0cqOztbaWlpmjhxog4ePKgvv/yyzXUdOY6srCx5vV5L4wCAw6h3h1DvmrNS7/r27auxY8fqmWeekSTV19dr6dKluvnmm+XzHZrSfMWKFfr2t7+tk046ST179tQll1wi6ej9BgDHglp2CLWsuWM5disrK9Py5cub/fx69+6t/fv3N/38YvlcwPloKOKYDRo0SCkpKVq/fn2H35uSknJUUauvr2/2+KabbtI//vEPTZ48WTt27NCVV16p/Pz8Ntfb2NioMWPGaN26dc3+27BhQ7O7R3m9XqWmpnY4d0u+OQGvx+NRY2OjJGnfvn26/PLL5fF4tGTJEv39739XWVmZPB7PUafNH8slBh3h8Xja3fdS2+PqbN/cF++9955+8IMfaOTIkVq+fLnKy8v11FNPSdJR+/GbWpogOVHjAJAcqHeHUO9ic+utt+rdd9/VJ598oj/+8Y+qqqpquhnLP//5T1111VU65ZRT9NJLL2nNmjX64x//KKn9+gYAHUEtO4RaFj+NjY264YYbjvr5ffbZZ011LpbPBZyPhiKOWTAY1JVXXqknn3xSNTU1R71eX1+vr7/+usX39unTR9u3b2/23OG/Kh3pxBNP1E033aTnn39eixcv1osvvqivvvpK0qEvzcPzTxyWm5uriooK9evXTwMHDmz2X2ZmZofGd95550mS3nrrrQ6970iffPKJdu3apYceekijRo3SmWeeqUgkEtNfCPv06aN+/fq1mmfgwIHq2rXrUX/1Wblypb71rW81W8+R+/7AgQMx/WLR0v7vLO+++65CoZAefPBBXXjhhTrttNP0xRdfJGTbAEC9ax/1rnVXXnml+vfvr2eeeUbPPvusLr/8cp1yyimSDp3dUVdXp6KiIo0YMUKnn346Z9ED6BTUsvZRyzomNzdXH374oU499dSjfn6BQKBpuY5+LuB8NBQRF4sWLZLf79f555+v3/3ud1q/fr02bdqkZcuWKTc396hT1Q8Lh8P69NNPtXDhQm3evFnPPPOMXn755WbL3H777XrjjTe0efNmVVRU6LXXXmu6HEiSBgwYoP/7v//TP//5T1VVVamxsVG33367GhoadM011+ivf/2rtm7dqnfffVc/+9nPtGrVqg6NbeDAgZo4caKmTJmiZcuWafPmzSorK9Njjz1meR0nn3yyunbtqieeeEKbN2/WX/7yF91xxx3yeDwdynLYnDlz9Jvf/Ebz5s3TJ598ooqKCj355JOqqqpS9+7dNW3aNP385z/XK6+8os8++0y/+tWv9Ic//EGzZs1qWkc4HNZTTz2lv/3tb/r444914403xnQWxIABA7R27Vpt3rxZVVVVTX8p+9GPfqQf/ehHMY2vNaeffrp27dqlxYsX6/PPP9fzzz+vRYsWxXUbANAW6l3bqHetO3xzlt/+9rd66623mt2MZdCgQfJ4PJo/f762bNmi4uJi/fKXv+xwRgCwglrWNmpZx8yaNUuffPKJ8vPz9fe//11btmzR22+/rTvuuEOff/65pNg+F3ABe6ZuRDKqrKw0d999txk0aJDp2rWryczMNCNHjjQvvPBCs1vVf3Mi3wcffNBkZ2ebHj16mB/+8IfmySefbDax75QpU8ygQYNMamqqCQaD5qqrrjIff/xx0+tlZWXm3HPPNampqc1uMb9161YzYcIEEwqFTJcuXUz//v3NxIkTzeeff26MOTSxr9frtTS2gwcPmgceeMCcfPLJxu/3m759+5o77rij6XVZmCT3lVdeMQMHDjRdu3Y1Q4cONStWrDBer9csWbLEGNPxydaXLVtmzj77bNOlS5em/RKJRJryzpgxw2RnZxu/32/OPPNM8+KLLzZ7/44dO8zVV19tevbsafr162cWLVrU4sS+8+bNa/a+SZMmmby8vKbHmzdvNpdeeqnp0aOHkWTefvttY4wxeXl5zZZrS2s3ZfnmPjXGmAceeMD06dPHdO/e3Vx55ZXmd7/7XbOfe2s3ZTly3caYZvseADqCeke9i7XeHb45S0s3Y3nyySdNv379TGpqqhkxYoT585//3Gw73JQFQDxRy6hl8Tx2+/DDD82///u/m4yMDJOammpOPfVU85Of/MTs3r3bGBP75wLO5jGmk2dlBQAAAAAAAJA0uOQZAAAAAAAAgGU0FAEAAAAAAABYRkMRAAAAAAAAgGU+uwMAAAAAAJzrtttuU2pqqlJSUuT1elVQUKC9e/eqsLBQu3btUmZmpqZPn660tDS7owIAEoSGIgAAAACgTXPmzFGvXr2aHhcXF2vIkCEaN26ciouLVVxcrPz8fBsTAgASKakaitu3b4/pfaFQSFVVVXFOkxhuzi65O7+bs0vuzu/m7JK788cre3Z2dhzSHB9iqW1u/owdKVnGISXPWBiH8yTLWJJhHMdbbSsrK9PcuXMlSXl5eZo7d66lhuLxeMwmuT+/xBicgjE4g9vHYCV/e3UtqRqKAAAAAID4e+ihhyRJl112mcLhsGpqahQIBCRJGRkZqqmpafF9JSUlKikpkSQVFBQoFArFtH2fzxfze53A7fklxuAUjMEZ3D6GeOSnoQgAAAAAaNW8efMUDAZVU1OjBx988KizVjwejzweT4vvDYfDCofDTY9jPaPneDgbyOkYgzMwBmdw+xhcc4biokWLVF5ervT0dM2fP7/p+T//+c/6n//5H6WkpOi8885rOkV++fLlKi0tVUpKim666SYNHTo0ETEBAAAAAN8QDAYlSenp6Ro2bJg2bdqk9PR0RSIRBQIBRSKRZvMrAgCSX0oiNjJq1CjNmjWr2XMff/yx1qxZo0ceeUQLFizQd77zHUnSF198oVWrVmnBggX62c9+psWLF6uxsTERMQEAAAAAR9i/f7/q6uqa/v/DDz9U//79lZubq5UrV0qSVq5cqWHDhtkZEwCQYAk5Q/Gss85SZWVls+feeustXXPNNfL7/ZIO/bVLOjS578UXXyy/368+ffrohBNO0KZNm3TaaaclIioAAAAA4F9qamr06KOPSpIaGhp0ySWXaOjQoTr11FNVWFio0tJSZWZmavr06TYnBQAkkm1zKO7YsUOffvqpXnrpJfn9ft1www0aOHCgqqurNWjQoKblgsGgqqurW1wHE/y6O7vk7vxuzi65O7+bs0vuzu/m7AAAoOOysrL0yCOPHPV8z549NXv2bBsSAQCcwLaGYmNjo/bu3auHHnpImzdvVmFhoZ588skOrYMJft2dXXJ3fjdnl9yd383ZJXfnj1f29ib4dbvbbrtNqampSklJkdfrVUFBgfbu3avCwkLt2rWr6UyOtLQ0u6MCAAAAQIfZ1lAMBoO64IIL5PF4NHDgQKWkpKi2tlbBYFC7d+9uWq66urppEmAAANxizpw5zSaoLy4u1pAhQzRu3DgVFxeruLi46WZkAAAAAOAmCbkpS0uGDRumiooKSdL27dsVjUbVs2dP5ebmatWqVaqvr1dlZaV27NihgQMHJiSTx+Np9z8AAGJRVlamvLw8SVJeXp7Kyso6fZtW6hq1DQDgJtQ1AHCGhJyhWFRUpPXr16u2tlaTJ0/W+PHjNXr0aC1atEh33323fD6fbrvtNnk8Hp100km66KKLdNdddyklJUWTJk1SSkrn9z09Ho+eXVupPXXRVpfJ6ObTLef3kTGm0/MAANztoYcekiRddtllCofDqqmpUSAQkCRlZGSopqamxffFY35gn8+nYDCox1ZuVqSNuiZJgW4+3ZF3akJqbUcl05ydyTIWxuE8yTKWZBkHOpfH49Hi8so2a1ugm0+TzuOYDQA6W0IainfeeWeLz0+bNq3F56+99lpde+21nRmpRXvqoqquq0/4dgEAyWXevHkKBoOqqanRgw8+eNSckW2dQRGP+YFDoZAikYh21e7X7n1t17Vo1K9IJOLIAy83zzf6TckyFsbhPMkylmQYR7LPD+wUkbqoqtupbQCAzue80xEAAHC5w3P/pqena9iwYdq0aZPS09MViUQkSZFIpNn8igAAAADgJjQUAQCIo/3796uurq7p/z/88EP1799fubm5WrlypSRp5cqVGjZsmJ0xAQAAACBmtt3lGQCAZFRTU6NHH31UktTQ0KBLLrlEQ4cO1amnnqrCwkKVlpYqMzNT06dPtzkpAAAAAMSGhiIAAHGUlZWlRx555Kjne/bsqdmzZ9uQCAAAAADii0ueAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFiWkIbiokWLdMstt+juu+8+6rXXX39d48eP11dffSVJMsbot7/9raZOnap77rlHn3/+eSIiAgAAAAAAALAgIQ3FUaNGadasWUc9X1VVpQ8//FChUKjpuffff19ffvmlHn/8cd1666169tlnExERAAAAAAAAgAUJaSieddZZSktLO+r55557ThMnTpTH42l6bs2aNRo5cqQ8Ho9OO+00ff3114pEIomICQAAAAAAAKAdPrs2XFZWpmAwqFNOOaXZ89XV1c3OWOzdu7eqq6sVCASOWkdJSYlKSkokSQUFBc3e1xE+n0+BQEA+f6X80TaW8x9aLiXFOVNP+ny+mMftBG7O7+bskrvzuzm75O78bs4OAAAAAIgPWxqKBw4c0PLly/XAAw8c03rC4bDC4XDT46qqqpjWEwqFFIlEFK2Pqr6+vtXloj4pEonIGBPTdjpDKBSKedxO4Ob8bs4uuTu/m7NL7s4fr+zZ2dlxSAMAAAAAsIMtDcWdO3eqsrJS9957ryRp9+7dmjFjhh5++GEFg8FmB6u7d+9WMBi0IyYAAAAAAACAb7Clodi/f/9mN1u57bbb9PDDD6tXr17Kzc3Vm2++qREjRmjjxo3q3r17i5c7AwAAAAAAAEi8hDQUi4qKtH79etXW1mry5MkaP368Ro8e3eKy5557rsrLyzVt2jR16dJFU6ZMSUREAAAAAAAAABYkpKF45513tvn6woULm/7f4/Holltu6exIAAAAAAAAAGLgnNsVAwAAAAAAAHA8GooAAAAAAAAALKOhCAAAAAAAAMAyW+7yDAAAAABwj8bGRs2cOVPBYFAzZ85UZWWlioqKVFtbq5ycHE2dOlU+H4eXAHC84AxFAAAAAECb3njjDfXt27fp8bJlyzR27Fg98cQT6tGjh0pLS21MBwBINBqKAAAAAIBW7d69W+Xl5RozZowkyRijiooKDR8+XJI0atQolZWV2RkRAJBgnJMOAAAAAGjV0qVLlZ+fr7q6OklSbW2tunfvLq/XK0kKBoOqrq5u8b0lJSUqKSmRJBUUFCgUCsWUwefzKRAIyO+rlN/f+nL+fy2XkuKsc2d8Pl/MY3cKxuAMjMEZ3D6GeOSnoQgAAAAAaNHatWuVnp6unJwcVVRUdPj94XBY4XC46XFVVVVMOUKhkCKRiOqjUdXX17e6XL1fikQiMsbEtJ3OEgqFYh67UzAGZ2AMzuD2MVjJn52d3ebrNBQBAAAAAC3asGGD1qxZo/fff18HDx5UXV2dli5dqn379qmhoUFer1fV1dUKBoN2RwUAJBANRQAAAABAiyZMmKAJEyZIkioqKvT6669r2rRpWrBggVavXq0RI0ZoxYoVys3NtTkpACCRaCgCABBnjY2NmjlzpoLBoGbOnKnKykoVFRWptrZWOTk5mjp1qnw+SjAAwL0mTpyooqIivfTSSxowYIBGjx5tdyQAQAJxNAMAQJy98cYb6tu3b9Pk9cuWLdPYsWM1YsQIPf300yotLdXll19uc0oAADpm8ODBGjx4sCQpKytLDz/8sM2JAAB2cdatrwAAcLndu3ervLxcY8aMkSQZY1RRUaHhw4dLkkaNGqWysjI7IwIAAADAMeEMRQAA4mjp0qXKz89vOjuxtrZW3bt3l9frlSQFg0FVV1e3+v6SkhKVlJRIkgoKChQKhTqcwefzKRAIyOerlN9vbdmUFOf9jdHn88U0fidKlrEwDudJlrEkyzgAADhe0FAEACBO1q5dq/T0dOXk5KiioiKmdYTDYYXD4abHVVVVHV5HKBRSJBJRNBpVfX19m8tG/VIkEpExpsPb6WyhUCim8TtRsoyFcThPsowlGcaRnZ1tdwQAABKGhiIAAHGyYcMGrVmzRu+//74OHjyouro6LV26VPv27VNDQ4O8Xq+qq6sVDAbtjgoAAAAAMaOhCABAnEyYMEETJkyQJFVUVOj111/XtGnTtGDBAq1evVojRozQihUrlJuba3NSAAAAAIhdQhqKixYtUnl5udLT0zV//nxJ0gsvvKC1a9fK5/MpKytLU6ZMUY8ePSRJy5cvV2lpqVJSUnTTTTdp6NChiYgJAECnmDhxooqKivTSSy9pwIABGj16tN2RAAAAACBmCWkojho1SldccYUWLlzY9NzZZ5+tCRMmyOv1atmyZVq+fLny8/P1xRdfaNWqVVqwYIEikYjmzZunxx57zJGTxQMA0JrBgwdr8ODBkqSsrCw9/PDDNicCAAAAgPhISJfurLPOUlpaWrPnzjnnnKY7Xp522mlNd7wsKyvTxRdfLL/frz59+uiEE07Qpk2bEhETAAAAAAAAQDsccdpfaWlp02XN1dXV6t27d9NrwWCwqdkIAAAAAAAAwF6235Tltddek9fr1aWXXtrh95aUlKikpESSVFBQoFAoFFMGn8+nQCAgn79S/mgby/kPLeeky699Pl/M43YCN+d3c3bJ3fndnF1yd343ZwcAAAAAxIetDcUVK1Zo7dq1mj17tjwej6RDZyTu3r27aZnq6moFg8EW3x8OhxUOh5seV1VVxZQjFAopEokoWh9VfX19q8tFfVIkEpExJqbtdIZQKBTzuJ3AzfndnF1yd343Z5fcnT9e2bOzs+OQBgAAAABgB9tOtVu3bp3+8Ic/aMaMGeratWvT87m5uVq1apXq6+tVWVmpHTt2aODAgXbFBAAAAAAAAHCEhJyhWFRUpPXr16u2tlaTJ0/W+PHjtXz5ckWjUc2bN0+SNGjQIN1666066aSTdNFFF+muu+5SSkqKJk2a5KhLjAEAAAAAAIDjWUIainfeeedRz40ePbrV5a+99lpde+21nRkJAAAAAAAAQAw49Q8AAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFhGQxEAAAAAAACAZTQUAQAAAAAAAFjmS8RGFi1apPLycqWnp2v+/PmSpL1796qwsFC7du1SZmampk+frrS0NBljtGTJEr3//vvq2rWrpkyZopycnETEBAAAAAAAANCOhJyhOGrUKM2aNavZc8XFxRoyZIgef/xxDRkyRMXFxZKk999/X19++aUef/xx3XrrrXr22WcTEREAAAAAAACABQlpKJ511llKS0tr9lxZWZny8vIkSXl5eSorK5MkrVmzRiNHjpTH49Fpp52mr7/+WpFIJBExAQAAAABHOHjwoO6//37de++9uuuuu/Tyyy9LkiorKzVr1ixNnTpVhYWFikajNicFACRSQi55bklNTY0CgYAkKSMjQzU1NZKk6upqhUKhpuV69+6t6urqpmWPVFJSopKSEklSQUFBs/d1hM/nUyAQkM9fKX8bddDnP7RcSopzpp70+Xwxj9sJ3Jzfzdkld+d3c3bJ3fndnB0AAHSc3+/XnDlzlJqaqmg0qtmzZ2vo0KH605/+pLFjx2rEiBF6+umnVVpaqssvv9zuuACABLGtoXgkj8cjj8fT4feFw2GFw+Gmx1VVVTFtPxQKKRKJKFofVX19favLRX1SJBKRMSam7XSGUCgU87idwM353Zxdcnd+N2eX3J0/Xtmzs7PjkAYAAHQ2j8ej1NRUSVJDQ/uw28gAACAASURBVIMaGhrk8XhUUVGhO+64Q9KhKa5eeeUVGooAcByxraGYnp6uSCSiQCCgSCSiXr16SZKCwWCzg9Xdu3crGAzaFRMAAAAAjmuNjY2aMWOGvvzyS337299WVlaWunfvLq/XK+nQMVx1dXWL7433VWV+X6X8/taX8/ucd1WZlBxXeTAGZ2AMzuD2McQjv20NxdzcXK1cuVLjxo3TypUrNWzYsKbn33zzTY0YMUIbN25U9+7dW7zcGQAAAADQ+VJSUvTII4/o66+/1qOPPqrt27dbfm+8ryqrj7Z9VVm933lXlUnuvkLlMMbgDIzBGdw+Biv527uqLCENxaKiIq1fv161tbWaPHmyxo8fr3HjxqmwsFClpaXKzMzU9OnTJUnnnnuuysvLNW3aNHXp0kVTpkxJREQAAOLi4MGDmjNnjqLRqBoaGjR8+HCNHz9elZWVKioqUm1trXJycjR16lT5fI6YeQQAAEt69OihwYMH67PPPtO+ffvU0NAgr9er6upqrioDgONMQo5k7rzzzhafnz179lHPeTwe3XLLLZ0dCQCATsHk9QCAZPLVV1/J6/WqR48eOnjwoD788ENdc801Gjx4sFavXq0RI0ZoxYoVys3NtTsqACCBODUCAIA4YvJ6AEAyiUQiWrhwoRobG2WM0UUXXaTzzz9f/fr1U1FRkV566SUNGDBAo0ePtjsqACCBaCgCABBnxzJ5PQAATnLyySfr17/+9VHPZ2Vl6eGHH7YhEQDACSw3FP/2t7/poosuOur51atXa/jw4XENBQCAnY615h3L5PXxuBvm4Tth+tq5E+aRyzrtbpiS+++ed6RkGQvjcJ5kGUuyjMOpOJYDAMSb5YbiU0891WIR+s1vfkMRAgAklXjVvFgmr4/H3TAP3wkz2s6dMCUp6tC7YUruv3vekZJlLIzDeZJlLMkwjvbuhmknjuUAAPHWbkNx586dkg5dvlVZWdnsgGPnzp3q0qVL56UDACCB4lHzmLweAOAUHMsBADpLuw3FadOmNf3/1KlTm72WkZGhH/zgB/FPBQCADeJR85i8HgDgFBzLAQA6S7sNxd///veSpDlz5ugXv/hFpwcCAMAu8ah5TF4PAHAKjuUAAJ3F8gzsFCAAwPGCmgcASCbUNQBAvFm+KUtlZaX++7//W1u3btX+/fubvfZf//VfcQ8GAIBdqHkAgGRCXQMAxJvlhuJjjz2mrKws/ehHP1LXrl07MxMAALai5gEAkgl1DQAQb5Ybil988YXmzZunlBTLV0kDAOBK1DwAQDKhrgEA4s1yRTnzzDO1devWTowCAIAzUPMAAMmEugYAiDfLZyhmZmbqoYce0gUXXKCMjIxmr1133XVxDwYAgF2oeQCAZEJdAwDEm+WG4oEDB3T++eeroaFBu3fv7sxMAADYipoHAEgm1DUAQLxZbihOmTKlM3MAAOAY1DwAQDKhrgEA4s1yQ3Hnzp2tvpaVlRWXMAAAOAE1DwCQTKhrAIB4s9xQnDZtWquv/f73v49LGAAAnICaBwBIJtQ1AEC8WW4ofrPQ7NmzR6+88orOPPPMYwrwpz/9SaWlpfJ4PDrppJM0ZcoU7dmzR0VFRaqtrVVOTo6mTp0qn89yVAAAjkln1TwAAOxAXQMAxFtKrG/MyMjQjTfeqN/97ncxb7y6ulp//vOfVVBQoPnz56uxsVGrVq3SsmXLNHbsWD3xxBPq0aOHSktLY94GAADHKh41DwAAp6CuAQCOVcwNRUnavn27Dhw4cEwBGhsbdfDgQTU0NOjgwYPKyMhQRUWFhg8fLkkaNWqUysrKjmkbAAAcq3jUPAAAnIK6BgA4FpavI549e7Y8Hk/T4wMHDmjbtm36/ve/H/PGg8GgvvOd7+inP/2punTponPOOUc5OTnq3r27vF5v0zLV1dUtvr+kpEQlJSWSpIKCAoVCoZhy+Hw+BQIB+fyV8kfbWM5/aLmUlGPqw8aVz+eLedxO4Ob8bs4uuTu/m7NL7s7v5uwd0Rk1DwAAu1DXAADxZrmhOHr06GaPU1NTdfLJJ+vEE0+MeeN79+5VWVmZFi5cqO7du2vBggVat26d5feHw2GFw+Gmx1VVVTHlCIVCikQiitZHVV9f3+pyUZ8UiURkjIlpO50hFArFPG4ncHN+N2eX3J3fzdkld+ePV/bs7Ow4pOk8nVHzAACwC3UNABBvlhuKo0aNivvGP/roI/Xp00e9evWSJF144YXasGGD9u3bp4aGBnm9XlVXVysYDMZ92wAAtKYzah4AAHahrgEA4s1yQzEajeq1117TO++8o0gkokAgoJEjR+raa6+N+Q7MoVBIGzdu1IEDB9SlSxd99NFHOvXUUzV48GCtXr1aI0aM0IoVK5SbmxvT+gEAiEVn1DwAAOxCXQMAxJvl6rFs2TJt3rxZP/nJT5SZmaldu3bp1Vdf1b59+3TjjTfGtPFBgwZp+PDhmjFjhrxer0455RSFw2Gdd955Kioq0ksvvaQBAwYcdYo+AACdqTNqHgAAdqGuAQDizXJDcfXq1XrkkUfUs2dPSYfmvxowYIDuvffeYypC48eP1/jx45s9l5WVpYcffjjmdQIAcCw6q+YBAGAH6hoAIN4s367YSTciAQCgM1HzAADJhLoGAIg3y2coXnTRRfrP//xPff/732+6y+err76q4cOHd2Y+AAASjpoHAEgm1DUAQLxZbijm5+fr1Vdf1eLFixWJRBQMBjVixAh973vf68x8AAAkHDUPAJBMqGsAgHhrt6H46aefas2aNcrPz9d1112n6667rum1ZcuW6fPPP9dpp53WqSEBAEgEah4AIJlQ1wAAnaXdORSXL1+us846q8XXvvWtb+m1116LeygAAOxAzQMAJBPqGgCgs7TbUNy6dauGDh3a4mtDhgzRli1b4h4KAAA7UPMAAMmEugYA6CztNhTr6uoUjUZbfK2hoUF1dXVxDwUAgB2oeQCAZEJdAwB0lnYbin379tUHH3zQ4msffPCB+vbtG/dQAADYgZoHAEgm1DUAQGdpt6E4duxYPf3003rvvffU2NgoSWpsbNR7772nZ555RmPHju30kAAAJAI1DwCQTKhrAIDO0u5dni+55BLt2bNHCxcuVH19vXr16qWvvvpKfr9f48eP1yWXXJKInAAAdDpqHgAgmVDXAACdpd2GoiRdffXVGj16tD777DPt3btXaWlpOu2009S9e/fOzgcAQEJR8wAAyeRY61pVVZUWLlyoPXv2yOPxKBwO66qrrtLevXtVWFioXbt2KTMzU9OnT1daWlonjwYA4BSWGoqS1L1791bvEAYAQDKh5gEAksmx1DWv16sbbrhBOTk5qqur08yZM3X22WdrxYoVGjJkiMaNG6fi4mIVFxcrPz8/zskBAE7V7hyKAAAAAIDjUyAQUE5OjiSpW7du6tu3r6qrq1VWVqa8vDxJUl5ensrKyuyMCQBIMBqKAAAAAIB2VVZWasuWLRo4cKBqamoUCAQkSRkZGaqpqbE5HQAgkSxf8gwAANrHXFMAgGS0f/9+zZ8/XzfeeONR8y96PB55PJ4W31dSUqKSkhJJUkFBgUKhUEzb9/l8CgQC8vsq5fe3vpz/X8ulpDjr3Bmfzxfz2J2CMTgDY3AGt48hHvlpKAIAEEfMNQUASDbRaFTz58/XpZdeqgsvvFCSlJ6erkgkokAgoEgkol69erX43nA4rHA43PS4qqoqpgyhUEiRSET10ajq6+tbXa7eL0UiERljYtpOZwmFQjGP3SkYgzMwBmdw+xis5M/Ozm7zdWf92QYAAJdjrikAQDIxxuipp55S3759dfXVVzc9n5ubq5UrV0qSVq5cqWHDhtkVEQBgA9vPUPz666/11FNPadu2bfJ4PPrpT3+q7OxsLgsDALheLHNNxePSsMOXhfnauSzsyGWddmmY5P5LSY6ULGNhHM6TLGNJlnEkow0bNuidd95R//79de+990qSrr/+eo0bN06FhYUqLS1tOmYDABw/bG8oLlmyREOHDtXdd9+taDSqAwcOaPny5VwWBgBwtVjnmorHpWGHLwuLtnNZmCRFHXppmOT+S0mOlCxjYRzOkyxjSYZxtHdpmFudccYZevnll1t8bfbs2QlOAwBwCltPR9i3b58++eQTjR49WtKhv0z26NGDy8IAAK7W1lxTktqcawoAAAAAnM7WhmJlZaV69eqlRYsW6b777tNTTz2l/fv3W74sDAAAp2GuKQAAAADJztZLnhsaGrRlyxbdfPPNGjRokJYsWaLi4uJmy7R1WVg85pmSjphryl8pf7SN5fzOm2fK7fPNuDm/m7NL7s7v5uySu/O7OXuiMNcUAAAAgGRna0Oxd+/e6t27twYNGiRJGj58uIqLi5suCwsEAm1eFhaPeaakI+aaqm97rqmoz3nzTLl9vhk353dzdsnd+d2cXXJ3/nhlT9Z5piTmmgIAAACQ/Gw91S4jI0O9e/fW9u3bJUkfffSR+vXrx2VhAAAAAAAAgEPZfpfnm2++WY8//rii0aj69OmjKVOmyBjDZWEAAAAAAACAA9neUDzllFNUUFBw1PNcFgYAAAAAAAA4j3PuLgIAAAAAAADA8WgoAgAAAAAAALCMhiIAAAAAAAAAy2goAgAAAAAAALCMhiIAAAAAAAAAy2goAgAAAAAAALCMhiIAAAAAAAAAy2goAgAAAAAAALCMhiIAAAAAAAAAy2goAgAAAAAAALCMhiIAAAAAAAAAy2goAgAAAAAAALDMZ3cAAAAAAADiwSPJ4/FYWtYY07lhACCJ0VAEAAAAACSF9FSfFq/dqeq6aJvLBbr5NOm8PjQVASBGNBQBAAAAAEkjUhdV9b56u2MAQFJjDkUAAAAAAAAAltFQBAAAAAAAAGAZDUUAAAAAAAAAljliDsXGxkbNnDlTwWBQM2fOVGVlpYqKilRbW6ucnBxNnTpVPp8jogIAAAAAAADHNUecofjGG2+ob9++TY+XLVumsWPH6oknnlCPHj1UWlpqYzoAAAAAAAAAh9neUNy9e7fKy8s1ZswYSZIxRhUVFRo+fLgkadSoUSorK7MzIgAAAAAAAIB/sf064qVLlyo/P191dXWSpNraWnXv3l1er1eSFAwGVV1d3eJ7S0pKVFJSIkkqKChQKBSKKYPP51MgEJDPXyl/tI3l/IeWS0mxvQ/bxOfzxTxuJ3Bzfjdnl9yd383ZJXfnd3N2AAAAu3k8HkvLGWM6OQkAHBtbG4pr165Venq6cnJyVFFR0eH3h8NhhcPhpsdVVVUx5QiFQopEIorWR1VfX9/qclGfFIlEHPXlHgqFYh63E7g5v5uzS+7O7+bskrvzxyt7dnZ2HNIAAAC4h8fj0eLySkXq2jiLRVKgm0+TzuvjqONOAPgmWxuKGzZs0Jo1a/T+++/r4MGDqqur09KlS7Vv3z41NDTI6/WqurpawWDQzpgAAAAAAByzSF1U1ftaP4kFANzC1obihAkTNGHCBElSRUWFXn/9dU2bNk0LFizQ6tWrNWLECK1YsUK5ubl2xgQAAAAAAADwL86ZDPAIEydO1J/+9CdNnTpVe/fu1ejRo+2OBAAAAAAAAEAOuCnLYYMHD9bgwYMlSVlZWXr44YdtTgQAAAAAAADgmxzTUAQAAAAAOMuiRYtUXl6u9PR0zZ8/X5K0d+9eFRYWateuXcrMzNT06dOVlpZmc1IAQCI58pJnAAAAAID9Ro0apVmzZjV7rri4WEOGDNHjjz+uIUOGqLi42KZ0AAC70FAEACCOFi1apFtuuUV3331303N79+7VvHnzNG3aNM2bN0979+61MSEAANadddZZR519WFZWpry8PElSXl6eysrK7IgGALARDUUAAOKIMzkAAMmupqZGgUBAkpSRkaGamhqbEwEAEo05FAEAiKOzzjpLlZWVzZ4rKyvT3LlzJR06k2Pu3LnKz8+3IR0AAPHl8Xjk8Xhafb2kpEQlJSWSpIKCAoVCoZi24/P5FAgE5PdVyu9vazmvfF7T5jKS5P/X+lJSEnOOjdX8dmSzyufzxfzzcwrG4AyMwX7xyE9DEQCATtaRMzniceB1+KDFZ+GgxefQgxbJ/b+oHSlZxsI4nCdZxpIs4zhepKenKxKJKBAIKBKJqFevXq0uGw6HFQ6Hmx5XVVXFtM1QKKRIJKL6aFT19fWtLheN+hRtaGhzGUmq90uRSETGmJjydJTV/HZksyoUCsX883MKxuAMjMF+VvJnZ2e3+ToNRQAAEqi9MzniceB1+KAlauGgJerQgxbJ/b+oHSlZxsI4nCdZxpIM42jvwCuZ5ObmauXKlRo3bpxWrlypYcOG2R0JAJBgNBQBAOhkHTmTAwAAJykqKtL69etVW1uryZMna/z48Ro3bpwKCwtVWlqqzMxMTZ8+3e6YAIAEo6EIAEAn40wOAIBb3XnnnS0+P3v27AQnAQA4CQ1FAADiyG1ncnikNi/BPpITL4sGAAAAkHg0FAEAiCO3ncmR3s2n366tVHVd23MtBrr5dfN5mTQVAQAAANBQBADgeBepq9fufW03FAEAAADgsBS7AwAAAAAAAABwD85QBAAAtmhv7sbGxkbL8zsexiXZAAAAQOejoQgAABLO4/Hot+W7FGlj7kafr1J903yqPdDQ7hyPEvM8AgAAAIlCQ7EDuBMmAADx097cjX6/lOaXauqizPEIAAAAOAgNxQ5IT/Xp2TU7FamLtrlcRjefbjm/D01FAAAAAHA5TioBgKPZ2lCsqqrSwoULtWfPHnk8HoXDYV111VXau3evCgsLtWvXLmVmZmr69OlKS0uzM2qTPXVRS5ddAQAAAADczePxaHF5ZbsnlQS6+TTpPE4qAXD8sLWh6PV6dcMNNygnJ0d1dXWaOXOmzj77bK1YsUJDhgzRuHHjVFxcrOLiYuXn59sZtVPwly4AAAAAcLZIXVTVTL0BAM3Y2lAMBAIKBAKSpG7duqlv376qrq5WWVmZ5s6dK0nKy8vT3Llzk66h6PF49OzaSu3h8mkAAAAAAAC4iGPmUKysrNSWLVs0cOBA1dTUNDUaMzIyVFNT0+J7SkpKVFJSIkkqKChQKBSKads+n0+BQEA+f6X8bfT3vH6vvFEjv7+d9fkPrS8lJaXVZRobG7U3WqnatvuJ8kXV5rp8Pl/M43YCN+d3c3bJ3fndnF1yd343ZwcAADheWbk6zsknsXB1H+A8jmgo7t+/X/Pnz9eNN96o7t27N3vN4/G0+uURDocVDoebHldVVcW0/VAopEgkomh9VPX1rZ/K3lDvU0O0oc1lJCnqkyKRSJtfZh6Pp93tSVKDT9qzZ0+r6woEAu1u65vbbU8iv4RDoVDMPze7uTm75O78bs4uuTt/vLJnZ2fHIQ0AAADaY2UeSCfPAck8loAz2d5QjEajmj9/vi699FJdeOGFkqT09HRFIpGmZlmvXr1sTmmf9u4s7fNXKs0nS5dFW7nMmkusAQAAACC5uH0eSLfnB5KRrQ1FY4yeeuop9e3bV1dffXXT87m5uVq5cqXGjRunlStXatiwYTamtF9bd5b2Rw+dERmPdQEAAAAAAADtsbWhuGHDBr3zzjvq37+/7r33XknS9ddfr3HjxqmwsFClpaXKzMzU9OnT7YwJAAAAAAAA4F9sbSieccYZevnll1t8bfbs2QlO414eWZsb0epEtgAAAAAAAEBrbJ9DEceuvXkWDzspo6toKQIAAAAAAOBY0FBMElbmRsxI5ccNAAAAAACAY5NidwAAAAAAAAAA7sEpawAAIK6Y1xcAgORltYYbYzo5Sec7nsYKdBQNRQAAEDcej0e/Ld+lSDvTcJyckcq8vgAAuIzH49Hi8sp25+8PdPNp0nl9XN1oO57GCsSChiIAAIirSF29du9rZ17fbvwKAgCAG0Xqoqpup84ni+NprEBHMYciAAAAAAAAAMs4PQCdqr05JxobG+XxeDg9HAAcziPmRowHp8/FRN0GgNi0VycPf3/GY11Hitf3sZVtdmQMHdp2O+tMlt8tnP47ANBRNBQ7gZUv42T5UmyLx+PRs2srtaeNOSd8/kr19Em35Ga1+8XJFysA2Ce9m0+/XVupauZGjJnV+SUD3fy6+bzMhNc9K/l8vkr19HtsyQcATpae6tPitTtV3cqxj99Xqew0r6Ua2d66Dovn3H1WttmRMVhlZZ7CkzO6uv53C+ZjRDKiodgJ0lN9enbNzja/LE5Kgi9FK/bURds8+PRHpbS09vdXRjefbjmfL1agJfy1E4nC3IjHzso+tFN7+fx+Kdr2sRAAHLfamm/P75d6dKBE2jF3X3vb7OgY4rXdjNTk+N2C+RiRbJLjX6YDtddIS5YvxXhpb38BaJmVM4ElmvIAAAAAgPihq4WYcVk34Aw05AEAAI4/Tp7f2MnZrG7Xqfuto3NZuv2EAq7GOppT9gkNRcTEyllRdl3WbeUflx1fNk7NFU/HwxgBOFdnTGLvlF/YWuP0fHbh5jKt4zMDJA+rcy3aMQehk7NZnc/Qqfvt8FyWtQcaEjrPph2Ye/JoTtonNBQRMyde1m2l0Rno5rN0ExgpjndNs5DLyZekWv0L3jNrdrp2jMnOaqOFnw3czOqNY6ze9CQZbqIi2ZfPLtxcpnV8ZoDkY2VePrum2yJbbKzOZVmz//iYk5G5J4/mlH1CQxFJx0qjs72bwEjxb3659bJUq3P0nZTRVTUuHePxwMrNomj4IhnE+6Ynbr+JyvGKm8u0js8MAACIBxqKcIV4z8ERz+ZevHJ1xqV68WJlf9l1Rmp74nlZoxMvle/I/Cnt/Rw7MmcLTUcAAOBmTp/jDx3XGfMPxmu7ts0VaXHbyTIVjB2cehyZCDQU4QpWzq6S4jtvY3tfvo2NjUpJSWn3Ml+ruayOkbPIDonnZeTxviTdyi8yViR6rlIrn0Gfv1JpPvEZhKs5/SAy3vnsHK+TDzw68oe8jkiGgzI7/8h5vM2DCvs4eY4/xKYj8w/G82dqZbt2fY6sZLM6156T5u5zCiv7JJn3Bw1FNOPkg6xEnyXXXnPF56/UiT28li7ztZorkWdOWv3rXDx/1vE+QInHGXf61zLxXFd7TebMntW6cWhvS0U70XOVtrc9f1SKUjngclbnWjw5I9WeX/7jnM+u8Tp9vr6O7JdDE9+3X5+TZX7OeM9HalW894vT9zPs5+R59BAbq/MPJnq7dn6O4jnfnlPm7nOS43mfOPrbcd26dVqyZIkaGxs1ZswYjRs3zu5ISc+OMwGdrK3mij8qpXkTHEjWT6lvr6l1uCG690BDmz/vRJ8BJ8XvLMx4fp47sq72msy9e3bl39lxirrmHFbmkcvoZucv//HNZ9d4nT5fn9X9UlMXjfs4kmHfuGG7Tt/PbkddA4Djl2Mbio2NjVq8eLEeeOAB9e7dW/fff79yc3PVr18/u6MlPafOl4dDrDS2rDS1DjdEa/Y76wy4eIvn59mp64I7UNcAAMmEugYAxzfHHq1u2rRJJ5xwgrKysiRJF198scrKyjq1QLX3l/meqV55PFJ750xZWS5e6/L5fY7MZXUZq/mdOEY79/3eAw3tLHXo8+zWfZ/Rzdfu/JUej8eV/2YlqVdXnxqjDY7LZfXfbJpjK4ez2VHXAt387S6T3tWnFHna/QzZsZzP57O8PrsySof2s9VpJpLhZ9LT77E8BYSV8VrZfx1hZbsd+Wx15DNodSzx3DcducFAvD+D8fzZdeTfSGfsZ3ScHXVNOjQfWVvSU71KsfC7UaKX8/t8js1mdRm7xhDPdTGGowXaOfY67NB3avsHAlbW15Hpt+K1zXj7/3Wr7XzxztaRfdLZPMahk4WsXr1a69at0+TJkyVJ77zzjjZu3KhJkyY1LVNSUqKSkhJJUkFBgS05AQCwwkpdk6htAAB3oK4BwPEtxe4AxyIcDqugoOCYC9PMmTPjlCjx3Jxdcnd+N2eX3J3fzdkld+d3c3a3iEdtS5afU7KMQ0qesTAO50mWsSTLOHA0jtkOcXt+iTE4BWNwBrePIR75HdtQDAaD2r17d9Pj3bt3KxgM2pgIAIDYUdcAAMmEugYAxzfHNhRPPfVU7dixQ5WVlYpGo1q1apVyc3PtjgUAQEyoawCAZEJdA4Djm3fu3Llz7Q7RkpSUFJ1wwgl64okn9Oabb+rSSy/V8OHDO217OTk5nbbuzubm7JK787s5u+Tu/G7OLrk7v5uz24m6FptkGYeUPGNhHM6TLGNJlnEcLxJd1yT3f0bcnl9iDE7BGJzB7WM41vyOvSkLAAAAAAAAAOdx7CXPAAAAAAAAAJyHhiIAAAAAAAAAy3x2B7DTunXrtGTJEjU2NmrMmDEaN26c3ZHaVFVVpYULF2rPnj3yeDwKh8O66qqr9PLLL+svf/mLevXqJUm6/vrrdd5559mc9mi33XabUlNTlZKSIq/Xq4KCAu3du1eFhYXatWuXMjMzNX36dKWlpdkd9Sjbt29XYWFh0+PKykqNHz9eX3/9tSP3/aJFi1ReXq709HTNnz9fklrd18YYLVmyRO+//766du2qKVOm2D4XREv5X3jhBa1du1Y+n09ZWVmaMmWKevToocrKSk2fPl3Z2dmSpEGDBunWW291VPa2/o0uX75cpaWlSklJ0U033aShQ4fall1qOX9hYaG2b98uSdq3b5+6d++uRx55xHH7Hoe4rbYd5vYadyQ317sjua32HcntdfAwN9fDb3J7fYR93FjXkqWmub2eubWOub2GJUPtSoaalZDjOnOcamhoMLfffrv58ssvTX19vbnnnnvMtm3b7I7VpurqarN582ZjjDH79u0z06ZNM9u2bTO///3vzR/+8Aeb07VvypQppqamptlzL7zwglm+fLkxxpjly5ebF154wY5oHdLQ0GBuueUWU1lZ6dh9X1FRYTZv3mzuuuuupuda29dr1641Dz30kGlsbDQbNmww999/vy2Zj9RS/nXr1ploNGqMOTSWw/l3U3iuZQAABqRJREFU7tzZbDm7tZS9tc/Jtm3bzD333GMOHjxodu7caW6//XbT0NCQyLhHaSn/kZ577jnzyiuvGGOct+/hztp2mNtr3JGSpd4dyQ2170hur4OHubkefpPb6yPs4da6liw1LZnqmZvqmNtrWDLUrmSoWYk4rjtuL3netGmTTjjhBGVlZcnn+3/t3T1ME38cx/HPtX80NCGFqxWUSCJPCS7GpI1JBYlPTE5EjToYJocOJi66sQiTNpr4EBcH3WDAOLqokICGik9EJYoPW0MDRyoxNrFwDuTuf9a2/5o/cPf99fOaaHPDNz8O3tzv2vIPYrEYksmk22OVVFdXZ99tqK6uRmNjIwzDcHmq/yeZTKK7uxsA0N3d7fnvAQBMT0+joaEB4XDY7VGK2rVr1x93Cout9fPnz7F//35omob29nZ8//4di4uLGz6zU6H5d+/eDb/fDwBob2/37LlfaPZikskkYrEYqqqqsHXrVjQ0NGB2dnadJyyt1PymaeLp06fYt2/fBk9F5ZLYNouKjXOS2DsnCe1zkt5Bi+Qe5pPeR3KH1K6p3DSpPZPUMekNU6FdKjRrI67rKvYtz4ZhIBQK2Y9DoRA+fvzo4kR/J51O48uXL2htbcXMzAwePnyIsbExNDc348yZM5592fng4CAA4MiRIzh8+DAymQzq6uoAALW1tchkMm6OV5bx8fHffvCkrH2xtTYMA1u2bLGPC4VCMAzDPtaLHj16hFgsZj9Op9O4cOECqqurcfLkSXR0dLg4XWGFzhPDMNDW1mYfo+u6p+P6/v17BINBbNu2zX5OwtpXEults0htnJMKvXOS2j4nlTpokdjDfCr0kdaPCl2T3jRVeia9Yyo1THK7VGnWWl3XVeyGomTZbBaJRAJ9fX0IBALo6enBsWPHAABDQ0O4d+8e4vG4y1P+6dKlS9B1HZlMBgMDA/b78y2apkHTNJemK08ul8PU1BROnz4NAGLWPp+EtS5mZGQEfr8fXV1dAFbvAN+6dQs1NTX4/PkzLl++jEQigUAg4PKk/5J6nuTL/0NMwtqTPFIb56RC75xUaZ+TtO9BIRJ7mE+Fc4moFOlNU6VnqnVMyroXIrld0s8bp7W6rqvYtzzruo6FhQX78cLCAnRdd3Gi8uRyOSQSCXR1dWHv3r0AVu9Q+Hw++Hw+HDp0CJ8+fXJ5ysKs9Q0Gg4hGo5idnUUwGLRfkr24uGh/wKlXvXz5Ejt37kRtbS0AOWsPoOha67qO+fl5+zgv/yw8efIEU1NTOHfunB3Rqqoq1NTUAACam5tRX1+PVCrl5ph/KHae5P8eMgzDs2u/vLyMycnJ3+4mSlj7SiO1bRbJjXNSoXdOktvnpEIHLVJ7mE+FPtL6ktw1FZqmSs9U6JgKDZPeLlWatZbXdRW7odjS0oJUKoV0Oo1cLoeJiQlEIhG3xyrJNE3cvn0bjY2NOHr0qP288zMSJicnsWPHDjfGKymbzeLHjx/212/evEFTUxMikQhGR0cBAKOjo4hGo26O+Z/yd/IlrL2l2FpHIhGMjY3BNE18+PABgUDAky+Rf/XqFR48eICLFy9i8+bN9vPfvn3DysoKAGBubg6pVAr19fVujVlQsfMkEolgYmICP3/+RDqdRiqVQmtrq1tjljQ9PY3t27f/9rYjCWtfaSS2zSK5cU6q9M5JcvucpHfQIrmH+VToI60vqV1ToWkq9UyFjklvmArtUqVZa3ldp5mmaa7bpB734sUL3L17FysrKzhw4AB6e3vdHqmkmZkZ9Pf3o6mpyd7RP3XqFMbHx/H161domoZwOIyzZ8967pfI3Nwcrly5AmB1R7yzsxO9vb1YWlrC1atXMT8/j3A4jPPnz3v28yuy2Szi8Thu3Lhhv/T3+vXrnlz7a9eu4d27d1haWkIwGMSJEycQjUYLrrVpmrhz5w5ev36NTZs2IR6Po6WlxXPz379/H7lczj4/rH9l/+zZMwwPD8Pv98Pn8+H48eOu/qFZaPa3b98WPU9GRkbw+PFj+Hw+9PX1Yc+ePa7NXmz+gwcP4ubNm2hra0NPT499rNfWnlZJa5tFcuOcVOidk6T2OUnvoEVyD/NJ7yO5R2LXVGiaKj2T2DHpDVOhXSo0ayOu6yp6Q5GIiIiIiIiIiIj+TsW+5ZmIiIiIiIiIiIj+HjcUiYiIiIiIiIiIqGzcUCQiIiIiIiIiIqKycUORiIiIiIiIiIiIysYNRSIiIiIiIiIiIiobNxSJiIiIiIiIiIiobNxQJCIiIiIiIiIiorL9Au8MgXlSSxxVAAAAAElFTkSuQmCC\n","text/plain":["
"]},"metadata":{}}]},{"cell_type":"markdown","metadata":{"id":"EvI27BXG0SdB"},"source":["# Transformer building block"]},{"cell_type":"code","metadata":{"id":"iFGqpGW-vesT"},"source":["def get_angles(pos, i, d_model):\n"," angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))\n"," return pos * angle_rates\n","def positional_encoding(position, d_model):\n"," angle_rads = get_angles(np.arange(position)[:, np.newaxis],\n"," np.arange(d_model)[np.newaxis, :],\n"," d_model)\n","\n"," # apply sin to even indices in the array; 2i\n"," angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])\n","\n"," # apply cos to odd indices in the array; 2i+1\n"," angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])\n","\n"," pos_encoding = angle_rads[np.newaxis, ...]\n","\n"," return tf.cast(pos_encoding, dtype=tf.float32) "],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"Vh7DUDJ8KP_J"},"source":["def create_padding_mask(seq):\n"," seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\n","\n"," # add extra dimensions to add the padding\n"," # to the attention logits.\n"," return seq[:, tf.newaxis, tf.newaxis, :] # (batch_size, 1, 1, seq_len)\n","def create_look_ahead_mask(size):\n"," mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)\n"," return mask # (seq_len, seq_len)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"Y1a0X7sz79fs"},"source":["def scaled_dot_product_attention(q, k, v, mask):\n"," \"\"\"Calculate the attention weights.\n"," q, k, v must have matching leading dimensions.\n"," k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.\n"," The mask has different shapes depending on its type(padding or look ahead)\n"," but it must be broadcastable for addition.\n","\n"," Args:\n"," q: query shape == (..., seq_len_q, depth)\n"," k: key shape == (..., seq_len_k, depth)\n"," v: value shape == (..., seq_len_v, depth_v)\n"," mask: Float tensor with shape broadcastable\n"," to (..., seq_len_q, seq_len_k). Defaults to None.\n","\n"," Returns:\n"," output, attention_weights\n"," \"\"\"\n","\n"," matmul_qk = tf.matmul(q, k, transpose_b=True) # (..., seq_len_q, seq_len_k)\n","\n"," # scale matmul_qk\n"," dk = tf.cast(tf.shape(k)[-1], tf.float32)\n"," scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n","\n"," # add the mask to the scaled tensor.\n"," if mask is not None:\n"," scaled_attention_logits += (mask * -1e9)\n","\n"," # softmax is normalized on the last axis (seq_len_k) so that the scores\n"," # add up to 1.\n"," attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1) # (..., seq_len_q, seq_len_k)\n","\n"," output = tf.matmul(attention_weights, v) # (..., seq_len_q, depth_v)\n","\n"," return output, attention_weights"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"iPGM326S74cQ"},"source":["def print_out(q, k, v):\n"," temp_out, temp_attn = scaled_dot_product_attention(\n"," q, k, v, None)\n"," print('Attention weights are:')\n"," print(temp_attn)\n"," print('Output is:')\n"," print(temp_out)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"ulnTf9fq7wFg"},"source":["class Defined_MultiHeadAttention(tf.keras.layers.Layer):\n"," def __init__(self, d_model, num_heads):\n"," super(Defined_MultiHeadAttention, self).__init__()\n"," self.num_heads = num_heads\n"," self.d_model = d_model\n","\n"," assert d_model % self.num_heads == 0\n","\n"," self.depth = d_model // self.num_heads\n","\n"," self.wq = tf.keras.layers.Dense(d_model)\n"," self.wk = tf.keras.layers.Dense(d_model)\n"," self.wv = tf.keras.layers.Dense(d_model)\n","\n"," self.dense = tf.keras.layers.Dense(d_model)\n","\n"," def split_heads(self, x, batch_size):\n"," \"\"\"Split the last dimension into (num_heads, depth).\n"," Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth)\n"," \"\"\"\n"," x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))\n"," return tf.transpose(x, perm=[0, 2, 1, 3])\n","\n"," def call(self, v, k, q, mask):\n"," batch_size = tf.shape(q)[0]\n","\n"," q = self.wq(q) # (batch_size, seq_len, d_model)\n"," k = self.wk(k) # (batch_size, seq_len, d_model)\n"," v = self.wv(v) # (batch_size, seq_len, d_model)\n","\n"," q = self.split_heads(q, batch_size) # (batch_size, num_heads, seq_len_q, depth)\n"," k = self.split_heads(k, batch_size) # (batch_size, num_heads, seq_len_k, depth)\n"," v = self.split_heads(v, batch_size) # (batch_size, num_heads, seq_len_v, depth)\n","\n"," # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth)\n"," # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k)\n"," scaled_attention, attention_weights = scaled_dot_product_attention(\n"," q, k, v, mask)\n","\n"," scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) # (batch_size, seq_len_q, num_heads, depth)\n","\n"," concat_attention = tf.reshape(scaled_attention,\n"," (batch_size, -1, self.d_model)) # (batch_size, seq_len_q, d_model)\n","\n"," output = self.dense(concat_attention) # (batch_size, seq_len_q, d_model)\n","\n"," return output, attention_weights"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"ow6JEMF9siun"},"source":["def point_wise_feed_forward_network(d_model, dff):\n"," return tf.keras.Sequential([\n"," tf.keras.layers.Dense(dff, activation='relu'), # (batch_size, seq_len, dff)\n"," tf.keras.layers.Dense(d_model) # (batch_size, seq_len, d_model)\n"," ])"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"HB6bBjGptPHe"},"source":["class EncoderLayer(tf.keras.layers.Layer):\n"," def __init__(self, d_model, num_heads, dff, rate=0.1):\n"," super(EncoderLayer, self).__init__()\n","\n"," self.mha = Defined_MultiHeadAttention(d_model, num_heads)\n"," self.ffn = point_wise_feed_forward_network(d_model, dff)\n","\n"," self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)\n"," self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)\n","\n"," self.dropout1 = layers.Dropout(rate)\n"," self.dropout2 = layers.Dropout(rate)\n","\n"," def call(self, x, training, mask):\n","\n"," attn_output, _ = self.mha(x, x, x, mask) # (batch_size, input_seq_len, d_model)\n"," attn_output = self.dropout1(attn_output, training=training)\n"," out1 = self.layernorm1(x + attn_output) # (batch_size, input_seq_len, d_model)\n","\n"," ffn_output = self.ffn(out1) # (batch_size, input_seq_len, d_model)\n"," ffn_output = self.dropout2(ffn_output, training=training)\n"," out2 = self.layernorm2(out1 + ffn_output) # (batch_size, input_seq_len, d_model)\n","\n"," return out2"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"eAX5mgzwuIzp"},"source":["class DecoderLayer(tf.keras.layers.Layer):\n"," def __init__(self, d_model, num_heads, dff, rate=0.1):\n"," super(DecoderLayer, self).__init__()\n","\n"," self.mha1 = Defined_MultiHeadAttention(d_model, num_heads)\n"," self.mha2 = Defined_MultiHeadAttention(d_model, num_heads)\n","\n"," self.ffn = point_wise_feed_forward_network(d_model, dff)\n","\n"," self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)\n"," self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)\n"," self.layernorm3 = layers.LayerNormalization(epsilon=1e-6)\n","\n"," self.dropout1 = layers.Dropout(rate)\n"," self.dropout2 = layers.Dropout(rate)\n"," self.dropout3 = layers.Dropout(rate)\n","\n"," def call(self, x, enc_output, training,\n"," look_ahead_mask, padding_mask):\n"," # enc_output.shape == (batch_size, input_seq_len, d_model)\n","\n"," attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask) # (batch_size, target_seq_len, d_model)\n"," attn1 = self.dropout1(attn1, training=training)\n"," out1 = self.layernorm1(attn1 + x)\n","\n"," attn2, attn_weights_block2 = self.mha2(\n"," enc_output, enc_output, out1, padding_mask) # (batch_size, target_seq_len, d_model)\n"," attn2 = self.dropout2(attn2, training=training)\n"," out2 = self.layernorm2(attn2 + out1) # (batch_size, target_seq_len, d_model)\n","\n"," ffn_output = self.ffn(out2) # (batch_size, target_seq_len, d_model)\n"," ffn_output = self.dropout3(ffn_output, training=training)\n"," out3 = self.layernorm3(ffn_output + out2) # (batch_size, target_seq_len, d_model)\n","\n"," return out3, attn_weights_block1, attn_weights_block2"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"2Y1RwhoUu_6u"},"source":["class Encoder(tf.keras.layers.Layer):\n"," def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size,\n"," maximum_position_encoding, rate=0.1):\n"," super(Encoder, self).__init__()\n","\n"," self.d_model = d_model\n"," self.num_layers = num_layers\n","\n"," self.embedding = layers.Embedding(input_vocab_size, d_model)\n"," self.pos_encoding = positional_encoding(maximum_position_encoding,\n"," self.d_model)\n","\n"," self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate)\n"," for _ in range(num_layers)]\n","\n"," self.dropout = tf.keras.layers.Dropout(rate)\n","\n"," def call(self, x, training, mask):\n","\n"," seq_len = tf.shape(x)[1]\n","\n"," # adding embedding and position encoding.\n"," x = self.embedding(x) # (batch_size, input_seq_len, d_model)\n"," x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n"," x += self.pos_encoding[:, :seq_len, :]\n","\n"," x = self.dropout(x, training=training)\n","\n"," for i in range(self.num_layers):\n"," x = self.enc_layers[i](x, training, mask)\n","\n"," return x # (batch_size, input_seq_len, d_model)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"collapsed":true,"id":"vREtcc6U0SdC"},"source":["METRICS = [\n"," keras.metrics.TruePositives(name='tp'),\n"," keras.metrics.FalsePositives(name='fp'),\n"," keras.metrics.TrueNegatives(name='tn'),\n"," keras.metrics.FalseNegatives(name='fn'), \n"," keras.metrics.BinaryAccuracy(name='accuracy'),\n"," keras.metrics.Precision(name='precision'),\n"," keras.metrics.Recall(name='recall'),\n"," keras.metrics.AUC(name='auc'),\n"," keras.metrics.AUC(name='prc', curve='PR'), # precision-recall curve\n","]\n","\n"," "],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"-IZsy2Na4Kbg"},"source":["\n","def create_mlp(dim=30):\n","\t# define our MLP network\n","\tmodel = Sequential()\n","\tmodel.add(Dense(dim, activation=\"relu\"))\n","\tmodel.add(Dense(dim, activation=\"relu\"))\n","\n","\treturn model"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"yFjQdoX_278O"},"source":["#Building transformer encoder+ MLP"]},{"cell_type":"code","metadata":{"id":"J3pQ1mQUvAWz"},"source":["def build_t_encoder(\n"," num_layers,\n"," d_model,\n"," num_heads,\n"," dff,\n"," input_vocab_size,\n"," maximum_position_encoding,\n"," training=True,\n"," rate=0.1\n","):\n"," inputs = keras.layers.Input(shape=(30,))\n"," x=inputs\n"," enc_padding_mask = create_padding_mask(inputs)\n"," encoder = Encoder(num_layers, d_model, num_heads, dff,input_vocab_size, maximum_position_encoding, rate)\n"," x = encoder(x,training,enc_padding_mask)\n"," x = layers.GlobalAveragePooling1D(data_format=\"channels_first\")(x)\n"," t_encoder = keras.Model(inputs, x)\n"," # for dim in mlp_units:\n"," # x = layers.Dense(dim, activation=\"relu\")(x)\n"," # x = layers.Dropout(rate)(x)\n"," # outputs = layers.Dense(n_classes, activation=\"softmax\")(x)\n"," return t_encoder"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"TFSz2Fl9ZKeu"},"source":["## CDR model"]},{"cell_type":"code","metadata":{"id":"kjP2idIOCqN8"},"source":["def CDR_model(mlp_units,n_classes,rate=0.1,max_length=30):\n"," input1=keras.layers.Input(shape=(30,))\n"," input2=keras.layers.Input(shape=(30,))\n"," input3=keras.layers.Input(shape=(30,))\n"," input4=keras.layers.Input(shape=(30,))\n"," input5=keras.layers.Input(shape=(30,))\n"," input6=keras.layers.Input(shape=(30,))\n","\n"," encoder1=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input1)\n"," encoder2=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input2)\n"," encoder3=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input3)\n"," encoder4=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input4)\n"," encoder5=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input5)\n"," encoder6=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input6)\n","\n","\n"," x = Concatenate()([encoder1, encoder2,encoder3, encoder4,encoder5, encoder6])\n"," for dim in mlp_units:\n"," x = layers.Dense(dim, activation=\"relu\")(x)\n"," x = layers.Dropout(rate)(x)\n"," outputs = layers.Dense(n_classes, activation=\"sigmoid\")(x)\n"," return keras.Model([input1,input2,input3,input4,input5,input6],outputs)"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"p3bdQz7dvNnP","executionInfo":{"status":"ok","timestamp":1642741869020,"user_tz":360,"elapsed":185263,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"d82c2991-c4be-48cf-a4ac-c0e949da6055"},"source":["\n","CDR_model = CDR_model(mlp_units=[512,128,64],n_classes=1)\n","CDR_model.compile(\n"," loss=keras.losses.BinaryCrossentropy(),\n"," optimizer=keras.optimizers.Adam(learning_rate=1e-4),\n"," metrics=METRICS,\n",")\n","CDR_model.summary()\n","\n","callbacks = [keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]\n","\n","CDR_history=CDR_model.fit(\n"," [train_x1,train_x2,train_x3,train_x4,train_x5,train_x6], y_train,\n"," epochs=100, batch_size=256,\n"," validation_data=([val_x1,val_x2,val_x3,val_x4,val_x5,val_x6], y_val),\n"," callbacks=callbacks,\n",")\n"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Model: \"model_27\"\n","__________________________________________________________________________________________________\n"," Layer (type) Output Shape Param # Connected to \n","==================================================================================================\n"," input_37 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_38 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_39 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_40 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_41 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_42 (InputLayer) [(None, 30)] 0 [] \n"," \n"," model_21 (Functional) (None, 30) 1588480 ['input_37[0][0]'] \n"," \n"," model_22 (Functional) (None, 30) 1588480 ['input_38[0][0]'] \n"," \n"," model_23 (Functional) (None, 30) 1588480 ['input_39[0][0]'] \n"," \n"," model_24 (Functional) (None, 30) 1588480 ['input_40[0][0]'] \n"," \n"," model_25 (Functional) (None, 30) 1588480 ['input_41[0][0]'] \n"," \n"," model_26 (Functional) (None, 30) 1588480 ['input_42[0][0]'] \n"," \n"," concatenate_3 (Concatenate) (None, 180) 0 ['model_21[0][0]', \n"," 'model_22[0][0]', \n"," 'model_23[0][0]', \n"," 'model_24[0][0]', \n"," 'model_25[0][0]', \n"," 'model_26[0][0]'] \n"," \n"," dense_588 (Dense) (None, 512) 92672 ['concatenate_3[0][0]'] \n"," \n"," dropout_225 (Dropout) (None, 512) 0 ['dense_588[0][0]'] \n"," \n"," dense_589 (Dense) (None, 128) 65664 ['dropout_225[0][0]'] \n"," \n"," dropout_226 (Dropout) (None, 128) 0 ['dense_589[0][0]'] \n"," \n"," dense_590 (Dense) (None, 64) 8256 ['dropout_226[0][0]'] \n"," \n"," dropout_227 (Dropout) (None, 64) 0 ['dense_590[0][0]'] \n"," \n"," dense_591 (Dense) (None, 1) 65 ['dropout_227[0][0]'] \n"," \n","==================================================================================================\n","Total params: 9,697,537\n","Trainable params: 9,697,537\n","Non-trainable params: 0\n","__________________________________________________________________________________________________\n","Epoch 1/100\n","12/12 [==============================] - 38s 844ms/step - loss: 0.6908 - tp: 2477.0000 - fp: 874.0000 - tn: 421.0000 - fn: 287.0000 - accuracy: 0.7140 - precision: 0.7392 - recall: 0.8962 - auc: 0.6555 - prc: 0.7988 - val_loss: 0.6871 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.7099\n","Epoch 2/100\n","12/12 [==============================] - 3s 277ms/step - loss: 0.6831 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.5030 - prc: 0.7167 - val_loss: 0.6766 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.7099\n","Epoch 3/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.6701 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.4831 - prc: 0.7034 - val_loss: 0.6588 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.7099\n","Epoch 4/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.6484 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.5070 - prc: 0.7136 - val_loss: 0.6333 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.7099\n","Epoch 5/100\n","12/12 [==============================] - 3s 273ms/step - loss: 0.6220 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.5083 - prc: 0.7108 - val_loss: 0.6088 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.7099\n","Epoch 6/100\n","12/12 [==============================] - 3s 276ms/step - loss: 0.6064 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.4867 - prc: 0.7025 - val_loss: 0.6023 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.7099\n","Epoch 7/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.6032 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.5090 - prc: 0.7171 - val_loss: 0.6005 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.6649 - val_prc: 0.8277\n","Epoch 8/100\n","12/12 [==============================] - 3s 276ms/step - loss: 0.5970 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.5954 - prc: 0.7768 - val_loss: 0.5867 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.8044 - val_prc: 0.8961\n","Epoch 9/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.5767 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.7513 - prc: 0.8720 - val_loss: 0.5550 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.8399 - val_prc: 0.9205\n","Epoch 10/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.5443 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.8047 - prc: 0.8975 - val_loss: 0.5323 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.8484 - val_prc: 0.9269\n","Epoch 11/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.5149 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.8217 - prc: 0.9134 - val_loss: 0.4905 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.8518 - val_prc: 0.9301\n","Epoch 12/100\n","12/12 [==============================] - 3s 278ms/step - loss: 0.4831 - tp: 2102.0000 - fp: 861.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.7094 - precision: 0.7094 - recall: 1.0000 - auc: 0.8461 - prc: 0.9278 - val_loss: 0.4887 - val_tp: 526.0000 - val_fp: 215.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.7099 - val_precision: 0.7099 - val_recall: 1.0000 - val_auc: 0.8337 - val_prc: 0.9173\n","Epoch 13/100\n","12/12 [==============================] - 3s 276ms/step - loss: 0.4702 - tp: 2072.0000 - fp: 722.0000 - tn: 139.0000 - fn: 30.0000 - accuracy: 0.7462 - precision: 0.7416 - recall: 0.9857 - auc: 0.8416 - prc: 0.9236 - val_loss: 0.4771 - val_tp: 512.0000 - val_fp: 164.0000 - val_tn: 51.0000 - val_fn: 14.0000 - val_accuracy: 0.7598 - val_precision: 0.7574 - val_recall: 0.9734 - val_auc: 0.8304 - val_prc: 0.9186\n","Epoch 14/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.4607 - tp: 2038.0000 - fp: 603.0000 - tn: 258.0000 - fn: 64.0000 - accuracy: 0.7749 - precision: 0.7717 - recall: 0.9696 - auc: 0.8471 - prc: 0.9261 - val_loss: 0.4617 - val_tp: 507.0000 - val_fp: 140.0000 - val_tn: 75.0000 - val_fn: 19.0000 - val_accuracy: 0.7854 - val_precision: 0.7836 - val_recall: 0.9639 - val_auc: 0.8417 - val_prc: 0.9231\n","Epoch 15/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.4678 - tp: 1948.0000 - fp: 489.0000 - tn: 372.0000 - fn: 154.0000 - accuracy: 0.7830 - precision: 0.7993 - recall: 0.9267 - auc: 0.8293 - prc: 0.9179 - val_loss: 0.4562 - val_tp: 483.0000 - val_fp: 110.0000 - val_tn: 105.0000 - val_fn: 43.0000 - val_accuracy: 0.7935 - val_precision: 0.8145 - val_recall: 0.9183 - val_auc: 0.8408 - val_prc: 0.9267\n","Epoch 16/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.4520 - tp: 1910.0000 - fp: 397.0000 - tn: 464.0000 - fn: 192.0000 - accuracy: 0.8012 - precision: 0.8279 - recall: 0.9087 - auc: 0.8434 - prc: 0.9242 - val_loss: 0.4367 - val_tp: 498.0000 - val_fp: 106.0000 - val_tn: 109.0000 - val_fn: 28.0000 - val_accuracy: 0.8192 - val_precision: 0.8245 - val_recall: 0.9468 - val_auc: 0.8597 - val_prc: 0.9335\n","Epoch 17/100\n","12/12 [==============================] - 3s 273ms/step - loss: 0.4308 - tp: 1900.0000 - fp: 351.0000 - tn: 510.0000 - fn: 202.0000 - accuracy: 0.8134 - precision: 0.8441 - recall: 0.9039 - auc: 0.8620 - prc: 0.9347 - val_loss: 0.4223 - val_tp: 494.0000 - val_fp: 92.0000 - val_tn: 123.0000 - val_fn: 32.0000 - val_accuracy: 0.8327 - val_precision: 0.8430 - val_recall: 0.9392 - val_auc: 0.8706 - val_prc: 0.9386\n","Epoch 18/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.4103 - tp: 1904.0000 - fp: 316.0000 - tn: 545.0000 - fn: 198.0000 - accuracy: 0.8265 - precision: 0.8577 - recall: 0.9058 - auc: 0.8775 - prc: 0.9436 - val_loss: 0.4048 - val_tp: 486.0000 - val_fp: 77.0000 - val_tn: 138.0000 - val_fn: 40.0000 - val_accuracy: 0.8421 - val_precision: 0.8632 - val_recall: 0.9240 - val_auc: 0.8798 - val_prc: 0.9410\n","Epoch 19/100\n","12/12 [==============================] - 3s 276ms/step - loss: 0.3860 - tp: 1917.0000 - fp: 290.0000 - tn: 571.0000 - fn: 185.0000 - accuracy: 0.8397 - precision: 0.8686 - recall: 0.9120 - auc: 0.8928 - prc: 0.9511 - val_loss: 0.3986 - val_tp: 500.0000 - val_fp: 85.0000 - val_tn: 130.0000 - val_fn: 26.0000 - val_accuracy: 0.8502 - val_precision: 0.8547 - val_recall: 0.9506 - val_auc: 0.8883 - val_prc: 0.9433\n","Epoch 20/100\n","12/12 [==============================] - 3s 277ms/step - loss: 0.3726 - tp: 1891.0000 - fp: 264.0000 - tn: 597.0000 - fn: 211.0000 - accuracy: 0.8397 - precision: 0.8775 - recall: 0.8996 - auc: 0.8975 - prc: 0.9553 - val_loss: 0.3932 - val_tp: 464.0000 - val_fp: 57.0000 - val_tn: 158.0000 - val_fn: 62.0000 - val_accuracy: 0.8394 - val_precision: 0.8906 - val_recall: 0.8821 - val_auc: 0.8867 - val_prc: 0.9459\n","Epoch 21/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.3574 - tp: 1892.0000 - fp: 221.0000 - tn: 640.0000 - fn: 210.0000 - accuracy: 0.8545 - precision: 0.8954 - recall: 0.9001 - auc: 0.9046 - prc: 0.9572 - val_loss: 0.3722 - val_tp: 489.0000 - val_fp: 66.0000 - val_tn: 149.0000 - val_fn: 37.0000 - val_accuracy: 0.8610 - val_precision: 0.8811 - val_recall: 0.9297 - val_auc: 0.8970 - val_prc: 0.9468\n","Epoch 22/100\n","12/12 [==============================] - 3s 274ms/step - loss: 0.3432 - tp: 1898.0000 - fp: 230.0000 - tn: 631.0000 - fn: 204.0000 - accuracy: 0.8535 - precision: 0.8919 - recall: 0.9029 - auc: 0.9133 - prc: 0.9621 - val_loss: 0.3619 - val_tp: 482.0000 - val_fp: 63.0000 - val_tn: 152.0000 - val_fn: 44.0000 - val_accuracy: 0.8556 - val_precision: 0.8844 - val_recall: 0.9163 - val_auc: 0.9004 - val_prc: 0.9496\n","Epoch 23/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.3300 - tp: 1917.0000 - fp: 216.0000 - tn: 645.0000 - fn: 185.0000 - accuracy: 0.8647 - precision: 0.8987 - recall: 0.9120 - auc: 0.9180 - prc: 0.9625 - val_loss: 0.3620 - val_tp: 471.0000 - val_fp: 58.0000 - val_tn: 157.0000 - val_fn: 55.0000 - val_accuracy: 0.8475 - val_precision: 0.8904 - val_recall: 0.8954 - val_auc: 0.8995 - val_prc: 0.9507\n","Epoch 24/100\n","12/12 [==============================] - 3s 265ms/step - loss: 0.3233 - tp: 1910.0000 - fp: 194.0000 - tn: 667.0000 - fn: 192.0000 - accuracy: 0.8697 - precision: 0.9078 - recall: 0.9087 - auc: 0.9203 - prc: 0.9633 - val_loss: 0.3679 - val_tp: 496.0000 - val_fp: 74.0000 - val_tn: 141.0000 - val_fn: 30.0000 - val_accuracy: 0.8596 - val_precision: 0.8702 - val_recall: 0.9430 - val_auc: 0.9013 - val_prc: 0.9512\n","Epoch 25/100\n","12/12 [==============================] - 3s 277ms/step - loss: 0.3025 - tp: 1931.0000 - fp: 185.0000 - tn: 676.0000 - fn: 171.0000 - accuracy: 0.8799 - precision: 0.9126 - recall: 0.9186 - auc: 0.9311 - prc: 0.9691 - val_loss: 0.3539 - val_tp: 476.0000 - val_fp: 57.0000 - val_tn: 158.0000 - val_fn: 50.0000 - val_accuracy: 0.8556 - val_precision: 0.8931 - val_recall: 0.9049 - val_auc: 0.9033 - val_prc: 0.9513\n","Epoch 26/100\n","12/12 [==============================] - 3s 267ms/step - loss: 0.3025 - tp: 1933.0000 - fp: 206.0000 - tn: 655.0000 - fn: 169.0000 - accuracy: 0.8734 - precision: 0.9037 - recall: 0.9196 - auc: 0.9296 - prc: 0.9681 - val_loss: 0.3590 - val_tp: 465.0000 - val_fp: 55.0000 - val_tn: 160.0000 - val_fn: 61.0000 - val_accuracy: 0.8435 - val_precision: 0.8942 - val_recall: 0.8840 - val_auc: 0.9009 - val_prc: 0.9494\n","Epoch 27/100\n","12/12 [==============================] - 3s 265ms/step - loss: 0.2931 - tp: 1899.0000 - fp: 156.0000 - tn: 705.0000 - fn: 203.0000 - accuracy: 0.8788 - precision: 0.9241 - recall: 0.9034 - auc: 0.9347 - prc: 0.9712 - val_loss: 0.3742 - val_tp: 505.0000 - val_fp: 86.0000 - val_tn: 129.0000 - val_fn: 21.0000 - val_accuracy: 0.8556 - val_precision: 0.8545 - val_recall: 0.9601 - val_auc: 0.9035 - val_prc: 0.9487\n","Epoch 28/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.2901 - tp: 1956.0000 - fp: 209.0000 - tn: 652.0000 - fn: 146.0000 - accuracy: 0.8802 - precision: 0.9035 - recall: 0.9305 - auc: 0.9354 - prc: 0.9706 - val_loss: 0.3510 - val_tp: 469.0000 - val_fp: 51.0000 - val_tn: 164.0000 - val_fn: 57.0000 - val_accuracy: 0.8543 - val_precision: 0.9019 - val_recall: 0.8916 - val_auc: 0.9059 - val_prc: 0.9533\n","Epoch 29/100\n","12/12 [==============================] - 3s 265ms/step - loss: 0.2721 - tp: 1946.0000 - fp: 158.0000 - tn: 703.0000 - fn: 156.0000 - accuracy: 0.8940 - precision: 0.9249 - recall: 0.9258 - auc: 0.9430 - prc: 0.9746 - val_loss: 0.3524 - val_tp: 486.0000 - val_fp: 61.0000 - val_tn: 154.0000 - val_fn: 40.0000 - val_accuracy: 0.8637 - val_precision: 0.8885 - val_recall: 0.9240 - val_auc: 0.9046 - val_prc: 0.9478\n","Epoch 30/100\n","12/12 [==============================] - 3s 264ms/step - loss: 0.2563 - tp: 1970.0000 - fp: 154.0000 - tn: 707.0000 - fn: 132.0000 - accuracy: 0.9035 - precision: 0.9275 - recall: 0.9372 - auc: 0.9497 - prc: 0.9781 - val_loss: 0.3805 - val_tp: 498.0000 - val_fp: 79.0000 - val_tn: 136.0000 - val_fn: 28.0000 - val_accuracy: 0.8556 - val_precision: 0.8631 - val_recall: 0.9468 - val_auc: 0.9083 - val_prc: 0.9497\n","Epoch 31/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.2490 - tp: 1970.0000 - fp: 166.0000 - tn: 695.0000 - fn: 132.0000 - accuracy: 0.8994 - precision: 0.9223 - recall: 0.9372 - auc: 0.9522 - prc: 0.9778 - val_loss: 0.3520 - val_tp: 485.0000 - val_fp: 59.0000 - val_tn: 156.0000 - val_fn: 41.0000 - val_accuracy: 0.8650 - val_precision: 0.8915 - val_recall: 0.9221 - val_auc: 0.9015 - val_prc: 0.9467\n","Epoch 32/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.2412 - tp: 1973.0000 - fp: 144.0000 - tn: 717.0000 - fn: 129.0000 - accuracy: 0.9079 - precision: 0.9320 - recall: 0.9386 - auc: 0.9544 - prc: 0.9797 - val_loss: 0.3700 - val_tp: 501.0000 - val_fp: 73.0000 - val_tn: 142.0000 - val_fn: 25.0000 - val_accuracy: 0.8677 - val_precision: 0.8728 - val_recall: 0.9525 - val_auc: 0.9135 - val_prc: 0.9569\n","Epoch 33/100\n","12/12 [==============================] - 3s 275ms/step - loss: 0.2313 - tp: 1976.0000 - fp: 132.0000 - tn: 729.0000 - fn: 126.0000 - accuracy: 0.9129 - precision: 0.9374 - recall: 0.9401 - auc: 0.9577 - prc: 0.9809 - val_loss: 0.3414 - val_tp: 489.0000 - val_fp: 57.0000 - val_tn: 158.0000 - val_fn: 37.0000 - val_accuracy: 0.8731 - val_precision: 0.8956 - val_recall: 0.9297 - val_auc: 0.9104 - val_prc: 0.9501\n","Epoch 34/100\n","12/12 [==============================] - 3s 276ms/step - loss: 0.2184 - tp: 1992.0000 - fp: 136.0000 - tn: 725.0000 - fn: 110.0000 - accuracy: 0.9170 - precision: 0.9361 - recall: 0.9477 - auc: 0.9630 - prc: 0.9835 - val_loss: 0.3291 - val_tp: 500.0000 - val_fp: 59.0000 - val_tn: 156.0000 - val_fn: 26.0000 - val_accuracy: 0.8853 - val_precision: 0.8945 - val_recall: 0.9506 - val_auc: 0.9188 - val_prc: 0.9577\n","Epoch 35/100\n","12/12 [==============================] - 3s 265ms/step - loss: 0.2114 - tp: 1990.0000 - fp: 129.0000 - tn: 732.0000 - fn: 112.0000 - accuracy: 0.9187 - precision: 0.9391 - recall: 0.9467 - auc: 0.9646 - prc: 0.9841 - val_loss: 0.3491 - val_tp: 490.0000 - val_fp: 55.0000 - val_tn: 160.0000 - val_fn: 36.0000 - val_accuracy: 0.8772 - val_precision: 0.8991 - val_recall: 0.9316 - val_auc: 0.9138 - val_prc: 0.9525\n","Epoch 36/100\n","12/12 [==============================] - 3s 264ms/step - loss: 0.2071 - tp: 1989.0000 - fp: 118.0000 - tn: 743.0000 - fn: 113.0000 - accuracy: 0.9220 - precision: 0.9440 - recall: 0.9462 - auc: 0.9664 - prc: 0.9845 - val_loss: 0.3577 - val_tp: 507.0000 - val_fp: 74.0000 - val_tn: 141.0000 - val_fn: 19.0000 - val_accuracy: 0.8745 - val_precision: 0.8726 - val_recall: 0.9639 - val_auc: 0.9176 - val_prc: 0.9579\n","Epoch 37/100\n","12/12 [==============================] - 3s 267ms/step - loss: 0.1975 - tp: 2001.0000 - fp: 122.0000 - tn: 739.0000 - fn: 101.0000 - accuracy: 0.9247 - precision: 0.9425 - recall: 0.9520 - auc: 0.9696 - prc: 0.9862 - val_loss: 0.3369 - val_tp: 497.0000 - val_fp: 67.0000 - val_tn: 148.0000 - val_fn: 29.0000 - val_accuracy: 0.8704 - val_precision: 0.8812 - val_recall: 0.9449 - val_auc: 0.9205 - val_prc: 0.9585\n","Epoch 38/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.1836 - tp: 2008.0000 - fp: 112.0000 - tn: 749.0000 - fn: 94.0000 - accuracy: 0.9305 - precision: 0.9472 - recall: 0.9553 - auc: 0.9741 - prc: 0.9887 - val_loss: 0.3521 - val_tp: 486.0000 - val_fp: 56.0000 - val_tn: 159.0000 - val_fn: 40.0000 - val_accuracy: 0.8704 - val_precision: 0.8967 - val_recall: 0.9240 - val_auc: 0.9179 - val_prc: 0.9573\n","Epoch 39/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.1713 - tp: 2018.0000 - fp: 93.0000 - tn: 768.0000 - fn: 84.0000 - accuracy: 0.9403 - precision: 0.9559 - recall: 0.9600 - auc: 0.9763 - prc: 0.9895 - val_loss: 0.3902 - val_tp: 506.0000 - val_fp: 79.0000 - val_tn: 136.0000 - val_fn: 20.0000 - val_accuracy: 0.8664 - val_precision: 0.8650 - val_recall: 0.9620 - val_auc: 0.9103 - val_prc: 0.9482\n","Epoch 40/100\n","12/12 [==============================] - 3s 265ms/step - loss: 0.1711 - tp: 2017.0000 - fp: 103.0000 - tn: 758.0000 - fn: 85.0000 - accuracy: 0.9366 - precision: 0.9514 - recall: 0.9596 - auc: 0.9757 - prc: 0.9884 - val_loss: 0.3684 - val_tp: 488.0000 - val_fp: 57.0000 - val_tn: 158.0000 - val_fn: 38.0000 - val_accuracy: 0.8718 - val_precision: 0.8954 - val_recall: 0.9278 - val_auc: 0.9085 - val_prc: 0.9484\n","Epoch 41/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.1474 - tp: 2034.0000 - fp: 79.0000 - tn: 782.0000 - fn: 68.0000 - accuracy: 0.9504 - precision: 0.9626 - recall: 0.9676 - auc: 0.9820 - prc: 0.9914 - val_loss: 0.3979 - val_tp: 495.0000 - val_fp: 66.0000 - val_tn: 149.0000 - val_fn: 31.0000 - val_accuracy: 0.8691 - val_precision: 0.8824 - val_recall: 0.9411 - val_auc: 0.9055 - val_prc: 0.9450\n","Epoch 42/100\n","12/12 [==============================] - 3s 264ms/step - loss: 0.1563 - tp: 2027.0000 - fp: 91.0000 - tn: 770.0000 - fn: 75.0000 - accuracy: 0.9440 - precision: 0.9570 - recall: 0.9643 - auc: 0.9796 - prc: 0.9900 - val_loss: 0.3849 - val_tp: 487.0000 - val_fp: 61.0000 - val_tn: 154.0000 - val_fn: 39.0000 - val_accuracy: 0.8650 - val_precision: 0.8887 - val_recall: 0.9259 - val_auc: 0.9140 - val_prc: 0.9548\n","Epoch 43/100\n","12/12 [==============================] - 3s 266ms/step - loss: 0.1553 - tp: 2028.0000 - fp: 95.0000 - tn: 766.0000 - fn: 74.0000 - accuracy: 0.9430 - precision: 0.9553 - recall: 0.9648 - auc: 0.9790 - prc: 0.9891 - val_loss: 0.3740 - val_tp: 477.0000 - val_fp: 55.0000 - val_tn: 160.0000 - val_fn: 49.0000 - val_accuracy: 0.8596 - val_precision: 0.8966 - val_recall: 0.9068 - val_auc: 0.9116 - val_prc: 0.9522\n","Epoch 44/100\n","12/12 [==============================] - 3s 278ms/step - loss: 0.1468 - tp: 2033.0000 - fp: 74.0000 - tn: 787.0000 - fn: 69.0000 - accuracy: 0.9517 - precision: 0.9649 - recall: 0.9672 - auc: 0.9811 - prc: 0.9907 - val_loss: 0.3964 - val_tp: 492.0000 - val_fp: 64.0000 - val_tn: 151.0000 - val_fn: 34.0000 - val_accuracy: 0.8677 - val_precision: 0.8849 - val_recall: 0.9354 - val_auc: 0.9123 - val_prc: 0.9528\n"]}]},{"cell_type":"markdown","metadata":{"id":"1UUAsd3X0SdD"},"source":["### Plot loss functions\n","\n"]},{"cell_type":"code","metadata":{"id":"qP0Q151IkjSl"},"source":["plt.style.use('ggplot')\n","def plot_loss(history, label, n):\n"," # Use a log scale on y-axis to show the wide range of values.\n"," plt.semilogy(history.epoch, history.history['loss'],\n"," color=colors[n], label='Train ' + label)\n"," plt.semilogy(history.epoch, history.history['val_loss'],\n"," color=colors[n], label='Val ' + label,\n"," linestyle=\"--\")\n"," plt.xlabel('Epoch')\n"," plt.ylabel('Loss')\n","def plot_metrics(history):\n"," metrics = ['loss', 'prc', 'precision', 'recall']\n"," for n, metric in enumerate(metrics):\n"," name = metric.replace(\"_\",\" \").capitalize()\n"," plt.subplot(2,2,n+1)\n"," plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')\n"," plt.plot(history.epoch, history.history['val_'+metric],\n"," color=colors[0], linestyle=\"--\", label='Val')\n"," plt.xlabel('Epoch')\n"," plt.ylabel(name)\n"," if metric == 'loss':\n"," plt.ylim([0, plt.ylim()[1]])\n"," elif metric == 'auc':\n"," plt.ylim([0.8,1])\n"," else:\n"," plt.ylim([0,1])\n","\n"," plt.legend()\n","def plot_cm(labels, predictions, p=0.5):\n"," cm = confusion_matrix(labels, predictions > p)\n"," plt.figure(figsize=(5,5))\n"," sns.heatmap(cm, annot=True, fmt=\"d\")\n"," plt.title('Confusion matrix @{:.2f}'.format(p))\n"," plt.ylabel('Actual label')\n"," plt.xlabel('Predicted label')\n"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"collapsed":true,"scrolled":true,"id":"-yyt-qUM0SdD","colab":{"base_uri":"https://localhost:8080/","height":286},"executionInfo":{"status":"ok","timestamp":1642741922163,"user_tz":360,"elapsed":46577,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"cf2708c0-13d2-405a-e1e3-e38ed18ca2ac"},"source":["colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n","plot_metrics(CDR_history)"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"IubzpbWPCrtr","colab":{"base_uri":"https://localhost:8080/","height":939},"executionInfo":{"status":"ok","timestamp":1642741944698,"user_tz":360,"elapsed":1745,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"39f25954-7786-4ae5-871b-db078409246e"},"source":["y_pred=CDR_model.predict([test_x1,test_x2,test_x3,test_x4,test_x5,test_x6])\n","\n","con_mat = confusion_matrix(y_test, y_pred >0.5)\n","con_mat_norm = np.around(con_mat.astype('float') / con_mat.sum(axis=1)[:, np.newaxis], decimals=2)\n","\n","con_mat_df = pd.DataFrame(con_mat_norm,\n"," index = le.classes_, \n"," columns = le.classes_)\n","figure = plt.figure(figsize=(8, 8))\n","sns.heatmap(con_mat_df, annot=True,cmap=plt.cm.Blues)\n","plt.tight_layout()\n","plt.ylabel('True label')\n","plt.xlabel('Predicted label')\n","\n","plot_cm(labels=y_test, predictions=y_pred)"],"execution_count":null,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{}},{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{}}]},{"cell_type":"markdown","metadata":{"id":"EgtfvUnoOxSe"},"source":["## Saving model"]},{"cell_type":"code","metadata":{"id":"cNSsQyzKaUvs","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642742311698,"user_tz":360,"elapsed":72172,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"98e68550-3e43-4037-faf0-10bd7b5fc506"},"source":["# saving model weights.\n","CDR_model.save('./Model/RBD_HA_CDR_model')\n","# load model\n","# CDR_model = keras.models.load_model('./Model/RBD_HA_CDR_model')"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stderr","text":["WARNING:absl:Found untraced functions such as embedding_18_layer_call_fn, embedding_18_layer_call_and_return_conditional_losses, dropout_179_layer_call_fn, dropout_179_layer_call_and_return_conditional_losses, embedding_19_layer_call_fn while saving (showing 5 of 1260). These functions will not be directly callable after loading.\n"]},{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: ./Model/RBD_HA_new_CDR_model/assets\n"]},{"output_type":"stream","name":"stderr","text":["INFO:tensorflow:Assets written to: ./Model/RBD_HA_new_CDR_model/assets\n"]}]},{"cell_type":"markdown","metadata":{"id":"_ww5F8FS0SdD"},"source":["## Evaluate results"]},{"cell_type":"code","metadata":{"id":"NUQfbVN8koaK"},"source":["# Utility function: Display model score(Loss & Accuracy and so on) across all sets.\n","\n","def display_model_score(model, train, val, test, batch_size):\n","\n"," train_score = model.evaluate(train[0], train[1], batch_size=batch_size, verbose=1)\n"," print('Train loss: ', train_score[0])\n"," print('Train accuracy: ', train_score[5])\n"," print('Train Precision: ', train_score[6])\n"," print('Train Recall: ', train_score[7])\n"," print('Train AUC: ', train_score[8])\n"," print('Train PRC: ', train_score[9])\n"," print('-'*70)\n","\n"," val_score = model.evaluate(val[0], val[1], batch_size=batch_size, verbose=1)\n"," print('Val loss: ', val_score[0])\n"," print('Val accuracy: ', val_score[5])\n"," print('Val Precision: ', val_score[6])\n"," print('Val Recall: ', val_score[7])\n"," print('Val AUC: ', val_score[8])\n"," print('Val PRC: ', val_score[9])\n"," print('-'*70)\n"," \n"," test_score = model.evaluate(test[0], test[1], batch_size=batch_size, verbose=1)\n"," print('Test loss: ', test_score[0])\n"," print('Test accuracy: ', test_score[5])\n"," print('Test Precision: ', test_score[6])\n"," print('Test Recall: ', test_score[7])\n"," print('Test AUC: ', test_score[8])\n"," print('Test PRC: ', test_score[9])"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"_ct8BQbSkMlO","executionInfo":{"status":"ok","timestamp":1642741968623,"user_tz":360,"elapsed":2543,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"22e6a339-2568-43c9-ef99-e76f6e6a79b1"},"source":["display_model_score(CDR_model,\n"," [[train_x1,train_x2,train_x3,train_x4,train_x5,train_x6], y_train],\n"," [[val_x1,val_x2,val_x3,val_x4,val_x5,val_x6], y_val],\n"," [[test_x1,test_x2,test_x3,test_x4,test_x5,test_x6], y_test],\n"," 256)\n"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["12/12 [==============================] - 1s 94ms/step - loss: 0.2019 - tp: 2015.0000 - fp: 140.0000 - tn: 721.0000 - fn: 87.0000 - accuracy: 0.9234 - precision: 0.9350 - recall: 0.9586 - auc: 0.9695 - prc: 0.9866\n","Train loss: 0.20186258852481842\n","Train accuracy: 0.9233884811401367\n","Train Precision: 0.9350348114967346\n","Train Recall: 0.9586108326911926\n","Train AUC: 0.9695322513580322\n","Train PRC: 0.9866031408309937\n","----------------------------------------------------------------------\n","3/3 [==============================] - 0s 90ms/step - loss: 0.3492 - tp: 497.0000 - fp: 69.0000 - tn: 146.0000 - fn: 29.0000 - accuracy: 0.8677 - precision: 0.8781 - recall: 0.9449 - auc: 0.9159 - prc: 0.9574\n","Val loss: 0.3491574227809906\n","Val accuracy: 0.8677462935447693\n","Val Precision: 0.8780918717384338\n","Val Recall: 0.9448668956756592\n","Val AUC: 0.915947437286377\n","Val PRC: 0.9574365019798279\n","----------------------------------------------------------------------\n","4/4 [==============================] - 0s 93ms/step - loss: 0.3433 - tp: 603.0000 - fp: 77.0000 - tn: 203.0000 - fn: 44.0000 - accuracy: 0.8695 - precision: 0.8868 - recall: 0.9320 - auc: 0.9170 - prc: 0.9550\n","Test loss: 0.3433356285095215\n","Test accuracy: 0.8694714307785034\n","Test Precision: 0.8867647051811218\n","Test Recall: 0.931993842124939\n","Test AUC: 0.9170456528663635\n","Test PRC: 0.9550190567970276\n"]}]},{"cell_type":"code","metadata":{"id":"YJk8AsVzTdoy"},"source":["#load model\n","CDR_model = keras.models.load_model('./Model/RBD_HA_CDR_model')"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Model evaluation and export on Spike-HA dataset"],"metadata":{"id":"Q_G6Qa5zRBcd"}},{"cell_type":"code","metadata":{"id":"Lu4TIRL_Y4oy"},"source":["def eval_model(model, train, val, test, batch_size):\n"," train_score = model.evaluate(train[0], train[1], batch_size=batch_size, verbose=1)\n"," val_score = model.evaluate(val[0], val[1], batch_size=batch_size, verbose=1)\n"," test_score = model.evaluate(test[0], test[1], batch_size=batch_size, verbose=1)\n"," return [train_score,val_score,test_score]\n"],"execution_count":null,"outputs":[]},{"cell_type":"code","metadata":{"id":"McG2sywkgNW1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642742544959,"user_tz":360,"elapsed":2435,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"67451bcd-d1ea-48a0-c49c-9b5d2334e4b3"},"source":["cdr_ls = eval_model(CDR_model,\n"," [[train_x1,train_x2,train_x3,train_x4,train_x5,train_x6], y_train],\n"," [[val_x1,val_x2,val_x3,val_x4,val_x5,val_x6], y_val],\n"," [[test_x1,test_x2,test_x3,test_x4,test_x5,test_x6], y_test],\n"," 256)\n","cdr_df = pd.DataFrame(cdr_ls, columns =['loss','tp', 'fp' , 'tn','fn', 'accuracy','precision', 'recall','AUC','PRC'], index=['train set','val set','test set'],dtype = float) "],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["12/12 [==============================] - 1s 96ms/step - loss: 0.2040 - tp: 2013.0000 - fp: 141.0000 - tn: 720.0000 - fn: 89.0000 - accuracy: 0.9224 - precision: 0.9345 - recall: 0.9577 - auc: 0.9688 - prc: 0.9861\n","3/3 [==============================] - 0s 90ms/step - loss: 0.3413 - tp: 494.0000 - fp: 61.0000 - tn: 154.0000 - fn: 32.0000 - accuracy: 0.8745 - precision: 0.8901 - recall: 0.9392 - auc: 0.9149 - prc: 0.9544\n","4/4 [==============================] - 0s 91ms/step - loss: 0.3499 - tp: 600.0000 - fp: 74.0000 - tn: 206.0000 - fn: 47.0000 - accuracy: 0.8695 - precision: 0.8902 - recall: 0.9274 - auc: 0.9184 - prc: 0.9600\n"]}]},{"cell_type":"code","metadata":{"id":"Cn-n6_XJecYr"},"source":["\n","cdr_df.to_csv('result/evaluation/RBD-HA_CDR_model_evaluation.csv')"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Prediction on Momsen and HIV dataset"],"metadata":{"id":"uQ6MsPNmOiqV"}},{"cell_type":"code","metadata":{"id":"NLotiMS0DUby","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1642742733992,"user_tz":360,"elapsed":222,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"4fd4636e-3ad6-4d49-ae9a-d1b97e88758d"},"source":["data_path = 'data/Momsen_HIV_Abs.xlsx'\n","Momsen_df = pd.read_excel(data_path)\n","\n","[Momsen_test_x1,Momsen_test_x2,Momsen_test_x3,Momsen_test_x4,Momsen_test_x5,Momsen_test_x6]=encode_six_CDR(Momsen_df)\n","\n","print(Momsen_test_x1.shape)\n"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["(162, 30)\n"]}]},{"cell_type":"code","metadata":{"id":"Usc-bDsJEnne"},"source":["y_pred=CDR_model.predict([Momsen_test_x1,Momsen_test_x2,Momsen_test_x3,Momsen_test_x4,Momsen_test_x5,Momsen_test_x6])\n","# print(y_pred)\n","\n","Momsen_df['probability_Spike']=pd.Series(y_pred.flatten())\n","Momsen_df['Prediction']=np.where(Momsen_df['probability_Spike'] > 0.5, 'Spike', 'HA')\n","Momsen_df.to_excel('result/evaluation/Momsen_HIV_Abs_prediction_by_RBD-HA_model.xlsx')"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"4tP0SEVq5alC"},"source":["## Test on HIV dataset"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"g65-fzXC5eJ8","executionInfo":{"status":"ok","timestamp":1642743006380,"user_tz":360,"elapsed":1659,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"ec81a094-e3e7-47d1-d5b1-c60a51604242"},"source":["data_path = 'data/HIV_Abs_from_GB_v4_full_CDR.xlsx'\n","\n","raw_df = pd.read_excel(data_path)\n","raw_df=raw_df[raw_df[['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA']].notnull().all(1)]\n","cleaned_df = raw_df[['Name','CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA','VH Genbank ID','VL Genbank ID']].copy()\n","\n","#deduplication\n","HIV_df = cleaned_df.drop_duplicates(subset=['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA'])\n","\n","[HIV_test_x1,HIV_test_x2,HIV_test_x3,HIV_test_x4,HIV_test_x5,HIV_test_x6]=encode_six_CDR(HIV_df)\n","\n","HIV_y_pred=CDR_model.predict([HIV_test_x1,HIV_test_x2,HIV_test_x3,HIV_test_x4,HIV_test_x5,HIV_test_x6])\n","# print(HIV_y_pred)\n","HIV_df=HIV_df.reset_index()\n","HIV_df['probability_Spike']=pd.Series(HIV_y_pred.flatten())\n","print(HIV_df['probability_Spike'])\n","HIV_df['Prediction']=np.where(HIV_df['probability_Spike'] > 0.5, 'Spike', 'HA')\n","\n","HIV_df.to_excel('./result/evaluation/HIV_dataset_prediction_by_RBD-HA_model.xlsx')"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["0 0.593477\n","1 0.974983\n","2 0.092957\n","3 0.064527\n","4 0.534932\n"," ... \n","686 0.187647\n","687 0.977179\n","688 0.996910\n","689 0.996684\n","690 0.512793\n","Name: probability_Spike, Length: 691, dtype: float32\n"]}]}]} \ No newline at end of file +{"nbformat":4,"nbformat_minor":0,"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.6.2"},"colab":{"name":"RBD_HA_classifier.ipynb","provenance":[],"collapsed_sections":["8LlD-Llz0SdA","DasHlLjt467U","EvI27BXG0SdB","TFSz2Fl9ZKeu"]},"accelerator":"GPU"},"cells":[{"cell_type":"code","metadata":{"id":"EMWCby8OfwMI","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1643864800643,"user_tz":360,"elapsed":797,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"29650196-f00d-49ca-e464-691bd20c18f9"},"source":["#set the colab to access the google drive\n","from google.colab import drive\n","drive.mount('/content/drive/')\n","import os\n","os.chdir(\"drive/MyDrive/Colab Notebooks/CoV_Encoder\")"],"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Drive already mounted at /content/drive/; to attempt to forcibly remount, call drive.mount(\"/content/drive/\", force_remount=True).\n"]}]},{"cell_type":"code","metadata":{"collapsed":true,"id":"yzYyFtE90Sc1","executionInfo":{"status":"ok","timestamp":1643864809645,"user_tz":360,"elapsed":5646,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["#import package\n","import tensorflow as tf\n","from tensorflow import keras\n","\n","import os\n","import tempfile\n","\n","import matplotlib as mpl\n","import matplotlib.pyplot as plt\n","import numpy as np\n","import pandas as pd\n","import seaborn as sns\n","import sklearn\n","\n","from sklearn.metrics import confusion_matrix\n","from sklearn.model_selection import train_test_split\n","from keras.preprocessing.sequence import pad_sequences\n","from keras.models import Sequential\n","from keras.layers import Dense\n","\n","from sklearn.preprocessing import LabelEncoder\n","from tensorflow.keras.utils import to_categorical\n","from tensorflow.keras import layers\n","from tensorflow.keras.layers import Concatenate\n","from sklearn.utils import shuffle\n","\n","%matplotlib inline"],"execution_count":2,"outputs":[]},{"cell_type":"code","source":["pip install openpyxl==3.0.9"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":278},"id":"C7X1V_oWzFN0","executionInfo":{"status":"ok","timestamp":1643864777605,"user_tz":360,"elapsed":3801,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"f66f7c0a-9531-4d90-9b2c-c80908cebaae"},"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["Collecting openpyxl==3.0.9\n"," Downloading openpyxl-3.0.9-py2.py3-none-any.whl (242 kB)\n","\u001b[?25l\r\u001b[K |█▍ | 10 kB 27.9 MB/s eta 0:00:01\r\u001b[K |██▊ | 20 kB 18.4 MB/s eta 0:00:01\r\u001b[K |████ | 30 kB 9.9 MB/s eta 0:00:01\r\u001b[K |█████▍ | 40 kB 8.4 MB/s eta 0:00:01\r\u001b[K |██████▊ | 51 kB 7.1 MB/s eta 0:00:01\r\u001b[K |████████▏ | 61 kB 6.9 MB/s eta 0:00:01\r\u001b[K |█████████▌ | 71 kB 6.7 MB/s eta 0:00:01\r\u001b[K |██████████▉ | 81 kB 7.5 MB/s eta 0:00:01\r\u001b[K |████████████▏ | 92 kB 6.3 MB/s eta 0:00:01\r\u001b[K |█████████████▌ | 102 kB 6.5 MB/s eta 0:00:01\r\u001b[K |██████████████▉ | 112 kB 6.5 MB/s eta 0:00:01\r\u001b[K |████████████████▎ | 122 kB 6.5 MB/s eta 0:00:01\r\u001b[K |█████████████████▋ | 133 kB 6.5 MB/s eta 0:00:01\r\u001b[K |███████████████████ | 143 kB 6.5 MB/s eta 0:00:01\r\u001b[K |████████████████████▎ | 153 kB 6.5 MB/s eta 0:00:01\r\u001b[K |█████████████████████▋ | 163 kB 6.5 MB/s eta 0:00:01\r\u001b[K |███████████████████████ | 174 kB 6.5 MB/s eta 0:00:01\r\u001b[K |████████████████████████▍ | 184 kB 6.5 MB/s eta 0:00:01\r\u001b[K |█████████████████████████▊ | 194 kB 6.5 MB/s eta 0:00:01\r\u001b[K |███████████████████████████ | 204 kB 6.5 MB/s eta 0:00:01\r\u001b[K |████████████████████████████▍ | 215 kB 6.5 MB/s eta 0:00:01\r\u001b[K |█████████████████████████████▊ | 225 kB 6.5 MB/s eta 0:00:01\r\u001b[K |███████████████████████████████▏| 235 kB 6.5 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 242 kB 6.5 MB/s \n","\u001b[?25hRequirement already satisfied: et-xmlfile in /usr/local/lib/python3.7/dist-packages (from openpyxl==3.0.9) (1.1.0)\n","Installing collected packages: openpyxl\n"," Attempting uninstall: openpyxl\n"," Found existing installation: openpyxl 2.5.9\n"," Uninstalling openpyxl-2.5.9:\n"," Successfully uninstalled openpyxl-2.5.9\n","Successfully installed openpyxl-3.0.9\n"]},{"output_type":"display_data","data":{"application/vnd.colab-display-data+json":{"pip_warning":{"packages":["openpyxl"]}}},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"JaZYMn1l0SdA","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1643864820103,"user_tz":360,"elapsed":5675,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"9ee0c8e6-7864-4b7c-b17a-fd03bd9defcc"},"source":["# Read a file and split into train,validation,test sets\n","\n","data_path = 'data/RBD-HA_new_full_CDR.xlsx'\n","raw_df = pd.read_excel(data_path)\n","raw_df=raw_df[raw_df[['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA']].notnull().all(1)]\n","cleaned_df = raw_df[['Name','cluster','Antigen','Resources','CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA','VH Genbank ID','VL Genbank ID']].copy()\n","\n","#deduplication\n","cleaned_df = cleaned_df.drop_duplicates(subset=['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA'])\n","\n","# down sample whole set for spike\n","RBD_df = cleaned_df[cleaned_df['Antigen'] == 'S:RBD']\n","RBD_df=shuffle(RBD_df)\n","RBD_df = RBD_df.sample(n=3000)\n","\n","nonS_df = cleaned_df[cleaned_df['Antigen'] != 'S:RBD']\n","\n","cleaned_df = pd.concat([nonS_df,RBD_df])\n","\n","# Use a utility from sklearn to split and shuffle your dataset.\n","train_df, test_df = train_test_split(cleaned_df, test_size=0.2)\n","train_df, val_df = train_test_split(train_df, test_size=0.2)\n","\n","\n","\n","print(len(train_df))\n","print(len(val_df))\n","print(len(test_df))\n"],"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["2787\n","697\n","872\n"]}]},{"cell_type":"code","metadata":{"id":"Q-gHvUw7LtSV","executionInfo":{"status":"ok","timestamp":1643866249737,"user_tz":360,"elapsed":437,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["# save train_df, val_df, test_df\n","train_df['dataset']='train set'\n","val_df['dataset']='val set'\n","test_df['dataset']='test set'\n","dataset_df = df=pd.concat([train_df,val_df,test_df])\n","dataset_df.to_csv('result/dataset/RBD_new_dataset.csv')\n"],"execution_count":53,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"8LlD-Llz0SdA"},"source":["# Data processing"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"dlKyWvIxc26n","executionInfo":{"status":"ok","timestamp":1643864853580,"user_tz":360,"elapsed":153,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"3b8d4ff7-58d9-4fda-f069-a020f9853441"},"source":["\n","codes = ['A', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K', 'L',\n"," 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'Y']\n","\n","def create_dict(codes):\n"," char_dict = {}\n"," for index, val in enumerate(codes):\n"," char_dict[val] = index+1\n","\n"," return char_dict\n","\n","char_dict = create_dict(codes)\n","\n","print(char_dict)\n","print(\"Dict Length:\", len(char_dict))"],"execution_count":4,"outputs":[{"output_type":"stream","name":"stdout","text":["{'A': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8, 'K': 9, 'L': 10, 'M': 11, 'N': 12, 'P': 13, 'Q': 14, 'R': 15, 'S': 16, 'T': 17, 'V': 18, 'W': 19, 'Y': 20}\n","Dict Length: 20\n"]}]},{"cell_type":"code","metadata":{"id":"74hboteHc57v","executionInfo":{"status":"ok","timestamp":1643864853752,"user_tz":360,"elapsed":10,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def integer_encoding(data,CDR):\n"," \"\"\"\n"," - Encodes code sequence to integer values.\n"," - 20 common amino acids are taken into consideration\n"," and rests are categorized as 21.\n"," \"\"\"\n"," \n"," encode_list = []\n"," for row in data[CDR].values:\n"," row_encode = []\n"," for code in row:\n"," row_encode.append(char_dict.get(code, 21))\n"," encode_list.append(np.array(row_encode))\n"," \n"," return encode_list"],"execution_count":5,"outputs":[]},{"cell_type":"code","metadata":{"id":"lkU0B3GCWjdB","executionInfo":{"status":"ok","timestamp":1643864853752,"user_tz":360,"elapsed":9,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def encode_six_CDR(data,max_length = 30):\n"," \"\"\"\n"," - Encodes code sequence to integer values.\n"," - add post-padding\n"," \"\"\"\n"," cdr_list = ['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA']\n"," encoded_cdr_list=[]\n"," for cdr in cdr_list:\n"," encoded_cdr=integer_encoding(data,cdr)\n"," pad_cdr=pad_sequences(encoded_cdr,maxlen=max_length, padding='post', truncating='post')\n"," encoded_cdr_list.append(pad_cdr)\n"," return encoded_cdr_list"],"execution_count":6,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"uBA1-IL8Xpj_","executionInfo":{"status":"ok","timestamp":1643864853995,"user_tz":360,"elapsed":260,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"ba5c042d-3828-4ef4-a059-34283bacc4d8"},"source":["[train_x1,train_x2,train_x3,train_x4,train_x5,train_x6]=encode_six_CDR(train_df)\n","[val_x1,val_x2,val_x3,val_x4,val_x5,val_x6]=encode_six_CDR(val_df)\n","[test_x1,test_x2,test_x3,test_x4,test_x5,test_x6]=encode_six_CDR(test_df)\n","print(train_x1.shape, val_x1.shape, test_x1.shape)\n","print(test_x1[0])"],"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["(2787, 30) (697, 30) (872, 30)\n","[ 6 6 16 8 16 16 6 6 20 20 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n"," 0 0 0 0 0 0]\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"IAc2Vwt3dAS5","executionInfo":{"status":"ok","timestamp":1643864854007,"user_tz":360,"elapsed":55,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"246b8e50-5abb-476d-d622-ef526a646387"},"source":["# label/integer encoding output variable: (y)\n","le = LabelEncoder()\n","\n","y_train = le.fit_transform(train_df['Antigen'])\n","y_val = le.transform(val_df['Antigen'])\n","y_test = le.transform(test_df['Antigen'])\n","\n","print(y_train.shape, y_val.shape, y_test.shape)\n","print('Total classes: ', len(le.classes_))"],"execution_count":8,"outputs":[{"output_type":"stream","name":"stdout","text":["(2787,) (697,) (872,)\n","Total classes: 2\n"]}]},{"cell_type":"markdown","metadata":{"id":"DasHlLjt467U"},"source":["# Basic statistics"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"uhdgojQx4_i4","executionInfo":{"status":"ok","timestamp":1643864855344,"user_tz":360,"elapsed":159,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"15144743-899f-4ec7-ff96-16d22fc07066"},"source":["def Count_Abs_bycls(train, test, val):\n"," \"\"\"\n"," Prints # Antibody number in different classes in data sets.\n"," \"\"\"\n"," train_count = train['Antigen'].value_counts()\n"," val_count = val['Antigen'].value_counts()\n"," test_count = test['Antigen'].value_counts()\n","\n"," print('Number of Abs in different classes in Train:\\n',train_count,'\\n')\n"," print('Number of Abs in different classes in Val:\\n',val_count,'\\n')\n"," print('Number of Abs in different classes in Test:\\n',test_count,'\\n')\n"," \n","\n","Count_Abs_bycls(train_df,test_df,val_df)"],"execution_count":9,"outputs":[{"output_type":"stream","name":"stdout","text":["Number of Abs in different classes in Train:\n"," S:RBD 1928\n","HA 859\n","Name: Antigen, dtype: int64 \n","\n","Number of Abs in different classes in Val:\n"," S:RBD 485\n","HA 212\n","Name: Antigen, dtype: int64 \n","\n","Number of Abs in different classes in Test:\n"," S:RBD 587\n","HA 285\n","Name: Antigen, dtype: int64 \n","\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":0},"id":"4GnknUOX61mk","executionInfo":{"status":"ok","timestamp":1643864856346,"user_tz":360,"elapsed":853,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"56be278e-4fd0-4bb2-e070-8d056863c7f7"},"source":["def plot_cluster_count(df, data_name):\n"," sns.histplot(df['cluster'].values,binwidth=5)\n"," plt.title(f'Cluster char count: {data_name}')\n"," plt.grid(True)\n","\n","plt.subplot(1, 3, 1)\n","plot_cluster_count(train_df, 'Train')\n","\n","plt.subplot(1, 3, 2)\n","plot_cluster_count(val_df, 'Val')\n","\n","plt.subplot(1, 3, 3)\n","plot_cluster_count(test_df, 'Test')\n","\n","plt.subplots_adjust(right=3.0)\n","plt.show()"],"execution_count":10,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"EvI27BXG0SdB"},"source":["# Transformer building block"]},{"cell_type":"code","metadata":{"id":"iFGqpGW-vesT","executionInfo":{"status":"ok","timestamp":1643864857672,"user_tz":360,"elapsed":143,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def get_angles(pos, i, d_model):\n"," angle_rates = 1 / np.power(10000, (2 * (i//2)) / np.float32(d_model))\n"," return pos * angle_rates\n","def positional_encoding(position, d_model):\n"," angle_rads = get_angles(np.arange(position)[:, np.newaxis],\n"," np.arange(d_model)[np.newaxis, :],\n"," d_model)\n","\n"," # apply sin to even indices in the array; 2i\n"," angle_rads[:, 0::2] = np.sin(angle_rads[:, 0::2])\n","\n"," # apply cos to odd indices in the array; 2i+1\n"," angle_rads[:, 1::2] = np.cos(angle_rads[:, 1::2])\n","\n"," pos_encoding = angle_rads[np.newaxis, ...]\n","\n"," return tf.cast(pos_encoding, dtype=tf.float32) "],"execution_count":11,"outputs":[]},{"cell_type":"code","metadata":{"id":"Vh7DUDJ8KP_J","executionInfo":{"status":"ok","timestamp":1643864857837,"user_tz":360,"elapsed":8,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def create_padding_mask(seq):\n"," seq = tf.cast(tf.math.equal(seq, 0), tf.float32)\n","\n"," # add extra dimensions to add the padding\n"," # to the attention logits.\n"," return seq[:, tf.newaxis, tf.newaxis, :] # (batch_size, 1, 1, seq_len)\n","def create_look_ahead_mask(size):\n"," mask = 1 - tf.linalg.band_part(tf.ones((size, size)), -1, 0)\n"," return mask # (seq_len, seq_len)"],"execution_count":12,"outputs":[]},{"cell_type":"code","metadata":{"id":"Y1a0X7sz79fs","executionInfo":{"status":"ok","timestamp":1643864857837,"user_tz":360,"elapsed":6,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def scaled_dot_product_attention(q, k, v, mask):\n"," \"\"\"Calculate the attention weights.\n"," q, k, v must have matching leading dimensions.\n"," k, v must have matching penultimate dimension, i.e.: seq_len_k = seq_len_v.\n"," The mask has different shapes depending on its type(padding or look ahead)\n"," but it must be broadcastable for addition.\n","\n"," Args:\n"," q: query shape == (..., seq_len_q, depth)\n"," k: key shape == (..., seq_len_k, depth)\n"," v: value shape == (..., seq_len_v, depth_v)\n"," mask: Float tensor with shape broadcastable\n"," to (..., seq_len_q, seq_len_k). Defaults to None.\n","\n"," Returns:\n"," output, attention_weights\n"," \"\"\"\n","\n"," matmul_qk = tf.matmul(q, k, transpose_b=True) # (..., seq_len_q, seq_len_k)\n","\n"," # scale matmul_qk\n"," dk = tf.cast(tf.shape(k)[-1], tf.float32)\n"," scaled_attention_logits = matmul_qk / tf.math.sqrt(dk)\n","\n"," # add the mask to the scaled tensor.\n"," if mask is not None:\n"," scaled_attention_logits += (mask * -1e9)\n","\n"," # softmax is normalized on the last axis (seq_len_k) so that the scores\n"," # add up to 1.\n"," attention_weights = tf.nn.softmax(scaled_attention_logits, axis=-1) # (..., seq_len_q, seq_len_k)\n","\n"," output = tf.matmul(attention_weights, v) # (..., seq_len_q, depth_v)\n","\n"," return output, attention_weights"],"execution_count":13,"outputs":[]},{"cell_type":"code","metadata":{"id":"iPGM326S74cQ","executionInfo":{"status":"ok","timestamp":1643864857838,"user_tz":360,"elapsed":7,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def print_out(q, k, v):\n"," temp_out, temp_attn = scaled_dot_product_attention(\n"," q, k, v, None)\n"," print('Attention weights are:')\n"," print(temp_attn)\n"," print('Output is:')\n"," print(temp_out)"],"execution_count":14,"outputs":[]},{"cell_type":"code","metadata":{"id":"ulnTf9fq7wFg","executionInfo":{"status":"ok","timestamp":1643864857838,"user_tz":360,"elapsed":6,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["class Defined_MultiHeadAttention(tf.keras.layers.Layer):\n"," def __init__(self, d_model, num_heads):\n"," super(Defined_MultiHeadAttention, self).__init__()\n"," self.num_heads = num_heads\n"," self.d_model = d_model\n","\n"," assert d_model % self.num_heads == 0\n","\n"," self.depth = d_model // self.num_heads\n","\n"," self.wq = tf.keras.layers.Dense(d_model)\n"," self.wk = tf.keras.layers.Dense(d_model)\n"," self.wv = tf.keras.layers.Dense(d_model)\n","\n"," self.dense = tf.keras.layers.Dense(d_model)\n","\n"," def split_heads(self, x, batch_size):\n"," \"\"\"Split the last dimension into (num_heads, depth).\n"," Transpose the result such that the shape is (batch_size, num_heads, seq_len, depth)\n"," \"\"\"\n"," x = tf.reshape(x, (batch_size, -1, self.num_heads, self.depth))\n"," return tf.transpose(x, perm=[0, 2, 1, 3])\n","\n"," def call(self, v, k, q, mask):\n"," batch_size = tf.shape(q)[0]\n","\n"," q = self.wq(q) # (batch_size, seq_len, d_model)\n"," k = self.wk(k) # (batch_size, seq_len, d_model)\n"," v = self.wv(v) # (batch_size, seq_len, d_model)\n","\n"," q = self.split_heads(q, batch_size) # (batch_size, num_heads, seq_len_q, depth)\n"," k = self.split_heads(k, batch_size) # (batch_size, num_heads, seq_len_k, depth)\n"," v = self.split_heads(v, batch_size) # (batch_size, num_heads, seq_len_v, depth)\n","\n"," # scaled_attention.shape == (batch_size, num_heads, seq_len_q, depth)\n"," # attention_weights.shape == (batch_size, num_heads, seq_len_q, seq_len_k)\n"," scaled_attention, attention_weights = scaled_dot_product_attention(\n"," q, k, v, mask)\n","\n"," scaled_attention = tf.transpose(scaled_attention, perm=[0, 2, 1, 3]) # (batch_size, seq_len_q, num_heads, depth)\n","\n"," concat_attention = tf.reshape(scaled_attention,\n"," (batch_size, -1, self.d_model)) # (batch_size, seq_len_q, d_model)\n","\n"," output = self.dense(concat_attention) # (batch_size, seq_len_q, d_model)\n","\n"," return output, attention_weights"],"execution_count":15,"outputs":[]},{"cell_type":"code","metadata":{"id":"ow6JEMF9siun","executionInfo":{"status":"ok","timestamp":1643864857839,"user_tz":360,"elapsed":7,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def point_wise_feed_forward_network(d_model, dff):\n"," return tf.keras.Sequential([\n"," tf.keras.layers.Dense(dff, activation='relu'), # (batch_size, seq_len, dff)\n"," tf.keras.layers.Dense(d_model) # (batch_size, seq_len, d_model)\n"," ])"],"execution_count":16,"outputs":[]},{"cell_type":"code","metadata":{"id":"HB6bBjGptPHe","executionInfo":{"status":"ok","timestamp":1643864857839,"user_tz":360,"elapsed":7,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["class EncoderLayer(tf.keras.layers.Layer):\n"," def __init__(self, d_model, num_heads, dff, rate=0.1):\n"," super(EncoderLayer, self).__init__()\n","\n"," self.mha = Defined_MultiHeadAttention(d_model, num_heads)\n"," self.ffn = point_wise_feed_forward_network(d_model, dff)\n","\n"," self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)\n"," self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)\n","\n"," self.dropout1 = layers.Dropout(rate)\n"," self.dropout2 = layers.Dropout(rate)\n","\n"," def call(self, x, training, mask):\n","\n"," attn_output, _ = self.mha(x, x, x, mask) # (batch_size, input_seq_len, d_model)\n"," attn_output = self.dropout1(attn_output, training=training)\n"," out1 = self.layernorm1(x + attn_output) # (batch_size, input_seq_len, d_model)\n","\n"," ffn_output = self.ffn(out1) # (batch_size, input_seq_len, d_model)\n"," ffn_output = self.dropout2(ffn_output, training=training)\n"," out2 = self.layernorm2(out1 + ffn_output) # (batch_size, input_seq_len, d_model)\n","\n"," return out2"],"execution_count":17,"outputs":[]},{"cell_type":"code","metadata":{"id":"eAX5mgzwuIzp","executionInfo":{"status":"ok","timestamp":1643864857969,"user_tz":360,"elapsed":136,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["class DecoderLayer(tf.keras.layers.Layer):\n"," def __init__(self, d_model, num_heads, dff, rate=0.1):\n"," super(DecoderLayer, self).__init__()\n","\n"," self.mha1 = Defined_MultiHeadAttention(d_model, num_heads)\n"," self.mha2 = Defined_MultiHeadAttention(d_model, num_heads)\n","\n"," self.ffn = point_wise_feed_forward_network(d_model, dff)\n","\n"," self.layernorm1 = layers.LayerNormalization(epsilon=1e-6)\n"," self.layernorm2 = layers.LayerNormalization(epsilon=1e-6)\n"," self.layernorm3 = layers.LayerNormalization(epsilon=1e-6)\n","\n"," self.dropout1 = layers.Dropout(rate)\n"," self.dropout2 = layers.Dropout(rate)\n"," self.dropout3 = layers.Dropout(rate)\n","\n"," def call(self, x, enc_output, training,\n"," look_ahead_mask, padding_mask):\n"," # enc_output.shape == (batch_size, input_seq_len, d_model)\n","\n"," attn1, attn_weights_block1 = self.mha1(x, x, x, look_ahead_mask) # (batch_size, target_seq_len, d_model)\n"," attn1 = self.dropout1(attn1, training=training)\n"," out1 = self.layernorm1(attn1 + x)\n","\n"," attn2, attn_weights_block2 = self.mha2(\n"," enc_output, enc_output, out1, padding_mask) # (batch_size, target_seq_len, d_model)\n"," attn2 = self.dropout2(attn2, training=training)\n"," out2 = self.layernorm2(attn2 + out1) # (batch_size, target_seq_len, d_model)\n","\n"," ffn_output = self.ffn(out2) # (batch_size, target_seq_len, d_model)\n"," ffn_output = self.dropout3(ffn_output, training=training)\n"," out3 = self.layernorm3(ffn_output + out2) # (batch_size, target_seq_len, d_model)\n","\n"," return out3, attn_weights_block1, attn_weights_block2"],"execution_count":18,"outputs":[]},{"cell_type":"code","metadata":{"id":"2Y1RwhoUu_6u","executionInfo":{"status":"ok","timestamp":1643864857969,"user_tz":360,"elapsed":3,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["class Encoder(tf.keras.layers.Layer):\n"," def __init__(self, num_layers, d_model, num_heads, dff, input_vocab_size,\n"," maximum_position_encoding, rate=0.1):\n"," super(Encoder, self).__init__()\n","\n"," self.d_model = d_model\n"," self.num_layers = num_layers\n","\n"," self.embedding = layers.Embedding(input_vocab_size, d_model)\n"," self.pos_encoding = positional_encoding(maximum_position_encoding,\n"," self.d_model)\n","\n"," self.enc_layers = [EncoderLayer(d_model, num_heads, dff, rate)\n"," for _ in range(num_layers)]\n","\n"," self.dropout = tf.keras.layers.Dropout(rate)\n","\n"," def call(self, x, training, mask):\n","\n"," seq_len = tf.shape(x)[1]\n","\n"," # adding embedding and position encoding.\n"," x = self.embedding(x) # (batch_size, input_seq_len, d_model)\n"," x *= tf.math.sqrt(tf.cast(self.d_model, tf.float32))\n"," x += self.pos_encoding[:, :seq_len, :]\n","\n"," x = self.dropout(x, training=training)\n","\n"," for i in range(self.num_layers):\n"," x = self.enc_layers[i](x, training, mask)\n","\n"," return x # (batch_size, input_seq_len, d_model)"],"execution_count":19,"outputs":[]},{"cell_type":"code","metadata":{"collapsed":true,"id":"vREtcc6U0SdC","executionInfo":{"status":"ok","timestamp":1643864861251,"user_tz":360,"elapsed":3285,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["METRICS = [\n"," keras.metrics.TruePositives(name='tp'),\n"," keras.metrics.FalsePositives(name='fp'),\n"," keras.metrics.TrueNegatives(name='tn'),\n"," keras.metrics.FalseNegatives(name='fn'), \n"," keras.metrics.BinaryAccuracy(name='accuracy'),\n"," keras.metrics.Precision(name='precision'),\n"," keras.metrics.Recall(name='recall'),\n"," keras.metrics.AUC(name='auc'),\n"," keras.metrics.AUC(name='prc', curve='PR'), # precision-recall curve\n","]\n","\n"," "],"execution_count":20,"outputs":[]},{"cell_type":"code","metadata":{"id":"-IZsy2Na4Kbg","executionInfo":{"status":"ok","timestamp":1643864861252,"user_tz":360,"elapsed":4,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["\n","def create_mlp(dim=30):\n","\t# define our MLP network\n","\tmodel = Sequential()\n","\tmodel.add(Dense(dim, activation=\"relu\"))\n","\tmodel.add(Dense(dim, activation=\"relu\"))\n","\n","\treturn model"],"execution_count":21,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"yFjQdoX_278O"},"source":["#Building transformer encoder+ MLP"]},{"cell_type":"code","metadata":{"id":"J3pQ1mQUvAWz","executionInfo":{"status":"ok","timestamp":1643864863745,"user_tz":360,"elapsed":135,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def build_t_encoder(\n"," num_layers,\n"," d_model,\n"," num_heads,\n"," dff,\n"," input_vocab_size,\n"," maximum_position_encoding,\n"," training=True,\n"," rate=0.1\n","):\n"," inputs = keras.layers.Input(shape=(30,))\n"," x=inputs\n"," enc_padding_mask = create_padding_mask(inputs)\n"," encoder = Encoder(num_layers, d_model, num_heads, dff,input_vocab_size, maximum_position_encoding, rate)\n"," x = encoder(x,training,enc_padding_mask)\n"," x = layers.GlobalAveragePooling1D(data_format=\"channels_first\")(x)\n"," t_encoder = keras.Model(inputs, x)\n"," # for dim in mlp_units:\n"," # x = layers.Dense(dim, activation=\"relu\")(x)\n"," # x = layers.Dropout(rate)(x)\n"," # outputs = layers.Dense(n_classes, activation=\"softmax\")(x)\n"," return t_encoder"],"execution_count":22,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"TFSz2Fl9ZKeu"},"source":["## CDR model"]},{"cell_type":"code","metadata":{"id":"kjP2idIOCqN8","executionInfo":{"status":"ok","timestamp":1643865121726,"user_tz":360,"elapsed":121,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def CDR_model(mlp_units,n_classes,rate=0.1,max_length=30):\n"," input1=keras.layers.Input(shape=(30,))\n"," input2=keras.layers.Input(shape=(30,))\n"," input3=keras.layers.Input(shape=(30,))\n"," input4=keras.layers.Input(shape=(30,))\n"," input5=keras.layers.Input(shape=(30,))\n"," input6=keras.layers.Input(shape=(30,))\n","\n"," encoder1=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input1)\n"," encoder2=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input2)\n"," encoder3=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input3)\n"," encoder4=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input4)\n"," encoder5=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input5)\n"," encoder6=build_t_encoder(num_layers=4,d_model=256,num_heads=4,dff=256,input_vocab_size=21,maximum_position_encoding=max_length)(input6)\n","\n","\n"," x = Concatenate()([encoder1, encoder2,encoder3, encoder4,encoder5, encoder6])\n"," for dim in mlp_units:\n"," x = layers.Dense(dim, activation=\"relu\")(x)\n"," x = layers.Dropout(rate)(x)\n"," outputs = layers.Dense(n_classes, activation=\"sigmoid\")(x)\n"," return keras.Model([input1,input2,input3,input4,input5,input6],outputs)"],"execution_count":31,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"p3bdQz7dvNnP","executionInfo":{"status":"ok","timestamp":1643865310828,"user_tz":360,"elapsed":187083,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"a6b2c3e9-0396-4b32-cd61-f0635f59dae7"},"source":["\n","CDR_model = CDR_model(mlp_units=[512,128,64],n_classes=1)\n","CDR_model.compile(\n"," loss=keras.losses.BinaryCrossentropy(),\n"," optimizer=keras.optimizers.Adam(learning_rate=1e-4),\n"," metrics=METRICS,\n",")\n","CDR_model.summary()\n","\n","callbacks = [keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]\n","\n","CDR_history=CDR_model.fit(\n"," [train_x1,train_x2,train_x3,train_x4,train_x5,train_x6], y_train,\n"," epochs=100, batch_size=256,\n"," validation_data=([val_x1,val_x2,val_x3,val_x4,val_x5,val_x6], y_val),\n"," callbacks=callbacks,\n",")\n"],"execution_count":32,"outputs":[{"output_type":"stream","name":"stdout","text":["Model: \"model_13\"\n","__________________________________________________________________________________________________\n"," Layer (type) Output Shape Param # Connected to \n","==================================================================================================\n"," input_13 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_14 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_15 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_16 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_17 (InputLayer) [(None, 30)] 0 [] \n"," \n"," input_18 (InputLayer) [(None, 30)] 0 [] \n"," \n"," model_7 (Functional) (None, 30) 1588480 ['input_13[0][0]'] \n"," \n"," model_8 (Functional) (None, 30) 1588480 ['input_14[0][0]'] \n"," \n"," model_9 (Functional) (None, 30) 1588480 ['input_15[0][0]'] \n"," \n"," model_10 (Functional) (None, 30) 1588480 ['input_16[0][0]'] \n"," \n"," model_11 (Functional) (None, 30) 1588480 ['input_17[0][0]'] \n"," \n"," model_12 (Functional) (None, 30) 1588480 ['input_18[0][0]'] \n"," \n"," concatenate_1 (Concatenate) (None, 180) 0 ['model_7[0][0]', \n"," 'model_8[0][0]', \n"," 'model_9[0][0]', \n"," 'model_10[0][0]', \n"," 'model_11[0][0]', \n"," 'model_12[0][0]'] \n"," \n"," dense_292 (Dense) (None, 512) 92672 ['concatenate_1[0][0]'] \n"," \n"," dropout_111 (Dropout) (None, 512) 0 ['dense_292[0][0]'] \n"," \n"," dense_293 (Dense) (None, 128) 65664 ['dropout_111[0][0]'] \n"," \n"," dropout_112 (Dropout) (None, 128) 0 ['dense_293[0][0]'] \n"," \n"," dense_294 (Dense) (None, 64) 8256 ['dropout_112[0][0]'] \n"," \n"," dropout_113 (Dropout) (None, 64) 0 ['dense_294[0][0]'] \n"," \n"," dense_295 (Dense) (None, 1) 65 ['dropout_113[0][0]'] \n"," \n","==================================================================================================\n","Total params: 9,697,537\n","Trainable params: 9,697,537\n","Non-trainable params: 0\n","__________________________________________________________________________________________________\n","Epoch 1/100\n","11/11 [==============================] - 37s 889ms/step - loss: 0.6910 - tp: 2252.0000 - fp: 855.0000 - tn: 289.0000 - fn: 263.0000 - accuracy: 0.6945 - precision: 0.7248 - recall: 0.8954 - auc: 0.6450 - prc: 0.8018 - val_loss: 0.6877 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.6958\n","Epoch 2/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.6845 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.4909 - prc: 0.6855 - val_loss: 0.6791 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.6958\n","Epoch 3/100\n","11/11 [==============================] - 3s 281ms/step - loss: 0.6740 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.4962 - prc: 0.6879 - val_loss: 0.6653 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.6958\n","Epoch 4/100\n","11/11 [==============================] - 3s 283ms/step - loss: 0.6586 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.4815 - prc: 0.6737 - val_loss: 0.6457 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.6958\n","Epoch 5/100\n","11/11 [==============================] - 3s 283ms/step - loss: 0.6378 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.5073 - prc: 0.6961 - val_loss: 0.6254 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.6958\n","Epoch 6/100\n","11/11 [==============================] - 3s 285ms/step - loss: 0.6224 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.5015 - prc: 0.6942 - val_loss: 0.6147 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.5000 - val_prc: 0.6958\n","Epoch 7/100\n","11/11 [==============================] - 3s 283ms/step - loss: 0.6179 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.5104 - prc: 0.7031 - val_loss: 0.6137 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.6034 - val_prc: 0.7437\n","Epoch 8/100\n","11/11 [==============================] - 3s 281ms/step - loss: 0.6171 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.5252 - prc: 0.7068 - val_loss: 0.6075 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.7778 - val_prc: 0.8747\n","Epoch 9/100\n","11/11 [==============================] - 3s 281ms/step - loss: 0.6003 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.7116 - prc: 0.8307 - val_loss: 0.5862 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.7988 - val_prc: 0.8950\n","Epoch 10/100\n","11/11 [==============================] - 3s 283ms/step - loss: 0.5758 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.7896 - prc: 0.8762 - val_loss: 0.5620 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.8181 - val_prc: 0.9011\n","Epoch 11/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.5456 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.8264 - prc: 0.9021 - val_loss: 0.5328 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.8181 - val_prc: 0.9067\n","Epoch 12/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.5137 - tp: 1928.0000 - fp: 859.0000 - tn: 0.0000e+00 - fn: 0.0000e+00 - accuracy: 0.6918 - precision: 0.6918 - recall: 1.0000 - auc: 0.8378 - prc: 0.9097 - val_loss: 0.5041 - val_tp: 485.0000 - val_fp: 212.0000 - val_tn: 0.0000e+00 - val_fn: 0.0000e+00 - val_accuracy: 0.6958 - val_precision: 0.6958 - val_recall: 1.0000 - val_auc: 0.8346 - val_prc: 0.9149\n","Epoch 13/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.4800 - tp: 1911.0000 - fp: 751.0000 - tn: 108.0000 - fn: 17.0000 - accuracy: 0.7244 - precision: 0.7179 - recall: 0.9912 - auc: 0.8564 - prc: 0.9222 - val_loss: 0.4943 - val_tp: 470.0000 - val_fp: 161.0000 - val_tn: 51.0000 - val_fn: 15.0000 - val_accuracy: 0.7475 - val_precision: 0.7448 - val_recall: 0.9691 - val_auc: 0.8246 - val_prc: 0.9067\n","Epoch 14/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.4584 - tp: 1832.0000 - fp: 485.0000 - tn: 374.0000 - fn: 96.0000 - accuracy: 0.7915 - precision: 0.7907 - recall: 0.9502 - auc: 0.8634 - prc: 0.9309 - val_loss: 0.4850 - val_tp: 467.0000 - val_fp: 132.0000 - val_tn: 80.0000 - val_fn: 18.0000 - val_accuracy: 0.7848 - val_precision: 0.7796 - val_recall: 0.9629 - val_auc: 0.8327 - val_prc: 0.9109\n","Epoch 15/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.4462 - tp: 1810.0000 - fp: 424.0000 - tn: 435.0000 - fn: 118.0000 - accuracy: 0.8055 - precision: 0.8102 - recall: 0.9388 - auc: 0.8688 - prc: 0.9314 - val_loss: 0.4785 - val_tp: 460.0000 - val_fp: 115.0000 - val_tn: 97.0000 - val_fn: 25.0000 - val_accuracy: 0.7991 - val_precision: 0.8000 - val_recall: 0.9485 - val_auc: 0.8325 - val_prc: 0.9112\n","Epoch 16/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.4299 - tp: 1763.0000 - fp: 332.0000 - tn: 527.0000 - fn: 165.0000 - accuracy: 0.8217 - precision: 0.8415 - recall: 0.9144 - auc: 0.8741 - prc: 0.9370 - val_loss: 0.4607 - val_tp: 461.0000 - val_fp: 107.0000 - val_tn: 105.0000 - val_fn: 24.0000 - val_accuracy: 0.8121 - val_precision: 0.8116 - val_recall: 0.9505 - val_auc: 0.8506 - val_prc: 0.9154\n","Epoch 17/100\n","11/11 [==============================] - 3s 281ms/step - loss: 0.4211 - tp: 1755.0000 - fp: 327.0000 - tn: 532.0000 - fn: 173.0000 - accuracy: 0.8206 - precision: 0.8429 - recall: 0.9103 - auc: 0.8768 - prc: 0.9405 - val_loss: 0.4532 - val_tp: 433.0000 - val_fp: 80.0000 - val_tn: 132.0000 - val_fn: 52.0000 - val_accuracy: 0.8106 - val_precision: 0.8441 - val_recall: 0.8928 - val_auc: 0.8448 - val_prc: 0.9177\n","Epoch 18/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.4062 - tp: 1751.0000 - fp: 275.0000 - tn: 584.0000 - fn: 177.0000 - accuracy: 0.8378 - precision: 0.8643 - recall: 0.9082 - auc: 0.8892 - prc: 0.9467 - val_loss: 0.4377 - val_tp: 417.0000 - val_fp: 67.0000 - val_tn: 145.0000 - val_fn: 68.0000 - val_accuracy: 0.8063 - val_precision: 0.8616 - val_recall: 0.8598 - val_auc: 0.8597 - val_prc: 0.9302\n","Epoch 19/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.3892 - tp: 1723.0000 - fp: 260.0000 - tn: 599.0000 - fn: 205.0000 - accuracy: 0.8332 - precision: 0.8689 - recall: 0.8937 - auc: 0.8941 - prc: 0.9471 - val_loss: 0.4526 - val_tp: 375.0000 - val_fp: 42.0000 - val_tn: 170.0000 - val_fn: 110.0000 - val_accuracy: 0.7819 - val_precision: 0.8993 - val_recall: 0.7732 - val_auc: 0.8583 - val_prc: 0.9295\n","Epoch 20/100\n","11/11 [==============================] - 3s 272ms/step - loss: 0.3882 - tp: 1689.0000 - fp: 234.0000 - tn: 625.0000 - fn: 239.0000 - accuracy: 0.8303 - precision: 0.8783 - recall: 0.8760 - auc: 0.8912 - prc: 0.9481 - val_loss: 0.4387 - val_tp: 392.0000 - val_fp: 54.0000 - val_tn: 158.0000 - val_fn: 93.0000 - val_accuracy: 0.7891 - val_precision: 0.8789 - val_recall: 0.8082 - val_auc: 0.8584 - val_prc: 0.9254\n","Epoch 21/100\n","11/11 [==============================] - 3s 281ms/step - loss: 0.3750 - tp: 1695.0000 - fp: 225.0000 - tn: 634.0000 - fn: 233.0000 - accuracy: 0.8357 - precision: 0.8828 - recall: 0.8791 - auc: 0.8986 - prc: 0.9507 - val_loss: 0.4311 - val_tp: 393.0000 - val_fp: 54.0000 - val_tn: 158.0000 - val_fn: 92.0000 - val_accuracy: 0.7905 - val_precision: 0.8792 - val_recall: 0.8103 - val_auc: 0.8663 - val_prc: 0.9330\n","Epoch 22/100\n","11/11 [==============================] - 3s 285ms/step - loss: 0.3517 - tp: 1714.0000 - fp: 205.0000 - tn: 654.0000 - fn: 214.0000 - accuracy: 0.8497 - precision: 0.8932 - recall: 0.8890 - auc: 0.9098 - prc: 0.9573 - val_loss: 0.4218 - val_tp: 422.0000 - val_fp: 66.0000 - val_tn: 146.0000 - val_fn: 63.0000 - val_accuracy: 0.8149 - val_precision: 0.8648 - val_recall: 0.8701 - val_auc: 0.8663 - val_prc: 0.9291\n","Epoch 23/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.3407 - tp: 1698.0000 - fp: 188.0000 - tn: 671.0000 - fn: 230.0000 - accuracy: 0.8500 - precision: 0.9003 - recall: 0.8807 - auc: 0.9155 - prc: 0.9594 - val_loss: 0.4334 - val_tp: 428.0000 - val_fp: 71.0000 - val_tn: 141.0000 - val_fn: 57.0000 - val_accuracy: 0.8164 - val_precision: 0.8577 - val_recall: 0.8825 - val_auc: 0.8586 - val_prc: 0.9279\n","Epoch 24/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.3440 - tp: 1714.0000 - fp: 191.0000 - tn: 668.0000 - fn: 214.0000 - accuracy: 0.8547 - precision: 0.8997 - recall: 0.8890 - auc: 0.9125 - prc: 0.9582 - val_loss: 0.4378 - val_tp: 413.0000 - val_fp: 69.0000 - val_tn: 143.0000 - val_fn: 72.0000 - val_accuracy: 0.7977 - val_precision: 0.8568 - val_recall: 0.8515 - val_auc: 0.8618 - val_prc: 0.9284\n","Epoch 25/100\n","11/11 [==============================] - 3s 283ms/step - loss: 0.3394 - tp: 1718.0000 - fp: 178.0000 - tn: 681.0000 - fn: 210.0000 - accuracy: 0.8608 - precision: 0.9061 - recall: 0.8911 - auc: 0.9142 - prc: 0.9560 - val_loss: 0.4167 - val_tp: 414.0000 - val_fp: 57.0000 - val_tn: 155.0000 - val_fn: 71.0000 - val_accuracy: 0.8164 - val_precision: 0.8790 - val_recall: 0.8536 - val_auc: 0.8708 - val_prc: 0.9354\n","Epoch 26/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.3189 - tp: 1743.0000 - fp: 174.0000 - tn: 685.0000 - fn: 185.0000 - accuracy: 0.8712 - precision: 0.9092 - recall: 0.9040 - auc: 0.9239 - prc: 0.9629 - val_loss: 0.4250 - val_tp: 409.0000 - val_fp: 64.0000 - val_tn: 148.0000 - val_fn: 76.0000 - val_accuracy: 0.7991 - val_precision: 0.8647 - val_recall: 0.8433 - val_auc: 0.8689 - val_prc: 0.9334\n","Epoch 27/100\n","11/11 [==============================] - 3s 274ms/step - loss: 0.3184 - tp: 1735.0000 - fp: 157.0000 - tn: 702.0000 - fn: 193.0000 - accuracy: 0.8744 - precision: 0.9170 - recall: 0.8999 - auc: 0.9238 - prc: 0.9628 - val_loss: 0.4447 - val_tp: 445.0000 - val_fp: 90.0000 - val_tn: 122.0000 - val_fn: 40.0000 - val_accuracy: 0.8135 - val_precision: 0.8318 - val_recall: 0.9175 - val_auc: 0.8650 - val_prc: 0.9295\n","Epoch 28/100\n","11/11 [==============================] - 3s 273ms/step - loss: 0.3179 - tp: 1735.0000 - fp: 186.0000 - tn: 673.0000 - fn: 193.0000 - accuracy: 0.8640 - precision: 0.9032 - recall: 0.8999 - auc: 0.9251 - prc: 0.9633 - val_loss: 0.4536 - val_tp: 452.0000 - val_fp: 89.0000 - val_tn: 123.0000 - val_fn: 33.0000 - val_accuracy: 0.8250 - val_precision: 0.8355 - val_recall: 0.9320 - val_auc: 0.8688 - val_prc: 0.9341\n","Epoch 29/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.3062 - tp: 1762.0000 - fp: 180.0000 - tn: 679.0000 - fn: 166.0000 - accuracy: 0.8759 - precision: 0.9073 - recall: 0.9139 - auc: 0.9294 - prc: 0.9657 - val_loss: 0.4392 - val_tp: 443.0000 - val_fp: 90.0000 - val_tn: 122.0000 - val_fn: 42.0000 - val_accuracy: 0.8106 - val_precision: 0.8311 - val_recall: 0.9134 - val_auc: 0.8713 - val_prc: 0.9356\n","Epoch 30/100\n","11/11 [==============================] - 3s 281ms/step - loss: 0.3003 - tp: 1779.0000 - fp: 177.0000 - tn: 682.0000 - fn: 149.0000 - accuracy: 0.8830 - precision: 0.9095 - recall: 0.9227 - auc: 0.9339 - prc: 0.9679 - val_loss: 0.4003 - val_tp: 438.0000 - val_fp: 72.0000 - val_tn: 140.0000 - val_fn: 47.0000 - val_accuracy: 0.8293 - val_precision: 0.8588 - val_recall: 0.9031 - val_auc: 0.8858 - val_prc: 0.9428\n","Epoch 31/100\n","11/11 [==============================] - 3s 272ms/step - loss: 0.2927 - tp: 1743.0000 - fp: 156.0000 - tn: 703.0000 - fn: 185.0000 - accuracy: 0.8776 - precision: 0.9179 - recall: 0.9040 - auc: 0.9368 - prc: 0.9688 - val_loss: 0.4114 - val_tp: 425.0000 - val_fp: 67.0000 - val_tn: 145.0000 - val_fn: 60.0000 - val_accuracy: 0.8178 - val_precision: 0.8638 - val_recall: 0.8763 - val_auc: 0.8806 - val_prc: 0.9409\n","Epoch 32/100\n","11/11 [==============================] - 3s 273ms/step - loss: 0.2783 - tp: 1773.0000 - fp: 157.0000 - tn: 702.0000 - fn: 155.0000 - accuracy: 0.8881 - precision: 0.9187 - recall: 0.9196 - auc: 0.9429 - prc: 0.9721 - val_loss: 0.4037 - val_tp: 433.0000 - val_fp: 70.0000 - val_tn: 142.0000 - val_fn: 52.0000 - val_accuracy: 0.8250 - val_precision: 0.8608 - val_recall: 0.8928 - val_auc: 0.8813 - val_prc: 0.9396\n","Epoch 33/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.2730 - tp: 1780.0000 - fp: 171.0000 - tn: 688.0000 - fn: 148.0000 - accuracy: 0.8855 - precision: 0.9124 - recall: 0.9232 - auc: 0.9454 - prc: 0.9740 - val_loss: 0.4238 - val_tp: 444.0000 - val_fp: 80.0000 - val_tn: 132.0000 - val_fn: 41.0000 - val_accuracy: 0.8264 - val_precision: 0.8473 - val_recall: 0.9155 - val_auc: 0.8816 - val_prc: 0.9366\n","Epoch 34/100\n","11/11 [==============================] - 3s 269ms/step - loss: 0.2649 - tp: 1783.0000 - fp: 155.0000 - tn: 704.0000 - fn: 145.0000 - accuracy: 0.8924 - precision: 0.9200 - recall: 0.9248 - auc: 0.9476 - prc: 0.9739 - val_loss: 0.4065 - val_tp: 438.0000 - val_fp: 68.0000 - val_tn: 144.0000 - val_fn: 47.0000 - val_accuracy: 0.8350 - val_precision: 0.8656 - val_recall: 0.9031 - val_auc: 0.8858 - val_prc: 0.9405\n","Epoch 35/100\n","11/11 [==============================] - 3s 272ms/step - loss: 0.2506 - tp: 1801.0000 - fp: 144.0000 - tn: 715.0000 - fn: 127.0000 - accuracy: 0.9028 - precision: 0.9260 - recall: 0.9341 - auc: 0.9530 - prc: 0.9765 - val_loss: 0.4051 - val_tp: 423.0000 - val_fp: 58.0000 - val_tn: 154.0000 - val_fn: 62.0000 - val_accuracy: 0.8278 - val_precision: 0.8794 - val_recall: 0.8722 - val_auc: 0.8917 - val_prc: 0.9475\n","Epoch 36/100\n","11/11 [==============================] - 3s 273ms/step - loss: 0.2518 - tp: 1783.0000 - fp: 140.0000 - tn: 719.0000 - fn: 145.0000 - accuracy: 0.8977 - precision: 0.9272 - recall: 0.9248 - auc: 0.9527 - prc: 0.9760 - val_loss: 0.4122 - val_tp: 409.0000 - val_fp: 50.0000 - val_tn: 162.0000 - val_fn: 76.0000 - val_accuracy: 0.8192 - val_precision: 0.8911 - val_recall: 0.8433 - val_auc: 0.8855 - val_prc: 0.9379\n","Epoch 37/100\n","11/11 [==============================] - 3s 282ms/step - loss: 0.2400 - tp: 1804.0000 - fp: 136.0000 - tn: 723.0000 - fn: 124.0000 - accuracy: 0.9067 - precision: 0.9299 - recall: 0.9357 - auc: 0.9579 - prc: 0.9801 - val_loss: 0.3971 - val_tp: 436.0000 - val_fp: 63.0000 - val_tn: 149.0000 - val_fn: 49.0000 - val_accuracy: 0.8393 - val_precision: 0.8737 - val_recall: 0.8990 - val_auc: 0.8904 - val_prc: 0.9446\n","Epoch 38/100\n","11/11 [==============================] - 3s 283ms/step - loss: 0.2223 - tp: 1824.0000 - fp: 133.0000 - tn: 726.0000 - fn: 104.0000 - accuracy: 0.9150 - precision: 0.9320 - recall: 0.9461 - auc: 0.9640 - prc: 0.9829 - val_loss: 0.3846 - val_tp: 429.0000 - val_fp: 59.0000 - val_tn: 153.0000 - val_fn: 56.0000 - val_accuracy: 0.8350 - val_precision: 0.8791 - val_recall: 0.8845 - val_auc: 0.8972 - val_prc: 0.9465\n","Epoch 39/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.2230 - tp: 1808.0000 - fp: 125.0000 - tn: 734.0000 - fn: 120.0000 - accuracy: 0.9121 - precision: 0.9353 - recall: 0.9378 - auc: 0.9634 - prc: 0.9817 - val_loss: 0.4049 - val_tp: 433.0000 - val_fp: 56.0000 - val_tn: 156.0000 - val_fn: 52.0000 - val_accuracy: 0.8451 - val_precision: 0.8855 - val_recall: 0.8928 - val_auc: 0.8874 - val_prc: 0.9353\n","Epoch 40/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.2202 - tp: 1823.0000 - fp: 118.0000 - tn: 741.0000 - fn: 105.0000 - accuracy: 0.9200 - precision: 0.9392 - recall: 0.9455 - auc: 0.9632 - prc: 0.9825 - val_loss: 0.3929 - val_tp: 449.0000 - val_fp: 71.0000 - val_tn: 141.0000 - val_fn: 36.0000 - val_accuracy: 0.8465 - val_precision: 0.8635 - val_recall: 0.9258 - val_auc: 0.8976 - val_prc: 0.9477\n","Epoch 41/100\n","11/11 [==============================] - 3s 272ms/step - loss: 0.2178 - tp: 1811.0000 - fp: 126.0000 - tn: 733.0000 - fn: 117.0000 - accuracy: 0.9128 - precision: 0.9350 - recall: 0.9393 - auc: 0.9642 - prc: 0.9814 - val_loss: 0.4181 - val_tp: 431.0000 - val_fp: 60.0000 - val_tn: 152.0000 - val_fn: 54.0000 - val_accuracy: 0.8364 - val_precision: 0.8778 - val_recall: 0.8887 - val_auc: 0.8866 - val_prc: 0.9414\n","Epoch 42/100\n","11/11 [==============================] - 3s 272ms/step - loss: 0.2103 - tp: 1805.0000 - fp: 106.0000 - tn: 753.0000 - fn: 123.0000 - accuracy: 0.9178 - precision: 0.9445 - recall: 0.9362 - auc: 0.9672 - prc: 0.9831 - val_loss: 0.4179 - val_tp: 453.0000 - val_fp: 78.0000 - val_tn: 134.0000 - val_fn: 32.0000 - val_accuracy: 0.8422 - val_precision: 0.8531 - val_recall: 0.9340 - val_auc: 0.8950 - val_prc: 0.9417\n","Epoch 43/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.2071 - tp: 1823.0000 - fp: 121.0000 - tn: 738.0000 - fn: 105.0000 - accuracy: 0.9189 - precision: 0.9378 - recall: 0.9455 - auc: 0.9681 - prc: 0.9840 - val_loss: 0.4138 - val_tp: 461.0000 - val_fp: 86.0000 - val_tn: 126.0000 - val_fn: 24.0000 - val_accuracy: 0.8422 - val_precision: 0.8428 - val_recall: 0.9505 - val_auc: 0.9003 - val_prc: 0.9466\n","Epoch 44/100\n","11/11 [==============================] - 3s 273ms/step - loss: 0.1859 - tp: 1835.0000 - fp: 101.0000 - tn: 758.0000 - fn: 93.0000 - accuracy: 0.9304 - precision: 0.9478 - recall: 0.9518 - auc: 0.9743 - prc: 0.9879 - val_loss: 0.4035 - val_tp: 441.0000 - val_fp: 62.0000 - val_tn: 150.0000 - val_fn: 44.0000 - val_accuracy: 0.8479 - val_precision: 0.8767 - val_recall: 0.9093 - val_auc: 0.8945 - val_prc: 0.9418\n","Epoch 45/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.1768 - tp: 1840.0000 - fp: 96.0000 - tn: 763.0000 - fn: 88.0000 - accuracy: 0.9340 - precision: 0.9504 - recall: 0.9544 - auc: 0.9772 - prc: 0.9896 - val_loss: 0.4080 - val_tp: 446.0000 - val_fp: 64.0000 - val_tn: 148.0000 - val_fn: 39.0000 - val_accuracy: 0.8522 - val_precision: 0.8745 - val_recall: 0.9196 - val_auc: 0.8915 - val_prc: 0.9386\n","Epoch 46/100\n","11/11 [==============================] - 3s 271ms/step - loss: 0.1592 - tp: 1860.0000 - fp: 92.0000 - tn: 767.0000 - fn: 68.0000 - accuracy: 0.9426 - precision: 0.9529 - recall: 0.9647 - auc: 0.9811 - prc: 0.9909 - val_loss: 0.4291 - val_tp: 435.0000 - val_fp: 57.0000 - val_tn: 155.0000 - val_fn: 50.0000 - val_accuracy: 0.8465 - val_precision: 0.8841 - val_recall: 0.8969 - val_auc: 0.8855 - val_prc: 0.9388\n","Epoch 47/100\n","11/11 [==============================] - 3s 272ms/step - loss: 0.1572 - tp: 1851.0000 - fp: 86.0000 - tn: 773.0000 - fn: 77.0000 - accuracy: 0.9415 - precision: 0.9556 - recall: 0.9601 - auc: 0.9811 - prc: 0.9901 - val_loss: 0.4221 - val_tp: 438.0000 - val_fp: 59.0000 - val_tn: 153.0000 - val_fn: 47.0000 - val_accuracy: 0.8479 - val_precision: 0.8813 - val_recall: 0.9031 - val_auc: 0.9024 - val_prc: 0.9511\n","Epoch 48/100\n","11/11 [==============================] - 3s 285ms/step - loss: 0.1607 - tp: 1858.0000 - fp: 94.0000 - tn: 765.0000 - fn: 70.0000 - accuracy: 0.9412 - precision: 0.9518 - recall: 0.9637 - auc: 0.9805 - prc: 0.9905 - val_loss: 0.4388 - val_tp: 451.0000 - val_fp: 69.0000 - val_tn: 143.0000 - val_fn: 34.0000 - val_accuracy: 0.8522 - val_precision: 0.8673 - val_recall: 0.9299 - val_auc: 0.8926 - val_prc: 0.9427\n"]}]},{"cell_type":"markdown","metadata":{"id":"1UUAsd3X0SdD"},"source":["### Plot loss functions\n","\n"]},{"cell_type":"code","metadata":{"id":"qP0Q151IkjSl","executionInfo":{"status":"ok","timestamp":1643865072702,"user_tz":360,"elapsed":154,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["plt.style.use('ggplot')\n","def plot_loss(history, label, n):\n"," # Use a log scale on y-axis to show the wide range of values.\n"," plt.semilogy(history.epoch, history.history['loss'],\n"," color=colors[n], label='Train ' + label)\n"," plt.semilogy(history.epoch, history.history['val_loss'],\n"," color=colors[n], label='Val ' + label,\n"," linestyle=\"--\")\n"," plt.xlabel('Epoch')\n"," plt.ylabel('Loss')\n","def plot_metrics(history):\n"," metrics = ['loss', 'prc', 'precision', 'recall']\n"," for n, metric in enumerate(metrics):\n"," name = metric.replace(\"_\",\" \").capitalize()\n"," plt.subplot(2,2,n+1)\n"," plt.plot(history.epoch, history.history[metric], color=colors[0], label='Train')\n"," plt.plot(history.epoch, history.history['val_'+metric],\n"," color=colors[0], linestyle=\"--\", label='Val')\n"," plt.xlabel('Epoch')\n"," plt.ylabel(name)\n"," if metric == 'loss':\n"," plt.ylim([0, plt.ylim()[1]])\n"," elif metric == 'auc':\n"," plt.ylim([0.8,1])\n"," else:\n"," plt.ylim([0,1])\n","\n"," plt.legend()\n","def plot_cm(labels, predictions, p=0.5):\n"," cm = confusion_matrix(labels, predictions > p)\n"," plt.figure(figsize=(5,5))\n"," sns.heatmap(cm, annot=True, fmt=\"d\")\n"," plt.title('Confusion matrix @{:.2f}'.format(p))\n"," plt.ylabel('Actual label')\n"," plt.xlabel('Predicted label')\n"],"execution_count":25,"outputs":[]},{"cell_type":"code","metadata":{"collapsed":true,"scrolled":true,"id":"-yyt-qUM0SdD","colab":{"base_uri":"https://localhost:8080/","height":286},"executionInfo":{"status":"ok","timestamp":1643865339146,"user_tz":360,"elapsed":687,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"371de8ae-af3b-436c-ac80-f437f1b7c6b7"},"source":["colors = plt.rcParams['axes.prop_cycle'].by_key()['color']\n","plot_metrics(CDR_history)"],"execution_count":33,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{}}]},{"cell_type":"code","metadata":{"id":"IubzpbWPCrtr","colab":{"base_uri":"https://localhost:8080/","height":939},"executionInfo":{"status":"ok","timestamp":1643865400764,"user_tz":360,"elapsed":1904,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"0975bb5a-4e1c-4bf0-ffce-0705e8482c9f"},"source":["y_pred=CDR_model.predict([test_x1,test_x2,test_x3,test_x4,test_x5,test_x6])\n","\n","con_mat = confusion_matrix(y_test, y_pred >0.5)\n","con_mat_norm = np.around(con_mat.astype('float') / con_mat.sum(axis=1)[:, np.newaxis], decimals=2)\n","\n","con_mat_df = pd.DataFrame(con_mat_norm,\n"," index = le.classes_, \n"," columns = le.classes_)\n","figure = plt.figure(figsize=(8, 8))\n","sns.heatmap(con_mat_df, annot=True,cmap=plt.cm.Blues)\n","plt.tight_layout()\n","plt.ylabel('True label')\n","plt.xlabel('Predicted label')\n","\n","plot_cm(labels=y_test, predictions=y_pred)"],"execution_count":41,"outputs":[{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAioAAAJJCAYAAACEUBxHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfXhU1b33/89MEowQEGYCSYSAP0aoPCgPHTUGjiUmCkqPjSjo0VIpnOqvqFBbQVFAqFKLoBSBG5ETAqIIig9VEbTBG3tIFIIYRYFCAJXAYMiEB4UEM9lz/2GZMgWSCJnZew/vV6+5ruzZa/ZaO1c1Xz9r7TWOYDAYFAAAgAU5zR4AAADA6VCoAAAAy6JQAQAAlkWhAgAALItCBQAAWBaFCgAAsKx4swcAAABiQ0lJifLz82UYhrKzs5Wbmxt2fv/+/Zo7d64OHz6spKQk3XfffXK73XVek0QFAACcNcMwlJeXp4cfflgzZsxQYWGhysrKwtosXrxYV199taZPn65bbrlFS5Ysqfe6FCoAAOCslZaWKjU1VSkpKYqPj1dmZqaKi4vD2pSVlal79+6SpG7dumnDhg31XtcWUz+pv1lu9hCAmPTuhP5mDwGIST3aN49aX+f3ujdqfb01LVcFBQWh45ycHOXk5EiSKisrw6Zx3G63tm/fHvb5Dh06aP369brhhhu0fv16VVVV6dtvv1Xz5qf/fdmiUAEAAOY7sTA5E0OHDtWCBQu0Zs0adenSRS6XS05n3ZM7FCoAAOCsuVwu+f3+0LHf75fL5TqpzQMPPCBJqq6u1rp169SsWbM6r8saFQAA7MzhjN6rDh6PRz6fT+Xl5QoEAioqKpLX6w1rc/jwYRmGIUl6/fXXlZWVVe/tkagAAICzFhcXp+HDh2vKlCkyDENZWVlKT0/XsmXL5PF45PV6tXnzZi1ZskQOh0NdunTRiBEj6r0uhQoAAHbmcJg9gpDevXurd+/eYe/deuutoZ8zMjKUkZHxo67J1A8AALAsEhUAAOysnrUjdhfbdwcAAGyNRAUAADuz0BqVSCBRAQAAlkWiAgCAnbFGBQAAwBwkKgAA2BlrVAAAAMxBogIAgJ2xRgUAAMAcFCoAAMCymPoBAMDOWEwLAABgDhIVAADsjMW0AAAA5iBRAQDAzlijAgAAYA4SFQAA7Iw1KgAAAOYgUQEAwM5YowIAAGAOEhUAAOyMNSoAAADmIFEBAMDOSFQAAADMQaICAICdOXnqBwAAwBQkKgAA2BlrVAAAAMxBogIAgJ2xMy0AAIA5SFQAALAz1qgAAACYg0QFAAA7Y40KAACAOShUAACAZTH1AwCAnbGYFgAAwBwkKgAA2BmLaQEAAMxBogIAgJ2xRgUAAMAcJCoAANgZa1QAAADMQaICAICdsUYFAADAHCQqAADYGWtUAAAAzEGiAgCAnbFGBQAAwBwkKgAA2BmJCgAAgDlIVAAAsDOe+gEAADAHiQoAAHbGGhUAAABzkKgAAGBnMb5GhUIFAAA0ipKSEuXn58swDGVnZys3NzfsfEVFhebMmaMjR47IMAzdfvvt6t27d53XpFABAMDOLLJGxTAM5eXlafz48XK73Ro3bpy8Xq/atWsXavPqq6/qqquu0nXXXaeysjI98cQT9RYq1rg7AABga6WlpUpNTVVKSori4+OVmZmp4uLisDYOh0NHjx6VJB09elStWrWq97okKgAAoEEKCgpUUFAQOs7JyVFOTo4kqbKyUm63O3TO7XZr+/btYZ8fPHiwHn/8ca1atUrHjh3ThAkT6u2TQgUAADuL4mLaEwuTM1FYWKh+/frpP//zP7Vt2zbNmjVLTz31lJzO00/wMPUDAADOmsvlkt/vDx37/X65XK6wNu+//76uuuoqSVLnzp1VU1Ojb7/9ts7rUqgAAGBjDocjaq+6eDwe+Xw+lZeXKxAIqKioSF6vN6xNcnKyPv/8c0lSWVmZampq1KJFizqvy9QPAAA4a3FxcRo+fLimTJkiwzCUlZWl9PR0LVu2TB6PR16vV7/61a80b948rVixQpI0cuTIegsgRzAYDEbjBs5G6m+Wmz0EICa9O6G/2UMAYlKP9s2j1lezW/Kj1teR5b+OWl/HMfUDAAAsi6kfAADsLLZ30CdRAQAA1kWiAgCAjdW3GNXuSFQAAIBlkagAAGBjJCoAAAAmIVEBAMDGSFQAAABMQqICAICNkagAAACYhEQFAAA7i+1AhUQFAABYF4kKAAA2xhoVAAAAk5CoAABgYyQqAAAAJiFRAQDAxkhUAAAATEKhAgAALIupHwAAbIypHwAAAJOQqAAAYGexHaiQqAAAAOsiUQEAwMZYowIAAGASEhUAAGyMRAUAAMAkJCoAANgYiQoAAIBJSFQAALCz2A5USFQAAIB1kagAAGBjrFEBAAAwCYkKAAA2RqICAABgEhIVAABsjEQFAADAJCQqAADYGIkKAACASUhUAACws9gOVEhUAACAdZGoAABgY6xRAQAAMAmFCgAAsCymfgAAsDGmfgAAAExCogIAgI2RqAAAAJiERAUAADuL7UCFRAUAAFgXiQoAADbGGhUAAACTkKgAAGBjJCoAAAAmIVEBAMDGSFQi6ODBg2Z2DwAALC7qicqRI0e0bt06rV27Vnv27NG8efOiPQScoaxuKXrstp6Kczr04v/u0uxV/wg7P3lID/W5pLUk6fwmcUpufp5+MvrN0PmkxHj9/Y/XadUne/XwSyVRHTtgZSXFRcr/P9NlGIayr89V7m3Dws6/vfwFrV75V8XFxanFBa302wcmqnVKmiSponyfnn3qMfn3fyM5HBo3ZabapF5owl3ALLGeqESlUPn+++9VXFystWvX6ssvv1RVVZXGjBmjLl26RKN7NAKnQ3ri9l4aMuN/5TtwVKseydZ7n+7VNt+3oTaPvvxp6OcR13jUPb1l2DUe/EU3fbStImpjBuzAqK1V3qypGj91jtzJKRp376/kvepqtevQMdTmoosv0Z/n3KLzEhP13lvL9cL8Z3T/+CckSbOnTtSg24frsp9mqLrqqBwOlh7CPCUlJcrPz/+h6M7OVm5ubtj5hQsX6osvvpD0Q21w6NAhLVy4sM5rRrxQmTlzprZu3arLLrtM119/vbp376777rtP3bp1i3TXaES9/j+Xdu3/Tl9XHJEkvVG8W/17Xqhtvn+csn3u5e017c0vQseXtW+p1i0S9X+/2KceHVpFZcyAHZT+4wulXpiulLR2kqTMftepuOiDsEKle09v6OdOXbrrfwvekSSVfbVTtbW1uuynGZKkxPObRnHksAyLBCqGYSgvL0/jx4+X2+3WuHHj5PV61a5du1CbYcOGhX5euXKldu3aVe91I156l5WVqVmzZmrbtq3atm0rp9MZ8zFVLEpreb72VlaFjn0HqpTW8vxTtm3naqr2yU21dmu5JMnhkCYN6aHJyz+LylgBO6msKJe7dUro2J3cRpUV5adt//7Kv6rnFZmSpL1lX6tZUnNNnzRGY///27X4uZkyamsjPmbgVEpLS5WamqqUlBTFx8crMzNTxcXFp21fWFiovn371nvdiCcq06ZN0549e1RYWKjHHntMzZs3V1VVlQ4ePKiWLVue9nMFBQUqKCj455H3tO1gPblXpOvtjXtkBH84/nU/j1Zv8sl3oKruDwKo098L3tHObVs06annJElGbUBbNn2iJ599UcltUjXj8XFa895buub63HquhFgSzf/4D//bLOXk5CgnJ0eSVFlZKbfbHTrndru1ffv2U15n//79Ki8vV/fu3evtMyprVNq2bashQ4ZoyJAh2rlzp9auXatx48bJ7Xbr8ccfP+VnTrz5hb9ZHo1hog6+g1W60PWvBCWt1fnyHTx14fGLy9tp3JJ/LZb9qcetKy9O1rB+HjU9L15N4p06ciygKa99HvFxA1bnSm7zw0LYf/JXlMuV3Oakdp9tXKfXlyzQpKeeU0KTJv/8bIou8vwkNG10RWY/bdvyua65Pjpjx7nnxL/NZ6OwsFAZGRlyOuuf2In6Uz8dO3ZUx44dNXToUG3ZsiXa3eMMlXx5QB3bJKl9clP5DlQp9/J0jfyf9Se1uzi1uVo2baINO/yh9+45od2tmR3Uo0MrihTgnzw/6Srfnt0q9+2RK7mNita8p1Hjwv8DblfpVs3/y5/08J9m6YJWrtD7F/+kq44e+VaHDx5Qi5at9HnJBnXszEMK5xqrLKdwuVzy+//1736/3y+Xy3XKtkVFRRoxYkSDrhvxQmXBggV1nu/atWukh4BGUGsE9fCSEr30u/9QnMOhlwq/1D/2HtbYG7uq5KsDeu9TnyQp9/J0vVG82+TRAvYRFxev4feO0ZRx98kwapXV/0alX+TRsoXPytO5i7yZP9MLzz2j6qoqPf3YQ5Kk5DYpevCxGXLGxWnoXaP1x7G/VTAYVMdOXZRzw00m3xHOVR6PRz6fT+Xl5XK5XCoqKtKoUaNOardnzx4dOXJEnTt3btB1HcFgMNjYgz3RmjVrQj+/8sorGjx4cNj5fv361XuNVKZ+gIh4d0J/s4cAxKQe7ZtHra+LH1gZtb5Kp9c9r7hx40YtWrRIhmEoKytLgwYN0rJly+TxeOT1/rDe9OWXX1ZNTY3uuOOOBvUZ8UTlxELknXfeaVBhAgAA7Kd3797q3bt32Hu33npr2PGQIUN+1DWjukbFKvNoAADEilj/28oWhgAAwLIinqj86le/ClV7x44d05133ilJCgaDcjgcWrRoUaSHAAAAbCrihcrzzz8f6S4AADhnxfjMD1M/AADAuqK+4RsAAGg8LKYFAAAwCYkKAAA2FuOBCokKAACwLhIVAABszOmM7UiFRAUAAFgWiQoAADbGGhUAAACTkKgAAGBj7KMCAABgEhIVAABsLMYDFRIVAABgXSQqAADYGGtUAAAATEKiAgCAjZGoAAAAmIREBQAAG4vxQIVEBQAAWBeJCgAANsYaFQAAAJNQqAAAAMti6gcAABuL8ZkfEhUAAGBdJCoAANgYi2kBAABMQqICAICNxXigQqICAACsi0QFAAAbY40KAACASUhUAACwsRgPVEhUAACAdZGoAABgY6xRAQAAMAmJCgAANhbjgQqJCgAAsC4SFQAAbIw1KgAAACYhUQEAwMZiPFAhUQEAANZFogIAgI2xRgUAAMAkJCoAANhYjAcqJCoAAMC6SFQAALAx1qgAAACYhEIFAABYFlM/AADYGFM/AAAAJiFRAQDAxmI8UCFRAQAA1kWiAgCAjbFGBQAAwCQkKgAA2JiVApWSkhLl5+fLMAxlZ2crNzf3pDZFRUV65ZVX5HA41KFDB40ePbrOa1KoAACAs2YYhvLy8jR+/Hi53W6NGzdOXq9X7dq1C7Xx+Xx644039NhjjykpKUmHDh2q97oUKgAA2JhV1qiUlpYqNTVVKSkpkqTMzEwVFxeHFSqrV69W//79lZSUJEm64IIL6r0uhQoAAGiQgoICFRQUhI5zcnKUk5MjSaqsrJTb7Q6dc7vd2r59e9jn9+7dK0maMGGCDMPQ4MGD1bNnzzr7pFABAMDGohmonFiYnAnDMOTz+fToo4+qsrJSjz76qKZPn65mzZqd9jM89QMAAM6ay+WS3+8PHfv9frlcrpPaeL1excfHq02bNkpLS5PP56vzuhQqAADYmNPhiNqrLh6PRz6fT+Xl5QoEAioqKpLX6w1rc8UVV+iLL76QJB0+fFg+ny+0puV0mPoBAABnLS4uTsOHD9eUKVNkGIaysrKUnp6uZcuWyePxyOv1qkePHvr00091//33y+l06pe//KWaN29e53UdwWAwGKV7OGOpv1lu9hCAmPTuhP5mDwGIST3a1/3HtzFdN+ejqPX13j0ZUevrOKZ+AACAZTH1AwCAjVllH5VIIVEBAACWRaICAICNOWM7UCFRAQAA1kWiAgCAjbFGBQAAwCQkKgAA2FiMByokKgAAwLooVAAAgGUx9QMAgI05FNtzPyQqAADAskhUAACwMTZ8AwAAMAmJCgAANsaGbwAAACYhUQEAwMZiPFAhUQEAANZFogIAgI05YzxSIVEBAACWRaICAICNxXigQqICAACsi0QFAAAbYx8VAAAAk5CoAABgYzEeqJCoAAAA6yJRAQDAxthHBQAAwCQkKgAA2Fhs5ykkKgAAwMJIVAAAsDH2UQEAADAJiQoAADbmjO1AhUQFAABY12kTlVmzZjVo3uvee+9t1AEBAAAcd9pCJTU1NZrjAAAAZyDWF9OetlAZPHhwNMcBAABwkgYvpv3ss89UWFioQ4cO6aGHHtKOHTtUVVWl7t27R3J8AACgDjEeqDRsMe3KlSs1f/58paWlacuWLZKkJk2aaOnSpREdHAAAOLc1KFF55513NGHCBLVp00Z//etfJUlt27bV3r17Izo4AABQt1hfo9KgRKWqqkrJyclh7wUCAcXHsw0LAACInAYVKl26dNEbb7wR9t7KlSvVrVu3iAwKAAA0jNMRvZcp99eQRsOHD9f69et1zz33qLq6WqNHj9aHH36oO++8M9LjAwAA57AGzd20atVKTzzxhHbs2KH9+/fL7Xbr4osvltPJxrYAAJiJNSr/FAwGFQgEJEmGYURsQAAAAMc1KFH56quvNG3aNNXU1MjlcqmyslIJCQl64IEHdNFFF0V4iAAA4HRiO09pYKEyd+5c9e/fXz//+c/lcDgUDAa1YsUKzZ07V1OnTo30GAEAwDmqQVM/Pp9PAwcODM2DORwO3XDDDdq3b19EBwcAAOrmdDii9jLl/hrSqFevXtqwYUPYexs2bFCvXr0iMigAAACpjqmfWbNmhRIUwzD0l7/8RR07dpTb7Zbf79fOnTvl9XqjNlAAAHCyGH/o5/SFSmpqathxenp66Od27dqpR48ekRsVAACA6ihUBg8eHM1xAACAMxDr+6g0+Mt6AoGA9u7dq8OHD4e9371790YfFAAAgNTAQmXr1q16+umnVVNTo6qqKp1//vmqrq6W2+3W7NmzIz1GAABwGjEeqDTsqZ9FixbpxhtvVH5+vs4//3zl5+fr5ptv1nXXXRfp8QEAgHNYgwqVvXv36oYbbgh7Lzc3VytWrIjIoAAAQMOwj4qkpk2bqqqqSpLUsmVLlZWV6bvvvlN1dXVEBwcAAM5tDVqjcuWVV+qTTz5R3759lZWVpcmTJysuLk4ZGRmRHh8AAKhDrK9RaVChMmzYsNDPN954ozp16qTq6mr2UgEAACElJSXKz8+XYRjKzs5Wbm5u2Pk1a9Zo8eLFcrlckqQBAwYoOzu7zms2+PHkE3Xp0uVMPgYAAGKUYRjKy8vT+PHj5Xa7NW7cOHm9XrVr1y6sXWZmpkaMGNHg6562UJk4cWKDNpGZPHlygzsDAACNyyobvpWWlio1NVUpKSmSfihIiouLTypUfqzTFirXXHPNWV24MX059xazhwDEpFaX32v2EICYVPVJbO4xVlBQoIKCgtBxTk6OcnJyJEmVlZVyu92hc263W9u3bz/pGuvWrdOWLVuUlpamO++8U8nJyXX2edpCpV+/fj92/AAAIMoa9PhuIzmxMDkTP/3pT9WnTx8lJCTob3/7m+bMmaNHH320zs9E8/4AAECMcrlc8vv9oWO/3x9aNHtc8+bNlZCQIEnKzs7Wzp07670uhQoAADbmcDii9qqLx+ORz+dTeXm5AoGAioqK5PV6w9ocOHAg9POGDRsatH7ljJ76AQAAOFFcXJyGDx+uKVOmyDAMZWVlKT09XcuWLZPH45HX69XKlSu1YcMGxcXFKSkpSSNHjqz3uo5gMBiMwvjPSnXA7BEAsYnFtEBkRHMx7e/+ujVqff3lF5dEra/jGpSo1NTUaPny5SosLNS3336rRYsW6dNPP5XP59OAAQMiPUYAAHCOavC3J+/evVujRo0KzVGlp6frvffei+jgAABA3ZyO6L3M0KBEZf369XrmmWeUmJgYKlRcLpcqKysjOjgAAHBua1ChEh8fL8Mwwt47fPiwmjdvHpFBAQCAhrHKzrSR0qCpn4yMDM2ePVvl5eWSfni8KC8vT5mZmREdHAAAOLc1qFC5/fbb1aZNG/3hD3/Q0aNHNWrUKLVq1UqDBw+O9PgAAEAdWKOiH6Z+hg0bpmHDhoWmfGI9agIAAOZrUKHyzTffhB1XVVWFfj7+LYkAACD6Yj03aFChMmrUqNOeW7ZsWaMNBgAA4EQNKlT+vRg5ePCgXnnlFXXp0iUigwIAAA3jjPFI5Yy+lLBly5YaNmyYlixZ0tjjAQAACDnjLyXcu3evjh071phjAQAAP9IZJQ420qBCZeLEiWFP+Rw7dky7d+/WLbfcErGBAQAANKhQueaaa8KOExMT1aFDB6WlpUVkUAAAoGFifIlK/YWKYRj6/PPPdffddyshISEaYwIAAJDUgELF6XTqs88+Y4M3AAAsiKd+JA0cOFAvv/yyAoFApMcDAAAQUmeisnbtWvXt21erVq3SwYMHtWLFCrVo0SKszdy5cyM6QAAAcO6qs1CZP3+++vbtq/vuuy9a4wEAAD9CjM/81F2oBINBSVLXrl2jMhgAAIAT1VmoHH/ipy7du3dv1AEBAICGc57LiUpNTY2effbZULLy7xwOh2bPnh2RgQEAANRZqCQmJlKIAABgYTyeDAAAYJIGLaYFAADWFOOBSt2JyvPPPx+tcQAAAJykQV9KCAAArCnWn/phjQoAALAsEhUAAGzModiOVEhUAACAZZGoAABgY6xRAQAAMAmJCgAANkaiAgAAYBISFQAAbMwR41vTkqgAAADLIlEBAMDGWKMCAABgEhIVAABsLMaXqJCoAAAA6yJRAQDAxpwxHqmQqAAAAMuiUAEAAJbF1A8AADbG48kAAAAmIVEBAMDGYnwtLYkKAACwLhIVAABszKnYjlRIVAAAgGWRqAAAYGOsUQEAADAJiQoAADbGPioAAAAmIVEBAMDG+FJCAAAAk5CoAABgYzEeqJCoAAAA6yJRAQDAxlijAgAA0AAlJSUaPXq07rvvPr3xxhunbffRRx9pyJAh2rFjR73XpFABAMDGHI7ovepiGIby8vL08MMPa8aMGSosLFRZWdlJ7aqqqrRy5Up16tSpQfdHoQIAAM5aaWmpUlNTlZKSovj4eGVmZqq4uPikdsuWLdMvfvELJSQkNOi6rFEBAMDGopk4FBQUqKCgIHSck5OjnJwcSVJlZaXcbnfonNvt1vbt28M+v3PnTlVUVKh379568803G9QnhQoAAGiQEwuTH8swDD3//PMaOXLkj/ochQoAADbmsMhTPy6XS36/P3Ts9/vlcrlCx9XV1dq9e7cmT54sSTp48KCefPJJjR07Vh6P57TXpVABAABnzePxyOfzqby8XC6XS0VFRRo1alTofNOmTZWXlxc6njRpkoYOHVpnkSJRqAAAYGvWyFOkuLg4DR8+XFOmTJFhGMrKylJ6erqWLVsmj8cjr9d7Rtd1BIPBYCOPtdFVB8weARCbWl1+r9lDAGJS1Sezo9bX8xt2R62vX3nTo9bXcTyeDAAALIupHwAAbIwt9AEAAExCogIAgI3Fdp5CogIAACyMRAUAABuL8SUqJCoAAMC6SFQAALAxq2yhHykkKgAAwLJIVAAAsLFYTxxi/f4AAICNkagAAGBjrFEBAAAwCYkKAAA2Ftt5CokKAACwMBIVAABsjDUqAAAAJiFRAQDAxmI9cYj1+wMAADZGogIAgI2xRgUAAMAkJCoAANhYbOcpJCoAAMDCSFQAALCxGF+iQqICAACsi0IFAABYFlM/AADYmDPGl9OSqAAAAMsiUQEAwMZYTAsAAGASEhUAAGzMwRoVAAAAc5CoAABgY6xRAQAAMAmJCgAANsY+KgAAACYhUQEAwMZYowIAAGASEhUAAGyMRAUAAMAkJCoAANgYO9MCAACYhEQFAAAbc8Z2oEKiAgAArItEBQAAG2ONCgAAgElIVAAAsDH2UQEAADBJ1BKVr7/+Wnv27JEktW3bVu3bt49W1wAAxKxYX6MS8ULl6NGjevLJJ+X3+9W+fXsFg0Ht3r1bycnJGjNmjJo2bRrpIQAAAJuKeKGydOlSdezYURMnTpTT+cNMk2EYWrJkiZYuXarhw4dHeggAAMCmIr5GZdOmTbrjjjtCRYokOZ1O/dd//Zc2bdoU6e4BAIhpTkf0XqbcX6Q7iI+PV1xc3Envx8XFKT6eh44AAMDpRbxSqKmp0a5duxQMBk86FwgEIt09AAAxjcW0Z6lVq1Z6/vnnT3muZcuWke4eAADYWMQLlUcffTTSXQAAcM5iw7dGsH//fh0+fFiStG3bNr355ptav359NLpGhBT+799148D++vmAa5U3/7mTzn+8oVi33nKTel/WVX97d5UJIwTs6drMLvr09Qn6/K+P6oFfX3vS+fZprfTOs/dp/bJxenf+aLVtQzKN2BbxRGX58uX64IMPJEl9+vTRpk2b1LVrV33yySfavHmzhg0bFukhoJHV1tbqT1P+qHnz85WSkqLbb71F/bKukefii0NtUtPS9NiUJ7Ro4QITRwrYi9Pp0F8eGqKBv52tPd8c1NoXx+jtDzZp6859oTZP3H+TXlyxXi++tU4/u7yz/njfjRox4dTT6zg3WClQKSkpUX5+vgzDUHZ2tnJzc8POv/fee3r33XfldDqVmJiou+++W+3atavzmhEvVAoLCzVjxgwdO3ZMI0eO1HPPPafzzjtPtbW1Gjt2bKS7RwR8vukzpad3ULv0dEnSgBsGas3/XR1WqLRt+8P/8ZwOvqUBaKjLu1+kHbsr9OUevyTplXc36uf9LgsrVC7pmKYHn3pNkvRB8Ta9/PRvTBkr8O8Mw1BeXp7Gjx8vt9utcePGyev1hhUiffv21XXXXSdJ2rBhgxYtWqRHHnmkzutG/K9IkyZNFB8fr2bNmiklJUXnnXeeJB5PtrPyb75Ralpq6LhNSoq++eYbE0cExIYL21ygsm8OhI73fHNAbVtfENZm07Y9+sU1PSVJv7imh1oknS/XBc2iOk5Yi9PhiNqrLqWlpUpNTVVKSori4+OVmZmp4uLisDYn7kZfXV0tRwMW2ES8Ujhy5IjWrVunYDCoqqoqrVu3TpIUDAZ19OjR036uoBr71zAAABNTSURBVKBABQUFkqRJj/850sMEAFsYN+N1zXhwsH5545Uq3FiqPd8cUG2tYfawcI448W+zJOXk5CgnJ0eSVFlZKbfbHTrndru1ffv2k66xatUqrVixQoFAQBMnTqy3z4gXKl27dtXHH38sSerSpUvo5+PHp3PizVez3YqltElJ0T7fv6Lo8m++UUpKiokjAmLD3vJDapfSKnTcNqWV9uw/FNbGt/+QbnvgfyRJzc5votzsnjr0XVVUxwlrieYalRP/Np+pAQMGaMCAAVq7dq1effVV3XvvvXW2j3ihMnLkyEh3gSjr1v1Sff31lyor262UNila9c4KPTHtKbOHBdjehi++0sXtW6vDhW7tLT+owf17a9i4hWFt3C2bqfLQUQWDQY0Z3l+L/vqROYMF/o3L5ZLf7w8d+/1+uVyu07bPzMzU/Pnz671uVFY6GoYRejxZ+mFH2oKCAt1///3R6B6NLD4+XuMemajf3vXfyr3xBl034HpdfHEnzZk1U2veXy3phwW3115ztd57b5Uem/yobrpxoMmjBqyvttbQ/VNf1lv/5x6VvDZer773ibbs3KcJvx2ogT+7VJJ0tbeTPntjgj57Y6LauJtr6v+8a/KoYTpHFF918Hg88vl8Ki8vVyAQUFFRkbxeb1gbn88X+nnjxo1KS0ur//aCp9rbvhEVFhbqueeeU2JiolJTUzVo0CDNnTtXHo9HN998szp27FjvNZj6ASKj1eV1R64AzkzVJ7Oj1tdHOw5Gra8MT9379mzcuFGLFi2SYRjKysrSoEGDtGzZMnk8Hnm9XuXn52vTpk2Ki4tTUlKShg8frvR/PkF6OhEvVP7whz9ozJgxSk1N1c6dOzV+/Hj9/ve/P6nKqguFChAZFCpAZESzUFm341D9jRrJlZ4L6m/UyKLy7cmpqT88ytqxY0elpaX9qCIFAACcuyK+mPbQoUN6++23Q8dHjhwJO/75z38e6SEAABCzYv27fiJeqGRnZ6uqquq0xwAAAKcT8UJl8ODBke4CAIBzVowHKtF5PPm4Ezd7O9UxAADAiaJaqOzYsaPOYwAA8CNZZB+VSIn41E9paamSk5PVsmVLDRkyRB988IHWrVun5ORkDRkyJNLdAwAAG4t4ojJ//vzQtyRv3rxZS5Ys0dVXX62mTZtq3rx5ke4eAICY5oji/8wQ8ULFMAwlJSVJkoqKipSdna2MjAzddttt2rdvXz2fBgAA57KoFCq1tbWSpM8//1zdu3cPOwcAAHA6EV+j0qdPH02aNEnNmzdXkyZN1KVLF0nSvn371LRp00h3DwBATGPDt7M0aNAgde/eXQcPHtRll10mxz9/o4Zh6Ne//nWkuwcAADYW8UJFkjp37nzSexdeeGE0ugYAIKbFeKAS3X1UAAAAfoyoJCoAACBCYjxSIVEBAACWRaICAICNmbURW7SQqAAAAMsiUQEAwMZifR8VEhUAAGBZJCoAANhYjAcqJCoAAMC6SFQAALCzGI9USFQAAIBlkagAAGBj7KMCAABgEhIVAABsjH1UAAAATEKiAgCAjcV4oEKiAgAArItEBQAAO4vxSIVEBQAAWBaJCgAANsY+KgAAACahUAEAAJbF1A8AADbGhm8AAAAmIVEBAMDGYjxQIVEBAADWRaICAICdxXikQqICAAAsi0QFAAAbY8M3AAAAk5CoAABgY+yjAgAAYBISFQAAbCzGAxUSFQAAYF0kKgAA2FmMRyokKgAAwLJIVAAAsDH2UQEAADAJiQoAADbGPioAAAAmIVEBAMDGYjxQIVEBAADWRaICAICdxXikQqICAAAsi0QFAAAbi/V9VChUAABAoygpKVF+fr4Mw1B2drZyc3PDzr/99ttavXq14uLi1KJFC/32t79V69at67wmUz8AAOCsGYahvLw8Pfzww5oxY4YKCwtVVlYW1uaiiy7Sn//8Z02fPl0ZGRl64YUX6r0uhQoAADbmcETvVZfS0lKlpqYqJSVF8fHxyszMVHFxcVib7t2767zzzpMkderUSZWVlfXeH1M/AACgQQoKClRQUBA6zsnJUU5OjiSpsrJSbrc7dM7tdmv79u2nvdb777+vnj171tsnhQoAADYWzaW0JxYmZ+Pvf/+7du7cqUmTJtXblqkfAABw1lwul/x+f+jY7/fL5XKd1O6zzz7T66+/rrFjxyohIaHe61KoAABgZ44ovurg8Xjk8/lUXl6uQCCgoqIieb3esDa7du3S/PnzNXbsWF1wwQUNuj2mfgAAwFmLi4vT8OHDNWXKFBmGoaysLKWnp2vZsmXyeDzyer164YUXVF1draefflqSlJycrAcffLDO6zqCwWAwGjdwNqoDZo8AiE2tLr/X7CEAManqk9lR6+sr/7Go9dXBfV7U+jqOqR8AAGBZTP0AAGBj9e1vYnckKgAAwLJIVAAAsLEYD1RIVAAAgHWRqAAAYGOsUQEAADAJiQoAALYW25EKiQoAALAsEhUAAGyMNSoAAAAmIVEBAMDGYjxQIVEBAADWRaICAICNsUYFAADAJCQqAADYmCPGV6mQqAAAAMuiUAEAAJbF1A8AAHYW2zM/JCoAAMC6SFQAALCxGA9USFQAAIB1kagAAGBjbPgGAABgEhIVAABsjA3fAAAATEKiAgCAncV2oEKiAgAArItEBQAAG4vxQIVEBQAAWBeJCgAANsY+KgAAACYhUQEAwMbYRwUAAMAkJCoAANgYa1QAAABMQqECAAAsi0IFAABYFmtUAACwMdaoAAAAmIREBQAAG2MfFQAAAJNQqAAAAMti6gcAABtjMS0AAIBJSFQAALCxGA9USFQAAIB1kagAAGBnMR6pkKgAAADLIlEBAMDG2PANAADAJCQqAADYGPuoAAAAmIREBQAAG4vxQIVEBQAAWBeJCgAAdhbjkQqJCgAAsCwSFQAAbCzW91GhUAEAAI2ipKRE+fn5MgxD2dnZys3NDTu/efNmLVq0SF999ZV+97vfKSMjo95rMvUDAICNORzRe9XFMAzl5eXp4Ycf1owZM1RYWKiysrKwNsnJyRo5cqT69u3b4PsjUQEAAGettLRUqampSklJkSRlZmaquLhY7dq1C7Vp06aNJMnxI3aps0WhkmiLUeK4goIC5eTkmD0MNEDVJ7PNHgJ+BP7ZwqlE829kQUGBCgoKQsc5OTmh/09WVlbK7XaHzrndbm3fvv2s+6QEQKPjX6ZAZPDPFsx2YmESLaxRAQAAZ83lcsnv94eO/X6/XC7XWV+XQgUAAJw1j8cjn8+n8vJyBQIBFRUVyev1nvV1HcFgMNgI4wNCiKeByOCfLVjdxo0btWjRIhmGoaysLA0aNEjLli2Tx+OR1+tVaWmppk+friNHjighIUEtW7bU008/Xec1KVQAAIBlMfUDAAAsi0IFAABYFo8n44wMHTpUixcvDh2vWbNGO3bs0IgRI0LvjRkzRm3bttXvfvc7M4YIWNZrr72mtWvXyul0yuFw6K677lKnTp1C519++WWtXr1aLVq0UCAQ0M033xzayXPOnDnavHmzmjZtqpqaGvXp00eDBw+WJE2aNEkHDhxQQkKCAoGALr30Ut12221q1qyZKfcJNAYKFUREWVmZDMPQli1bVF1drcTERLOHBFjCtm3b9PHHH2vq1KlKSEjQ4cOHFQgETmo3cOBA3XjjjfL5fHrooYeUkZGh+Pgf/pU9dOhQZWRk6Pvvv9fvf/97/exnPwvt+Dlq1Ch5PB4FAgEtWbJETz75pCZPnhzVewQaE1M/iIjCwkJdffXV6tGjhzZs2GD2cADLOHDggJo3b66EhARJUosWLercayItLU1NmjTRkSNHTjpXU1MjSTrvvPNOOhcfH69f/vKXqqio0Jdfftk4gwdMQKKCM/L9999rzJgxoePvvvsu7Hn5oqIiTZgwQXv27NHKlSt/1BdQAbGsR48eWr58uUaPHq1LL71UmZmZ6tq1a9gjnCfauXOn0tLSdMEFF4TeW7x4sV599VXt27dP119/fdi5EzmdTnXo0EF79+7VRRddFMnbAiKGQgVnpEmTJpo2bVro+PgaFUnasWOHWrRooeTkZLlcLs2dO1ffffedkpKSzBouYBmJiYmaOnWqtmzZoi+++EIzZszQHXfcoVtvvTWs3YoVK7RmzRr5fD49+OCDYeeOT/1UV1frj3/8o/7xj3/oJz/5STRvA4gaChU0usLCQu3Zs0f33HOPJKmqqkofffQRG1UB/+R0OtWtWzd169ZN7du315o1a9SvX7+wNsfXqGzYsEFz587VrFmz1KRJk7A2iYmJ6tq1q7Zu3XrKQsUwDH399ddq27ZtJG8HiCgKFTQqwzD04Ycfavr06aF5988//1yvvvoqhQogae/evXI4HEpLS5Mkffnll2rduvVp23u9Xr3//vv64IMPdO2114adq62tVWlpqQYMGHDS5wKBgJYuXSq3260OHTo07k0AUUShgka1detWuVyusMWBXbt21cyZM3XgwAG1atXKxNEB5quurtaCBQt05MgRxcXFKTU1VXfddddp16hI0i233KKZM2cqOztb0r/WqBx/BPnKK68MtX3mmWeUkJCgmpoaXXrppRo7dmzU7g2IBLbQBwAAlsXjyQAAwLIoVAAAgGVRqAAAAMuiUAEAAJZFoQIAACyLQgWwiTlz5mjp0qWSpC1btmj06NFR6XfIkCHat2/fKc9NmjRJq1evbtB17rnnHn322WdnNIaz+SwAe2MfFaAR3XPPPTp48KCcTqcSExPVs2dPjRgxotG/PbpLly6aOXNmve3WrFmj1atX67HHHmvU/gEgWkhUgEb24IMPavHixZo6dap27typV1999aQ2tbW1JowMAOyHRAWIEJfLpZ49e2r37t2SfphCGT58uN555x3V1tZqzpw5+vjjj7V06VLt379f7dq1029+85vQdue7du3Ss88+K5/Pp169esnhcISu/cUXX2jWrFl69tlnJUkVFRVauHChtmzZomAwqD59+qh///6aP3++AoGAhg4dqri4OC1cuFA1NTV66aWX9OGHHyoQCOjyyy/XsGHDQt8j8+abb+rtt9+Ww+E46Yvy6rJv3z7NmzdPX331lRwOh3r06KERI0aoWbNmoTY7duxQfn6+Dh48qMsvv1z//d//Heq3rt8FgHMXiQoQIRUVFfrkk0900UUXhd4rLi7Wn/70J82YMUO7du3S3Llzddddd2nBggXKycnRk08+qZqaGgUCAU2bNk3/8R//oQULFuiqq67SunXrTtmPYRiaOnWqkpOTNWfOHD377LPq06dP6I99586dtXjxYi1cuFCS9OKLL8rn82natGl65plnVFlZqeXLl0uSSkpK9NZbb2n8+PGaOXOmNm3a9KPu+aabbtK8efM0Y8YM+f1+vfLKK2Hn165dq0ceeUSzZs2Sz+fTa6+9Jkl1/i4AnNsoVIBGNm3aNA0bNkwTJ05U165dNWjQoNC5m266SUlJSWrSpIkKCgqUk5OjTp06yel0ql+/foqPj9f27du1bds21dbWauDAgYqPj1dGRoY8Hs8p+ystLVVlZaWGDh2qxMRENWnSRJdccskp2waDQa1evVp33nmnkpKSdP7552vQoEEqLCyUJBUVFalfv35q3769EhMTNXjw4Abfd2pqqi677DIlJCSoRYsWGjhwoDZv3hzWpn///kpOTlZSUpJuuummUL91/S4AnNuY+gEa2ZgxY3TZZZed8pzb7Q79XFFRoQ8++ECrVq0KvRcIBFRZWSmHwyGXyxU23ZOcnHzKa1ZUVKh169aKi4urd2yHDx/WsWPH9NBDD4XeCwaDMgxDknTgwAF17NgxdK6ub/X9dwcPHgxNP1VXV8swDCUlJYW1OfEeWrdurcrKytA9nO53AeDcRqECRNGJhYfb7dagQYPCEpfjNm/erMrKSgWDwdBn/H6/UlNTT2qbnJysiooK1dbW1lusNG/eXE2aNNHTTz8d9g3Xx7Vq1Up+vz90XFFR0eB7e+mllyRJTz31lJKSkrR+/XotWLAgrM2J16uoqAiNoa7fBYBzG1M/gEmys7P1t7/9Tdu3b1cwGFR1dbU2btyoqqoqde7cWU6nUytXrlQgENC6detUWlp6yutcfPHFatWqlV588UVVV1fr+++/19atWyVJLVu2VGVlpQKBgCTJ6XQqOztbCxcu1KFDhyRJlZWVKikpkSRdddVVWrNmjcrKynTs2LGT1pjUpaqqSomJiWratKkqKyv11ltvndTm3Xffld/v13fffafXXntNV111Vb2/CwDnNhIVwCQej0d33323FixYIJ/PF1pb0qVLF8XHx+uBBx7QvHnztHTpUvXq1UtXXHHFKa/jdDr14IMPasGCBRo5cqQcDof69OmjSy65RN27dw8tqnU6ncrLy9Mdd9yh5cuX65FHHtG3334rl8ula6+9Vj179lSvXr00cOBATZ48WU6nU7feeqvWrl3boPsZPHiwZs+erTvvvFOpqam6+uqrtWLFirA2ffv21eOPP64DBw7I6/Xq5ptvrvd3AeDc5ggGg0GzBwEAAHAqTP0AAADLolABAACWRaECAAAsi0IFAABYFoUKAACwLAoVAABgWRQqAADAsihUAACAZf0/eenGZcPHJMYAAAAASUVORK5CYII=\n","text/plain":["
"]},"metadata":{}},{"output_type":"display_data","data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAUUAAAFRCAYAAADjM7/QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deVxU5f4H8M8MqwOCDJuKuaASLhj8xMINUEf93bQuVlJmJppa4XUrTbPULO1npeJaelOx1HLLS2mmRSikuYBipqSIqLlAwAwgoMgyz+8PL9MZ2aZxxmHo8+41rzhnzvKdUb98n/M85zkyIYQAEREBAOSWDoCIqCFhUiQikmBSJCKSYFIkIpJgUiQikmBSJCKSYFK0oIqKCowdOxbu7u6QyWQ4ePCgSY7btm1bLFiwwCTHsgaXL1+GTCbDoUOHLB0KNQJMivdQq9V444038PDDD8PR0RFeXl4IDQ3F559/joqKCpOe66uvvsIXX3yB3bt3IysrC7169TLJcZOTkzFt2jSTHMtSVCoVoqKiDNr2oYceQlZWFh577DGTnPvOnTtYs2YNBg4ciFatWsHLywvBwcGYO3cucnJyatzn2LFj6NWrFxwdHdGiRQu8+eabqKysrPM8UVFRkMlk1V73/j3bu3cvAgMD4eDggLZt22Lp0qUm+ZxUM1tLB9CQXL16FX369IGtrS3effddBAUFwc7ODj///DMWL16Mbt26ITAw0GTnu3DhAnx8fEyWDKt4enqa9HgNWVlZGezt7dG8eXOTHO/s2bMYNmwYmjZtivHjx6Nr165o1qwZMjMzsX37dnTq1AlbtmzB//7v/+r2uXr1KgYOHIinn34an376KS5cuICxY8dCCIFFixbVeb6+ffti+/bteutsbf/8Z5mSkoJ//vOfmD59Or788kscO3YMr7zyChQKBV555RWTfGa6hyCdoUOHCm9vb1FQUFDtvbKyMlFcXKz7eebMmaJly5bCzs5OdOrUSWzZskVvewBi9erV4oUXXhDOzs7Cx8dHvP/++7r3w8LCBADdq02bNrr1L730kt6x3nvvPd37Qghx5swZMWjQIOHq6ioUCoXw9/cXn3/+ue79Nm3aiPfee0+3fPPmTTFhwgTh4eEh7O3tRffu3cX+/ft171+6dEkAENu2bRNDhgwRTZo0Ee3atROxsbF1fl+xsbHCxsZGJCQkiK5duwpHR0cRFhYmrl+/LhITE0VgYKBQKBRiwIAB4tq1a7r9MjMzxbBhw0SLFi1EkyZNRNeuXfXiHz16tN53A0AcOHBAF+fmzZvFP/7xD6FQKMQbb7yhW//TTz8JIYTYtm2bsLOzE8eOHdMd87PPPhOOjo7il19+qfXzXL9+XbRo0UIsWbKk1m0SExOFt7e3SE5O1q178803hY+Pj6isrNStW7VqlVAoFLq/MzUZPXq0GDBgQK3vCyHEiBEjRM+ePfXWTZ8+Xe/vA5kWk+J/qdVqIZfL9ZJJbaZPny6USqXYvn27OH/+vFi4cKGQyWQiPj5etw0A4eXlJf7973+LjIwMsWrVKgFAt41arRavv/66aNu2rcjKyhI5OTlCCMOSYkBAgBgxYoQ4e/asuHjxoti7d6/YvXu37v17k+Izzzwj2rRpI/bt2yfS0tLE5MmThZ2dnfjtt9+EEH8mxXbt2olt27aJCxcuiDfffFPY2NiI8+fP1/o9xMbGCplMJsLCwsTRo0fFiRMnRIcOHUSfPn1EWFiYOHLkiEhNTRUPP/ywiIyM1O13+vRpsXLlSnHq1CmRkZEhVqxYoUuuQghRUFAg+vbtKyIjI0VWVpbIysoSd+7c0cXp4+MjNm/eLDIzM0VmZma1pCiEEOPGjRO+vr6isLBQnD9/Xjg7O4vVq1fX+ec6atQoMW3aNCGEEEVFRWL8+PGiZcuWonPnzmLHjh3CyclJCCHE2rVrRf/+/XX7hYaGijFjxugdKyMjo1pM9xo9erRo2rSp8Pb2Fm3bthVPPfWUOHPmjN42rVu3FvPnz9dbFx8fLwCIq1ev1vl5yDhMiv917NgxAUB89dVXdW5XUlIi7O3tq/0Di4iIEP369dMtAxCTJk3S28bf31/MmjVLtzxv3jzRvn17vW0MSYouLi51VnHSpHjhwgUBQHz77bd62wQFBen+IVclFWmFVFFRIZydncWaNWtqPU9sbKwAIFJTU3XrPvzwQwFApKSk6NYtXbpUuLu713ocIYR48sknxbhx43TLAwYMEKNHj9bbpirOd999t8b10gRUUlIiOnfuLIYPHy4CAwNFREREnecvLi4WLi4uul9Or7zyiujevbtISkoSSUlJokePHqKqYVVaWiocHBxESUmJEEKIjh07ijfffLPa8QCI7du313rOL774QuzatUucPn1a/PDDD2Lw4MGiSZMm4tdff9VtY2dnJ9auXau335kzZwQAcfz48To/ExmHHS3/JQycFyMjIwNlZWUIDQ3VWx8WFoazZ8/qrbv3+mPLli3xxx9/3F+gAKZPn45x48YhPDwc77zzDk6ePFnrtmlpaQBQLd7Q0NA647WxsYGXl1e98cpkMgQEBOiWq67tdevWTW+dWq3WdTzcunULs2bNQpcuXaBUKuHs7Iy9e/fiypUrdZ6ryqOPPlrvNgqFAtu2bcOuXbuQk5OD9evX17l9eno6Wrdurbseu2vXLixfvhx9+/ZF3759sWTJEt22Dg4OcHFxQWFhoUHx1mbEiBEYNmwYAgICoFKp8M0338DHxwcrVqy4r+PS/WFS/K+OHTtCLpfrkogp2Nvb6y3LZDJotdo695HL5dUSdHl5ud7ynDlzkJ6ejsjISJw5cwYhISF4++23LRavjY2N3j4AYGdnV21d1eeaMWMGNm/ejHnz5uHAgQM4deoUHn/8cZSVlRkUp5OTk0HbVQ3RKSwsRG5ubp3bVlRUoEmTJrrlO3fu6J2nadOmup+vXr2KsrIyeHl5AQBatGiB7OxsveNV/TJp0aKFQbECd7//4OBgXL58WbfOVMcmwzEp/pdSqcQ//vEPrFq1qsYKoLy8HCUlJejQoQMcHByQlJSk935iYiK6du1633F4eXnhxo0beutqqgR9fX0RHR2NnTt34t1338Unn3xS4/G6dOkCANXiTUpKMkm8xkhKSsLIkSMRGRmJRx55BL6+vkhPT9fbxt7evt4hLXU5c+YMXnvtNaxbtw4qlQrPPfcc7ty5U+v2VTFUbRMeHo6FCxeiqKgIRUVFWLhwIQDg999/x4svvoipU6fqfhn07t0bP/zwg94vkH379kGhUCAoKMjgmCsrK/HLL7/goYce0q3r3bs39u/fr7fdvn370KZNG7Rq1crgY5PhmBQlPv74Y9jZ2aF79+744osvkJaWhoyMDGzevBnBwcG4cOECFAoFJk+ejDlz5mDHjh1IT0/H+++/j6+//hqzZ8++7xhUKhXi4+OxY8cOZGRkYNGiRfjpp5907xcXF2PixIlISEjApUuXkJqain379qFz5841Hq99+/YYPnw4oqOjsX//fpw7dw5TpkzBmTNnMGPGjPuO1xgPP/wwvv76axw/fhxpaWmYMGFCtV8E7dq1w4kTJ3Dx4kXk5eVVq5brUlpaihEjRiAiIgJRUVHYsGED8vLy8MYbb9S6j7u7O4KDg7Fu3ToAwPLly5GZmQlXV1d4eXnpLhEEBwdDpVJh7ty5un1fffVVFBYWYvz48Th79iy++eYbzJkzB5MmTdJVm9evX4e/vz/+85//ALj75/jaa6/h8OHDuHz5Mo4fP47nnnsOmZmZmDhxou7Y06ZNw/Hjx/HWW2/h3Llz+Oyzz7By5UrMmjXL4O+D/iILX9NscHJycsTrr78uOnbsKBwcHISnp6cIDQ0VmzZtEuXl5UIIw4fkbNq0SW/dvZ0HNXW0lJWViSlTpghPT0/h6uoqoqOjxZw5c3QdLbdv3xYjRowQbdu21cUXGRkpfv/9d90x7u19LiwsNGhIzr09pe3btxfz5s2r9buqGpIjtWnTJnHvX6svv/xSANB9f7///rsYNGiQUCgUonnz5mLu3Lli7NixIiwsTLfPxYsXRd++fYWTk1O1ITn3xnnv+ldeeUW0a9dOFBYW6rZJSkoStra2Ys+ePbV+npSUFOHm5iYOHDigW/fHH3/ohtVcv35daLXaGvc9cuSI6Nmzp3BwcBDe3t5i1qxZoqKiolqMVR1kt27dEoMHDxbe3t7Czs5OtGzZUjzxxBPixIkT1Y69Z88e0a1bN2Fvby9at25d55Ahun8yITjzNlGVuLg4REVFYfTo0Rg7diy6du0KGxsbZGZmYt26dTh8+DAOHDgAuZyNrMaKf7JEEhEREThx4gRu3ryJfv36wd7eXndJJTs7G7GxsUyIjRwrRaJaaLVa5OTkQKvVwtvbW6+XnRovJkUiIgm2A4iIJJgUiYgkrGLqsHfajLR0CGSk5epjlg6B7kN+cYZR+5XnZRq1n52Hr1H7mRIrRSIiCauoFInIymiNv0XT0pgUicj0RN0TiTRkTIpEZHr1zK7UkDEpEpHJCVaKREQSrBSJiCRYKRIRSbD3mYhIgpUiEZEErykSEf2Jvc9ERFKsFImIJFgpEhFJmLH3eeLEiXB0dNQ9c3zRokUoLi5GTEwMcnNz4enpiWnTpsHZ2RlCCMTGxiI1NRUODg6Ijo6Gr2/dM/EwKRKR6Zm5Upw3bx5cXFx0y3FxcQgICEBERATi4uIQFxeHF154AampqcjOzsaKFStw4cIFrFu3Du+//36dx+bUYURkelqtcS8jJScnIywsDAAQFhaG5ORkAEBKSgpCQ0Mhk8ng5+eHkpIS5Ofn13ksVopEZHpmrhQXLlwIABg4cCBUKhUKCwvh5uYGAGjWrBkKCwsBABqNBh4eHrr93N3dodFodNvWhEmRiBqM+Ph4xMfH65ZVKhVUKpXeNu+99x6USiUKCwuxYMECtGzZUu99mUwGmUxmdAxMikRkekY2hVWqwdWS4L2USiUAwNXVFT169EBGRgZcXV2Rn58PNzc35Ofn6643KpVK5OXl6fZVq9W6/WvDa4pEZHJCVBr1qk9paSlu376t+/n06dNo3bo1goODkZiYCABITExEjx49AADBwcFISkqCEALp6elQKBR1Np0BVopEZA5muqZYWFiIxYsXAwAqKyvRp08fBAYGon379oiJiUFCQoJuSA4ABAUF4eTJk5g8eTLs7e0RHR1d7zlkQghhluhNiE/zs158mp91M/ZpfqUnvzFqP8f/edKo/UyJlSIRmR7vaCEikuB8ikREEqwUiYgkOEsOEZEEK0UiIglWikREEkyKRER/MuTulIaKSZGITI+VIhGRBDtaiIgkWCkSEUlYcaXIqcOIiCRYKRKR6bH5TEQkYcXNZyZFIjI9VopERBJMikREEmw+ExFJsFIkIpJgpUhEJMFKkYhIgpUiEZEEK0UiIgkmRSIiCSEsHYHRmBSJyPRYKRIRSTApEhFJsPeZiEjCiitFTjJLRCTBSpGITI+9z0REElbcfGZSJCLTY1IkIpJg7zMR0Z+EltcUiYj+xOYzEZEEm89ERBJsPhMRSbD5TEQkwaRItXFpocSwmFfh7OEKIQROfJGAY7H70fnxRxE+7Wl4dmiJT5+cixu/XtLt0yf6SfzPs2HQVmrx3Tuf42LSrxb8BFSlQ8d22PDZct1ym7at8X8LlsG1mQtejIqEOk8DAHjvnSX44ftES4XZMPCOFqqNtlKL7xdsQdaZy7B3csTLexYg89AZ5KRfw7aXl+GJ98fqbe/Z0QddnwjB6oEz0dTbDS9ueRMrw1+36iEOjUXGhUsI7fUkAEAulyPtwmF8u/t7PD/qGXyyKharVqy3cIQNiBVXipwQwsyKcwqQdeYyAKCspBS5GTfQ1NsNeRk3oM7Mqrb9wwO748zuo6gsq0DB1VxoLv8Bn8D2Dzhqqk9YeC9czvwdV6/esHQoDZNWGPdqAB5IpXj9+nUkJydDo7nbvFAqlQgODkarVq0exOkbjGatPNCiSxtcP3Wx1m1cmrvhWmqGbvlmtgYuzZUPIjz6C556Zgi+2rlHtzz+5VF47vlhSD35K96e/X8oLLhpwegaACsekmP2SjEuLg7Lli0DAHTo0AEdOnQAACxfvhxxcXHmPn2DYa9wQOSaqdj37ibcKb5t6XDoPtjZ2eEfQwYg7j97AQAb1m1BUEB/9O35BP74IxcL3n/TwhE2AKwUa3fgwAEsWbIEtrb6pxo6dChee+01RERE1LhffHw84uPjAQCO5g7SzOS2NohcMxW/xh3Gb/tS6tz2ZnY+XFq465ZdmitxM1tj7hDpL1ANCsMvp9KQm6MGAN3/AeCz2G3YtvNTS4XWYAheU6ydTCZDfn5+tfX5+fmQyWS17qdSqbBo0SIsWrTInOE9EP/8cDzyMq7jyLrv6t32/A8n0PWJENjY26LZQ55wb9e8zuY2PXjPDB+Kr3bs1i17e3vqfh76xCD8lpZuibDIRMxeKUZFReHdd99FixYt4O5+twLKy8tDdnY2XnrpJXOf3uJaB/vhkaf74o/ffscre98HAPz40TbY2Nvh8fmjoVA2xfOxM5CddgWbX/wAuReu4+y3xzAx/kNoKyrx7ZyN7HluQBSKJgjv1xvTJr+tWzd/wUwEdOsEIQR+v3Jd772/LSv+OysTwvwDirRaLTIyMvQ6Wjp06AC53LBC9Z02I80ZHpnRcvUxS4dA9yG/OKP+jWpQsuAFo/ZzentzvdtotVrMmjULSqUSs2bNQk5ODpYtW4aioiL4+vpi0qRJsLW1RXl5OVatWoXMzEw0bdoUU6dOhZeXV73HfyBDcuRyOfz8/BASEoKQkBD4+fkZnBCJyAqZsaNl79698PHx0S1v3rwZQ4YMwcqVK+Hk5ISEhAQAQEJCApycnLBy5UoMGTIEW7ZsMej4zExEZHparXGveqjVapw8eRIDBgwAAAghcPbsWYSEhAAAwsPDkZycDABISUlBeHg4ACAkJARnzpyBIQ1jJkUiMj0zVYobN27ECy+8oOukLSoqgkKhgI2NDYC7l+aqLtNpNBpdP4aNjQ0UCgWKiorqPQdv8yMi0zNy8LZ0KB5wdxSKSqUCAJw4cQKurq7w9fXF2bNnTRJmTZgUicj0jOx9libBe50/fx4pKSlITU1FWVkZbt++jY0bN+LWrVuorKyEjY0NNBoNlMq7d4AplUqo1Wq4u7ujsrISt27dQtOmTeuNgUmRiEzOHIO3n3/+eTz//PMAgLNnz2L37t2YPHkyli5diqNHj6J37944ePAggoODAQDdu3fHwYMH4efnh6NHj6JLly51jo2uwmuKRGR6D/A2v5EjR2LPnj2YNGkSiouL0b9/fwBA//79UVxcjEmTJmHPnj0YOdKwoX0PZJzi/eI4RevFcYrWzdhxisUzhhm1n/NH/zFqP1Ni85mITM+KZ8lhUiQi07Pi2/yYFInI5Kz5fn0mRSIyPSZFIiIJK55PkUmRiEyPlSIRkYQVJ0UO3iYikmClSEQmZwX3hNSKSZGITM+Km89MikRkekyKRER/4uBtIiIpJkUiIgnrHbvNpEhEpsfmMxGRFJMiEZEEm89ERH9i85mISIqVIhHRn1gpEhFJsVIkIvqTFT+3ikmRiMygMSbFuXPnQiaT1XuA+fPnmzQgIrJ+jbJS7N+//4OMg4ioQag1KYaHhz/AMIioUWmMlaKUEAI//vgjDh8+jKKiIixevBhpaWkoKChAr169zB0jEVkZa24+G/SMlm3btuHAgQNQqVTIy8sDALi7u+Prr782a3BEZJ2E1rhXQ2BQUkxMTMTMmTPRu3dvXeeLl5cXcnJyzBocEVkna06KBjWftVotHB0d9daVlpZWW0dEBAAQ9Y9caagMqhSDgoLw+eefo7y8HMDda4zbtm1D9+7dzRocEVkna64UDUqKL774IvLz8xEVFYVbt27hxRdfRG5uLkaOHGnu+IjICgmtzKhXQ2BQ81mhUGDGjBkoLCxEbm4uPDw80KxZM3PHRkRWqqFUfcYw+Da/kpISnD59Gvn5+XBzc0NQUBCcnZ3NGRsRWSlhxdcUDUqKZ86cweLFi9GyZUt4eHhArVZj/fr1eP311xEQEGDuGInIyjT6SnH9+vWYMGGC3kDtI0eOYP369Vi2bJnZgiMi69RQrg8aw6COlvz8fISEhOite/TRR1FQUGCWoIjIuglh3KshMCgphoaGYt++fXrrvv/+e4SGhpolKCKybo2y91k6dZhWq8UPP/yAb775BkqlEhqNBoWFhejYseMDC5SIrEdDSXDGMHjqsAEDBpg9GCJqHBpKU9gYnDqMiEyuUVaK9yooKEBGRgaKioogJL8GOBktETUmBiXF48ePY+XKlWjRogWuXr2Khx56CFevXoW/vz+TIhFV0+gHb2/btg3R0dHo2bMnxowZgw8//BAHDhzA1atXzR0fEVkhax68bdCQnLy8PPTs2VNvXVhYGJKSkswSFBFZN62QGfVqCAyqFF1cXFBQUIBmzZrB09MT6enpaNq0KbRaK/51QERm0+ibzwMGDMC5c+cQEhKCIUOGYP78+ZDJZBg6dKi54yMiK9Toe58jIiJ0P4eFhaFLly4oLS1Fq1atzBYYEVmvRjlOsS4eHh6mjoOIGhFzVYplZWWYN28eKioqUFlZiZCQEERGRiInJwfLli1DUVERfH19MWnSJNja2qK8vByrVq1CZmYmmjZtiqlTp8LLy6vOc9SaFF999VWDgvzkk0/+2qciokbPXJ0mdnZ2mDdvHhwdHVFRUYG5c+ciMDAQe/bswZAhQ9C7d2/8+9//RkJCAgYNGoSEhAQ4OTlh5cqVOHz4MLZs2YJp06bVeY5ak+KkSZNM/oGI6O/BXB0tMplM98C8yspKVFZWQiaT4ezZs5gyZQqAu3fj7dixA4MGDUJKSgqGDx8OAAgJCcGGDRsghNDN61CTWpNi586dTflZiOhvxJzXFLVaLWbOnIns7GwMHjwY3t7eUCgUsLGxAQDdpDUAoNFo4O7uDgCwsbGBQqFAUVERXFxcaj2+UdcUiYjqYmzzOT4+HvHx8bpllUoFlUqlt41cLsdHH32EkpISLF68GDdu3LivWO/FpEhEJmds87mmJFgbJycndOnSBenp6bh16xYqKythY2MDjUYDpVIJ4G7VqFar4e7ujsrKSty6dQtNmzat87gG3dFCRPRXmGvm7Zs3b6KkpATA3Z7o06dPw8fHB126dMHRo0cBAAcPHkRwcDAAoHv37jh48CAA4OjRo+jSpUud1xMBQCZEwx9RZGvvY+kQyEi3b/xk6RDoPth5+Bq1X0qriPo3qkHwtbg6379y5QpWr14NrVYLIQR69uyJZ555Bn/88QeWLVuG4uJitGvXDpMmTYKdnR3KysqwatUqXLp0Cc7Ozpg6dSq8vb3rPEetSXHlypX1ZlQA+Ne//lXvNveLSdF6MSlaN2OTYrLPMKP263H9P0btZ0q1XlNs3rz5g4yDiBqRhjK5gzFqTYpVY3uIiP5ODO59rqiowI0bN3Dz5k299V27djV5UERk3Rp8R0UdDEqK586dw9KlS1FeXo7bt2+jSZMmKC0thbu7O1atWmXuGInIyjTK5rPUZ599hieffBJDhw7FmDFjEBsbi507d8Le3t7c8RGRFbLm+RQNGqd448YNPP7443rrIiIi8O2335olKCKyblojXw2BQUlRoVDg9u3bAIBmzZrh2rVrKC4uRmlpqVmDIyLrJCAz6tUQGNR8fuyxx5Camoo+ffqgX79+mD9/PmxsbBASEmLu+IjICmmtuKfFoKQYFRWl+/nJJ59Ex44dUVpaikceecRccRGRFdM2kKrPGEZNCNGpUydTx0FEjUhDaQobw6CkOHfu3Fpv+Zs/f75JAyIi69dQOk2MYVBS7N+/v95yQUEBDhw4gL59+5olKCKybo2+UgwPD6+2LiQkBB9//DGeeeYZU8dERFau0VeKNVEqlbhy5YopYyGiRqLRJ8WEhAS95bKyMhw7dgx+fn5mCYqIrFujbz7/9JP+nHgODg54+OGHMWTIELMERUTWzUyPfX4gDEqK8+bNM3ccRNSIWPM4RYNu8xszZkyN68eNG2fSYIiocRBGvhoCg5JiZWVltXUVFRXQaq35cioRUXV1Np+rBm2Xl5dXa0Kr1Wp2tBBRjay5XKozKVYN2s7IyEC/fv1062UyGVxdXTnrNhHVSGvAQ+8aqjqTYtWg7Y4dO8LHh0/UIyLDNJTrg8Yw6Jri/v37cf78eb1158+fx8aNG80RExFZuUY/yezhw4fRvn17vXW+vr44dOiQWYIiIuumlRn3aggMGqcok8mq9TRrtVoIYc1FMhGZS6Mfp+jv74+tW7fqEqNWq8WOHTvg7+9v1uCIyDpZ8zhFgyrFMWPGYNGiRXj55Zfh4eGBvLw8uLm54Y033jB3fERkhRpKU9gYBiVFd3d3fPDBB8jIyIBarYa7uzs6dOhg7tiIyEo1lE4TYxjUfAYAuVwOPz8/9OzZE46OjtiyZQteffVVc8ZGRFaq0TefAeDmzZs4dOgQEhMTcfnyZfj7++s90IqIqEqjbT5XVFQgJSUFBw8exC+//ILmzZujd+/eyM3NxWuvvQZXV9cHFScRWRFrbj7XmRTHjx8PuVyOsLAwREZGwtfXFwDw/fffP5DgiMg6WXNSrPOaYps2bVBSUoKMjAxcvHgRxcXFDyouIrJiQmbcqyGos1J85513kJubi8TEROzevRuxsbHo1q0b7ty5U+N0YkREgHVXijLxF25LOXfuHBITE3HkyBHY2NigX79+eOGFF8wZHwDA1p6TUVir2zd+qn8jarDsPHyN2m/VQ8blhX9d3WzUfqb0l57m5+/vD39/f4wZMwbHjx9HUlKSueIiIivWUIbXGMOoR5za29ujT58+6NOnj6njISKyKKOf+0xEVJtGO06RiMgY1tzRwqRIRCbHpEhEJPG362ghIqoLrykSEUmw+UxEJMHmMxGRhNaK0yKTIhGZHJvPREQS1lsnMikSkRmwUiQikuCQHCIiCXN1tOTl5WH16tUoKCiATCaDSqXC448/juLiYsTExCA3Nxeenp6YNm0anJ2dIYRAbGwsUlNT4eDggOjoaBxrSDUAAA8zSURBVN0TBGpj8NP8iIgMZa6n+dnY2GDUqFGIiYnBwoULsX//fly7dg1xcXEICAjAihUrEBAQgLi4OABAamoqsrOzsWLFCkyYMAHr1q2r9xxMikRkclojX/Vxc3PTVXpNmjSBj48PNBoNkpOTERYWBgAICwtDcnIyACAlJQWhoaGQyWTw8/NDSUkJ8vPz6zwHm89EZHLGNp/j4+MRHx+vW1apVFCpVDVum5OTg0uXLqFDhw4oLCyEm5sbAKBZs2YoLCwEAGg0Gnh4eOj2cXd3h0aj0W1bEyZFImow6kqCUqWlpViyZAmioqKgUCj03pPJZJDJjO/pYfOZiEzOXNcUgbvPo1+yZAn69u2Lxx57DADg6uqqaxbn5+fDxcUFAKBUKpGXl6fbV61WQ6lU1nl8JkUiMjlzXVMUQmDNmjXw8fHB0KFDdeuDg4ORmJgIAEhMTESPHj1065OSkiCEQHp6OhQKRZ1NZ4DNZyIyA3MNyTl//jySkpLQunVrzJgxAwAwYsQIREREICYmBgkJCbohOQAQFBSEkydPYvLkybC3t0d0dHS95/hLjzi1FD7i1HrxEafWzdhHnE5r+5xR+8Vc3mrUfqbESpGITI63+RERSQgrnhKCSZGITI6VIhGRBCeZJYNlpB9FUXExKiu1qKioQEjPxwEAE6PH4NVXo1BZWYnvvvsRs95caOFIqcqgp0fDSaGAXC6HjY0Ntm9YgZX//hwJh45ALpND6eaKhW+9Di9Pd2ReuYo5C5ciLT0DkyeMxpjnn7F0+BZhvSmRSdEiVAOHQ63+8/7L8LBeePKJwfif7gNRVlYGT093C0ZHNdmwchHcmrnqlseMfBqTJrwIANi842t8EvsF5r0xCa4uTTFr2itISDpiqVAbBGuuFDl4uwF4+eUX8eFHq1FWVgYAyM1VWzgiqo+zk5Pu59u3S1F1V5m7WzMEdHoYtrZ/73rDXIO3HwQmxQdMCIHv9n6JY0e/w7iXRgIAOnb0RZ8+j+LnQ7uREL8Twd0fsXCUJCWTyTBh2luIHDsJO77eq1u/fO1GDBg2Ct9+fwD/GjfKghE2PMLI/xoCi/46O3DgAPr162fJEB64sH7DcONGNjw93bHvu604fz4DtrY2cHNrhl59nkCP4EB8+cUadHy4p6VDpf/6/JPF8Pb0gDq/AOOnzka7Ng8hODAAU16OwpSXo/Dp59vwxVe7mRglGkrVZwyLVorbt2+v9b34+HjMmjULs2bNeoARmd+NG9kA7jaRv/76O/ToEYjr17IQF/cdACA55RS0Wi08POq+aZ0eHG/Pu1NPubs1w4DQXvg17bze+0MH9UP8wcOWCK3BYqVYh+nTp9e4Xgihm/OsJtIphBYv3WSW2B40haIJ5HI5iotLoFA0wUBVGBYsjEFx8S2Eh/fCwcSf0bGjL+zt7ZGXp7F0uATg1u1SCK0WTk4K3Lpdip+Pn8SrY57HlavX0eahu7efJvx0BO3atLJwpA2LNVeKZk+KhYWFeOutt+AkuTAN3E2Kc+bMMffpGxRvb0/s3LEeAGBra4OtW+Ow//uDsLOzw7pPl+BU6o8oKyvH2JemWjhSqqLW5GPK7PcAAJUVlXh8UDj6hARj6uwFuPz7NcjkMrRs7oW5MyYBAPLUGjz70mQUl9yCXC7H5u1x+HrLWr2Omb8DbcOfUqFWZp8Q4pNPPkG/fv3g7+9f7b3ly5djypQp9R6DE0JYL04IYd2MnRBiVJunjNpv05VdRu1nSpwlh8yKSdG6GZsUXzAyKW5uAEnx7z2YiojMwpoHbzMpEpHJNZSeZGMwKRKRybH3mYhIgs1nIiIJNp+JiCTYfCYikrCCkX61YlIkIpPjNUUiIgk2n4mIJNjRQkQkweYzEZEEO1qIiCR4TZGISILXFImIJKz5miKf5kdEJMFKkYhMjh0tREQS1tx8ZlIkIpNjRwsRkYQ1P82PSZGITM56UyKTIhGZAa8pEhFJMCkSEUlwSA4RkQQrRSIiCQ7JISKSYPOZiEiCzWciIglWikREEqwUiYgk2NFCRCRhzfc+c5JZIiIJVopEZHJsPhMRSZir+fzxxx/j5MmTcHV1xZIlSwAAxcXFiImJQW5uLjw9PTFt2jQ4OztDCIHY2FikpqbCwcEB0dHR8PX1rfccbD4TkckJI/+rT3h4OGbPnq23Li4uDgEBAVixYgUCAgIQFxcHAEhNTUV2djZWrFiBCRMmYN26dQbFzqRIRCanFcKoV306d+4MZ2dnvXXJyckICwsDAISFhSE5ORkAkJKSgtDQUMhkMvj5+aGkpAT5+fn1noNJkYhMzlyVYk0KCwvh5uYGAGjWrBkKCwsBABqNBh4eHrrt3N3dodFo6j0erykSkckZe00xPj4e8fHxumWVSgWVSmXw/jKZDDKZzKhzV2FSJCKTM7bq+6tJEABcXV2Rn58PNzc35Ofnw8XFBQCgVCqRl5en206tVkOpVNZ7PDaficjkhNAa9TJGcHAwEhMTAQCJiYno0aOHbn1SUhKEEEhPT4dCodA1s+siE1Zw57atvY+lQyAj3b7xk6VDoPtg51H/EJaatHHvZtR+V9Sn63x/2bJlSEtLQ1FREVxdXREZGYkePXogJiYGeXl51YbkrF+/Hr/88gvs7e0RHR2N9u3b1xsDkyKZFZOidTM2KbZWBhi13++aX43az5R4TZGITI6z5BARSVhBA7RWTIpEZHLWPEsOkyIRmRwnhCAikmDzmYhIgh0tREQS1lwp8o4WIiIJVopEZHLsfSYikrDm5jOTIhGZHDtaiIgkWCkSEUnwmiIRkQTvaCEikmClSEQkwWuKREQSbD4TEUmwUiQikmBSJCKSsN6UaCUPrmrs4uPj//Kzbqnh4J9f48JZchqA+Ph4S4dA94F/fo0LkyIRkQSTIhGRBJNiA8DrUdaNf36NCztaiIgkWCkSEUlwnKKFnTp1CrGxsdBqtRgwYAAiIiIsHRIZ6OOPP8bJkyfh6uqKJUuWWDocMhFWihak1Wqxfv16zJ49GzExMTh8+DCuXbtm6bDIQOHh4Zg9e7alwyATY1K0oIyMDDRv3hze3t6wtbVFr169kJycbOmwyECdO3eGs7OzpcMgE2NStCCNRgN3d3fdsru7OzQajQUjIiImRSIiCSZFC1IqlVCr1bpltVoNpVJpwYiIiEnRgtq3b4+srCzk5OSgoqICP//8M4KDgy0dFtHfGgdvW9jJkyfx2WefQavVol+/fnjqqacsHRIZaNmyZUhLS0NRURFcXV0RGRmJ/v37Wzosuk9MikREEmw+ExFJMCkSEUkwKRIRSTApEhFJMCkSEUkwKZKe1atXY+vWrQCA3377DVOmTHkg542MjER2dnaN773zzjv48ccfDTrOxIkTcfr0aaNiuJ99qfHg1GFWaOLEiSgoKIBcLoejoyMCAwPx0ksvwdHR0aTn6dSpE5YvX17vdgcPHsSPP/6I9957z6TnJ7IEVopWaubMmdi0aRM++OADZGZm4quvvqq2TWVlpQUiI7JurBStnFKpRGBgIK5evQrgbjN07Nix2Lt3LyorK7F69WqcOHECW7duRW5uLlq1aoXx48ejTZs2AIBLly5hzZo1yMrKQlBQEGQyme7YZ8+excqVK7FmzRoAQF5eHjZu3IjffvsNQgj07t0bgwcPxqeffoqKigqMGjUKNjY22LhxI8rLy/Hll1/iyJEjqKioQI8ePRAVFQV7e3sAwDfffIM9e/ZAJpPh2WefNfjzZmdnY+3atbhy5QpkMhkeeeQRvPTSS3ByctJtc/HiRcTGxqKgoAA9evTAuHHjdOet67sgAlgpWr28vDykpqaibdu2unXJycl4//33ERMTg0uXLuGTTz7BhAkTsGHDBqhUKnz44YcoLy9HRUUFPvroI/Tt2xcbNmxAz549cezYsRrPo9Vq8cEHH8DDwwOrV6/GmjVr0Lt3b11i8fPzw6ZNm7Bx40YAwJYtW5CVlYWPPvoIK1asgEajwc6dOwHcnW189+7dePvtt7F8+XL8+uuvf+kzDxs2DGvXrkVMTAzUajV27Nih9/6hQ4fw1ltvYeXKlcjKysKuXbsAoM7vgqgKk6KV+uijjxAVFYW5c+eic+fOevdMDxs2DM7OzrC3t0d8fDxUKhU6duwIuVyO8PBw2Nra4sKFC0hPT0dlZSWGDBkCW1tbhISEoH379jWeLyMjAxqNBqNGjYKjoyPs7e3h7+9f47ZCCPz4448YPXo0nJ2d0aRJEzz11FM4fPgwAODnn39GeHg4WrduDUdHRwwfPtzgz928eXN069YNdnZ2cHFxwZAhQ5CWlqa3zeDBg+Hh4QFnZ2cMGzZMd966vguiKmw+W6kZM2agW7duNb4nnbg2Ly8PiYmJ2Ldvn25dRUUFNBoNZDIZlEqlXpPZw8OjxmPm5eXB09MTNjY29cZ28+ZN3LlzB7NmzdKtE0JAq9UCAPLz8+Hr66t7z9PTs95jVikoKNA14UtLS6HVaqvNfi39DJ6enrqJe+v6LoiqMCk2QtIk5+7ujqeeeqrG2XfS0tKg0WgghNDto1ar0bx582rbenh4IC8vD5WVlfUmxqZNm8Le3h5Lly6tcX5INzc3vXkk8/LyDP5sX375JQBgyZIlcHZ2xvHjx7Fhwwa9baTHy8vL08VQ13dBVIXN50ZuwIAB+OGHH3DhwgUIIVBaWoqTJ0/i9u3b8PPzg1wux3fffYeKigocO3YMGRkZNR6nQ4cOcHNzw5YtW1BaWoqysjKcO3cOANCsWTNoNBpUVFQAAORyOQYMGICNGzeisLAQwN1HL5w6dQoA0LNnTxw8eBDXrl3DnTt3ql0TrMvt27fh6OgIhUIBjUaD3bt3V9tm//79UKvVKC4uxq5du9CzZ896vwuiKqwUG7n27dvj5ZdfxoYNG5CVlaW7FtipUyfY2tpi+vTpWLt2LbZu3YqgoCA8+uijNR5HLpdj5syZ2LBhA6KjoyGTydC7d2/4+/uja9euug4XuVyO9evXY+TIkdi5cyfeeustFBUVQalUYuDAgQgMDERQUBCGDBmC+fPnQy6X49lnn8WhQ4cM+jzDhw/HqlWrMHr0aDRv3hyhoaH49ttv9bbp06cPFixYgPz8fAQHB+Ppp5+u97sgqsL5FImIJNh8JiKSYFIkIpJgUiQikmBSJCKSYFIkIpJgUiQikmBSJCKSYFIkIpJgUiQikvh/Asfw1REcIW4AAAAASUVORK5CYII=\n","text/plain":["
"]},"metadata":{}}]},{"cell_type":"markdown","metadata":{"id":"EgtfvUnoOxSe"},"source":["## Saving model"]},{"cell_type":"code","metadata":{"id":"cNSsQyzKaUvs","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1643866697937,"user_tz":360,"elapsed":71957,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"bbdcf826-b944-4e7f-8794-8366f2628bc3"},"source":["# saving model weights.\n","CDR_model.save('./Model/RBD_HA_CDR_model')\n","# load model\n","# CDR_model = keras.models.load_model('./Model/RBD_HA_CDR_model')"],"execution_count":55,"outputs":[{"output_type":"stream","name":"stderr","text":["WARNING:absl:Found untraced functions such as embedding_6_layer_call_fn, embedding_6_layer_call_and_return_conditional_losses, dropout_65_layer_call_fn, dropout_65_layer_call_and_return_conditional_losses, embedding_7_layer_call_fn while saving (showing 5 of 1260). These functions will not be directly callable after loading.\n"]},{"output_type":"stream","name":"stdout","text":["INFO:tensorflow:Assets written to: ./Model/RBD_HA_CDR_model/assets\n"]},{"output_type":"stream","name":"stderr","text":["INFO:tensorflow:Assets written to: ./Model/RBD_HA_CDR_model/assets\n"]}]},{"cell_type":"markdown","metadata":{"id":"_ww5F8FS0SdD"},"source":["## Evaluate results"]},{"cell_type":"code","metadata":{"id":"NUQfbVN8koaK","executionInfo":{"status":"ok","timestamp":1643865101812,"user_tz":360,"elapsed":134,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["# Utility function: Display model score(Loss & Accuracy and so on) across all sets.\n","\n","def display_model_score(model, train, val, test, batch_size):\n","\n"," train_score = model.evaluate(train[0], train[1], batch_size=batch_size, verbose=1)\n"," print('Train loss: ', train_score[0])\n"," print('Train accuracy: ', train_score[5])\n"," print('Train Precision: ', train_score[6])\n"," print('Train Recall: ', train_score[7])\n"," print('Train AUC: ', train_score[8])\n"," print('Train PRC: ', train_score[9])\n"," print('-'*70)\n","\n"," val_score = model.evaluate(val[0], val[1], batch_size=batch_size, verbose=1)\n"," print('Val loss: ', val_score[0])\n"," print('Val accuracy: ', val_score[5])\n"," print('Val Precision: ', val_score[6])\n"," print('Val Recall: ', val_score[7])\n"," print('Val AUC: ', val_score[8])\n"," print('Val PRC: ', val_score[9])\n"," print('-'*70)\n"," \n"," test_score = model.evaluate(test[0], test[1], batch_size=batch_size, verbose=1)\n"," print('Test loss: ', test_score[0])\n"," print('Test accuracy: ', test_score[5])\n"," print('Test Precision: ', test_score[6])\n"," print('Test Recall: ', test_score[7])\n"," print('Test AUC: ', test_score[8])\n"," print('Test PRC: ', test_score[9])"],"execution_count":29,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"_ct8BQbSkMlO","executionInfo":{"status":"ok","timestamp":1643865418210,"user_tz":360,"elapsed":2562,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"34288bfb-c620-4c47-ef44-532321afbf49"},"source":["display_model_score(CDR_model,\n"," [[train_x1,train_x2,train_x3,train_x4,train_x5,train_x6], y_train],\n"," [[val_x1,val_x2,val_x3,val_x4,val_x5,val_x6], y_val],\n"," [[test_x1,test_x2,test_x3,test_x4,test_x5,test_x6], y_test],\n"," 256)\n"],"execution_count":43,"outputs":[{"output_type":"stream","name":"stdout","text":["11/11 [==============================] - 1s 95ms/step - loss: 0.2089 - tp: 1810.0000 - fp: 95.0000 - tn: 764.0000 - fn: 118.0000 - accuracy: 0.9236 - precision: 0.9501 - recall: 0.9388 - auc: 0.9679 - prc: 0.9850\n","Train loss: 0.20890021324157715\n","Train accuracy: 0.9235737323760986\n","Train Precision: 0.9501312375068665\n","Train Recall: 0.9387966990470886\n","Train AUC: 0.9679316878318787\n","Train PRC: 0.9849563837051392\n","----------------------------------------------------------------------\n","3/3 [==============================] - 0s 91ms/step - loss: 0.4131 - tp: 426.0000 - fp: 62.0000 - tn: 150.0000 - fn: 59.0000 - accuracy: 0.8264 - precision: 0.8730 - recall: 0.8784 - auc: 0.8858 - prc: 0.9418\n","Val loss: 0.4130643904209137\n","Val accuracy: 0.8263988494873047\n","Val Precision: 0.8729507923126221\n","Val Recall: 0.8783504962921143\n","Val AUC: 0.885810136795044\n","Val PRC: 0.9417612552642822\n","----------------------------------------------------------------------\n","4/4 [==============================] - 0s 80ms/step - loss: 0.3935 - tp: 529.0000 - fp: 72.0000 - tn: 213.0000 - fn: 58.0000 - accuracy: 0.8509 - precision: 0.8802 - recall: 0.9012 - auc: 0.8994 - prc: 0.9438\n","Test loss: 0.3934806287288666\n","Test accuracy: 0.8509174585342407\n","Test Precision: 0.880199670791626\n","Test Recall: 0.9011924862861633\n","Test AUC: 0.8993514776229858\n","Test PRC: 0.9437721371650696\n"]}]},{"cell_type":"code","metadata":{"id":"YJk8AsVzTdoy"},"source":["#load model\n","CDR_model = keras.models.load_model('./Model/RBD_HA_CDR_model')"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["### Model evaluation and export on Spike-HA dataset"],"metadata":{"id":"Q_G6Qa5zRBcd"}},{"cell_type":"code","metadata":{"id":"Lu4TIRL_Y4oy","executionInfo":{"status":"ok","timestamp":1643865618679,"user_tz":360,"elapsed":148,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["def eval_model(model, train, val, test, batch_size):\n"," train_score = model.evaluate(train[0], train[1], batch_size=batch_size, verbose=1)\n"," val_score = model.evaluate(val[0], val[1], batch_size=batch_size, verbose=1)\n"," test_score = model.evaluate(test[0], test[1], batch_size=batch_size, verbose=1)\n"," return [train_score,val_score,test_score]\n"],"execution_count":44,"outputs":[]},{"cell_type":"code","metadata":{"id":"McG2sywkgNW1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1643865641358,"user_tz":360,"elapsed":2053,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"9a1acdaa-9593-4880-d2dc-86b0cd0c3821"},"source":["cdr_ls = eval_model(CDR_model,\n"," [[train_x1,train_x2,train_x3,train_x4,train_x5,train_x6], y_train],\n"," [[val_x1,val_x2,val_x3,val_x4,val_x5,val_x6], y_val],\n"," [[test_x1,test_x2,test_x3,test_x4,test_x5,test_x6], y_test],\n"," 256)\n","cdr_df = pd.DataFrame(cdr_ls, columns =['loss','tp', 'fp' , 'tn','fn', 'accuracy','precision', 'recall','AUC','PRC'], index=['train set','val set','test set'],dtype = float) "],"execution_count":47,"outputs":[{"output_type":"stream","name":"stdout","text":["11/11 [==============================] - 1s 95ms/step - loss: 0.2086 - tp: 1803.0000 - fp: 92.0000 - tn: 767.0000 - fn: 125.0000 - accuracy: 0.9221 - precision: 0.9515 - recall: 0.9352 - auc: 0.9682 - prc: 0.9845\n","3/3 [==============================] - 0s 87ms/step - loss: 0.3849 - tp: 430.0000 - fp: 55.0000 - tn: 157.0000 - fn: 55.0000 - accuracy: 0.8422 - precision: 0.8866 - recall: 0.8866 - auc: 0.8963 - prc: 0.9464\n","4/4 [==============================] - 0s 82ms/step - loss: 0.3931 - tp: 533.0000 - fp: 75.0000 - tn: 210.0000 - fn: 54.0000 - accuracy: 0.8521 - precision: 0.8766 - recall: 0.9080 - auc: 0.8982 - prc: 0.9412\n"]}]},{"cell_type":"code","metadata":{"id":"Cn-n6_XJecYr","executionInfo":{"status":"ok","timestamp":1643866439424,"user_tz":360,"elapsed":154,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["\n","cdr_df.to_csv('result/evaluation/RBD-HA_CDR_model_evaluation.csv')"],"execution_count":54,"outputs":[]},{"cell_type":"markdown","source":["### Prediction on Momsen and HIV dataset"],"metadata":{"id":"uQ6MsPNmOiqV"}},{"cell_type":"code","metadata":{"id":"NLotiMS0DUby","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1643866133504,"user_tz":360,"elapsed":573,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"ab6b8020-929c-4cc3-854e-1b1c25e66572"},"source":["data_path = 'data/Momsen_Abs.xlsx'\n","Momsen_df = pd.read_excel(data_path)\n","\n","[Momsen_test_x1,Momsen_test_x2,Momsen_test_x3,Momsen_test_x4,Momsen_test_x5,Momsen_test_x6]=encode_six_CDR(Momsen_df)\n","\n","print(Momsen_test_x1.shape)\n"],"execution_count":50,"outputs":[{"output_type":"stream","name":"stdout","text":["(81, 30)\n"]}]},{"cell_type":"code","metadata":{"id":"Usc-bDsJEnne","executionInfo":{"status":"ok","timestamp":1643866229260,"user_tz":360,"elapsed":559,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}}},"source":["y_pred=CDR_model.predict([Momsen_test_x1,Momsen_test_x2,Momsen_test_x3,Momsen_test_x4,Momsen_test_x5,Momsen_test_x6])\n","# print(y_pred)\n","\n","Momsen_df['probability_Spike']=pd.Series(y_pred.flatten())\n","Momsen_df['Prediction']=np.where(Momsen_df['probability_Spike'] > 0.5, 'Spike', 'HA')\n","Momsen_df.to_excel('result/evaluation/Momsen_Abs_prediction_by_RBD-HA_model.xlsx')"],"execution_count":51,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"4tP0SEVq5alC"},"source":["## Test on HIV dataset"]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"g65-fzXC5eJ8","executionInfo":{"status":"ok","timestamp":1643866239089,"user_tz":360,"elapsed":3193,"user":{"displayName":"yiquan wang","photoUrl":"https://lh3.googleusercontent.com/a-/AOh14Gj4WDa94f5eE8mIi5YNmLxvCtSIU7GkkrKlyX6NUg=s64","userId":"16095811982935130614"}},"outputId":"5a6d5f23-eb2b-4940-d47e-1215c8021b88"},"source":["data_path = 'data/HIV_Abs_from_GB_v4_full_CDR.xlsx'\n","\n","raw_df = pd.read_excel(data_path)\n","raw_df=raw_df[raw_df[['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA']].notnull().all(1)]\n","cleaned_df = raw_df[['Name','CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA','VH Genbank ID','VL Genbank ID']].copy()\n","\n","#deduplication\n","HIV_df = cleaned_df.drop_duplicates(subset=['CDRH1_AA','CDRL1_AA','CDRH2_AA','CDRL2_AA','CDRH3_AA','CDRL3_AA'])\n","\n","[HIV_test_x1,HIV_test_x2,HIV_test_x3,HIV_test_x4,HIV_test_x5,HIV_test_x6]=encode_six_CDR(HIV_df)\n","\n","HIV_y_pred=CDR_model.predict([HIV_test_x1,HIV_test_x2,HIV_test_x3,HIV_test_x4,HIV_test_x5,HIV_test_x6])\n","# print(HIV_y_pred)\n","HIV_df=HIV_df.reset_index()\n","HIV_df['probability_Spike']=pd.Series(HIV_y_pred.flatten())\n","print(HIV_df['probability_Spike'])\n","HIV_df['Prediction']=np.where(HIV_df['probability_Spike'] > 0.5, 'Spike', 'HA')\n","\n","HIV_df.to_excel('./result/evaluation/HIV_dataset_prediction_by_RBD-HA_model.xlsx')"],"execution_count":52,"outputs":[{"output_type":"stream","name":"stdout","text":["0 0.883795\n","1 0.571575\n","2 0.081341\n","3 0.073715\n","4 0.155330\n"," ... \n","686 0.086630\n","687 0.788872\n","688 0.995728\n","689 0.994337\n","690 0.644402\n","Name: probability_Spike, Length: 691, dtype: float32\n"]}]}]} \ No newline at end of file diff --git a/graph/model_comparison.png b/graph/model_comparison.png index b727a51d7a1b3c7c82f150faced346f3058aae7f..ba7c25205c16d5eea1cc08ee9c31fdb0528f03a0 100644 GIT binary patch literal 44362 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�b}SRsvh07(ujH& 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 OkBgJXnlcCf_M$^RC(=hyZ{@G5~-U000DgiU+}b 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 delta 3253 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 e7-|53?O*Zy)+s