From d9b6c3ab5c29d85fd916a5799273e687798a8e5c Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 19 Sep 2022 11:50:22 +0200 Subject: [PATCH 01/51] push NBs --- PTB_XL_experiments.ipynb | 2553 +++++++++++++++++++++++ run_experiments_in_colab.ipynb | 3490 ++++++++++++++++++++++++++++++++ 2 files changed, 6043 insertions(+) create mode 100644 PTB_XL_experiments.ipynb create mode 100644 run_experiments_in_colab.ipynb diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb new file mode 100644 index 0000000..99f9dc4 --- /dev/null +++ b/PTB_XL_experiments.ipynb @@ -0,0 +1,2553 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", + "outputId": "6f8b3e9c-ccd1-4d94-9edd-03621f2f1d83" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: wget in /usr/local/lib/python3.7/dist-packages (3.2)\n" + ] + } + ], + "source": [ + "!pip install wget" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319", + "metadata": { + "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319" + }, + "outputs": [], + "source": [ + "import wget\n", + "import numpy as np\n", + "import os\n", + "import zipfile\n", + "import tensorflow as tf\n", + "from sklearn.utils.class_weight import compute_class_weight\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn.metrics import confusion_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "181ee1f6-3777-4aba-be5d-db810af7b5bc", + "metadata": { + "id": "181ee1f6-3777-4aba-be5d-db810af7b5bc" + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "T0cGBrFsdJFb", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 445 + }, + "id": "T0cGBrFsdJFb", + "outputId": "2d48ff89-f4b5-4cf4-e110-a9163ab59f9f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2022-08-28 09:36:19-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "Resolving physionet.org (physionet.org)... 18.18.42.54\n", + "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1842722380 (1.7G) [application/zip]\n", + "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip.2’\n", + "\n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 11.6MB/s in 2m 26s \n", + "\n", + "2022-08-28 09:38:46 (12.1 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip.2’ saved [1842722380/1842722380]\n", + "\n" + ] + }, + { + "output_type": "error", + "ename": "FileExistsError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileExistsError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./data/\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileExistsError\u001b[0m: [Errno 17] File exists: './data/'" + ] + } + ], + "source": [ + "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "\n", + "os.mkdir(\"./data/\")\n", + "\n", + "\n", + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", + "outputId": "b06ee695-48f9-4195-d336-83580dbeb637" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['records500',\n", + " 'LICENSE.txt',\n", + " 'ptbxl_database.csv',\n", + " 'RECORDS',\n", + " 'raw500.npy',\n", + " 'scp_statements.csv',\n", + " 'SHA256SUMS.txt',\n", + " 'records100',\n", + " 'example_physionet.py']" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "os.listdir(\"./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "1986c1d6-8c33-4e71-bd39-31c25cd57af6", + "metadata": { + "id": "1986c1d6-8c33-4e71-bd39-31c25cd57af6" + }, + "outputs": [], + "source": [ + "sampling_frequency=100 #500\n", + "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", + "task='superdiagnostic'\n", + "outputfolder='./'" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "9565781f-afb0-4649-b3a3-8e39dd598ae2", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9565781f-afb0-4649-b3a3-8e39dd598ae2", + "outputId": "835fcbf1-bab9-4997-fb54-b9fe10baaed1" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: wfdb in /usr/local/lib/python3.7/dist-packages (4.0.0)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", + "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n" + ] + } + ], + "source": [ + "!pip install wfdb\n", + "import wfdb" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "c0514023-5537-4297-8865-b28ab6bf8581", + "metadata": { + "id": "c0514023-5537-4297-8865-b28ab6bf8581" + }, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import re\n", + "import glob\n", + "import pickle\n", + "import copy\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from tqdm import tqdm\n", + "\n", + "import ast\n", + "from sklearn.metrics import fbeta_score, roc_auc_score, roc_curve, roc_curve, auc\n", + "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", + "from matplotlib.axes._axes import _log as matplotlib_axes_logger\n", + "import warnings\n", + "\n", + "# EVALUATION STUFF\n", + "def generate_results(idxs, y_true, y_pred, thresholds):\n", + " return evaluate_experiment(y_true[idxs], y_pred[idxs], thresholds)\n", + "\n", + "def evaluate_experiment(y_true, y_pred, thresholds=None):\n", + " results = {}\n", + "\n", + " if not thresholds is None:\n", + " # binary predictions\n", + " y_pred_binary = apply_thresholds(y_pred, thresholds)\n", + " # PhysioNet/CinC Challenges metrics\n", + " challenge_scores = challenge_metrics(y_true, y_pred_binary, beta1=2, beta2=2)\n", + " results['F_beta_macro'] = challenge_scores['F_beta_macro']\n", + " results['G_beta_macro'] = challenge_scores['G_beta_macro']\n", + "\n", + " # label based metric\n", + " results['macro_auc'] = roc_auc_score(y_true, y_pred, average='macro')\n", + " \n", + " df_result = pd.DataFrame(results, index=[0])\n", + " return df_result\n", + "\n", + "def challenge_metrics(y_true, y_pred, beta1=2, beta2=2, class_weights=None, single=False):\n", + " f_beta = 0\n", + " g_beta = 0\n", + " if single: # if evaluating single class in case of threshold-optimization\n", + " sample_weights = np.ones(y_true.sum(axis=1).shape)\n", + " else:\n", + " sample_weights = y_true.sum(axis=1)\n", + " for classi in range(y_true.shape[1]):\n", + " y_truei, y_predi = y_true[:,classi], y_pred[:,classi]\n", + " TP, FP, TN, FN = 0.,0.,0.,0.\n", + " for i in range(len(y_predi)):\n", + " sample_weight = sample_weights[i]\n", + " if y_truei[i]==y_predi[i]==1: \n", + " TP += 1./sample_weight\n", + " if ((y_predi[i]==1) and (y_truei[i]!=y_predi[i])): \n", + " FP += 1./sample_weight\n", + " if y_truei[i]==y_predi[i]==0: \n", + " TN += 1./sample_weight\n", + " if ((y_predi[i]==0) and (y_truei[i]!=y_predi[i])): \n", + " FN += 1./sample_weight \n", + " f_beta_i = ((1+beta1**2)*TP)/((1+beta1**2)*TP + FP + (beta1**2)*FN)\n", + " g_beta_i = (TP)/(TP+FP+beta2*FN)\n", + "\n", + " f_beta += f_beta_i\n", + " g_beta += g_beta_i\n", + "\n", + " return {'F_beta_macro':f_beta/y_true.shape[1], 'G_beta_macro':g_beta/y_true.shape[1]}\n", + "\n", + "def get_appropriate_bootstrap_samples(y_true, n_bootstraping_samples):\n", + " samples=[]\n", + " while True:\n", + " ridxs = np.random.randint(0, len(y_true), len(y_true))\n", + " if y_true[ridxs].sum(axis=0).min() != 0:\n", + " samples.append(ridxs)\n", + " if len(samples) == n_bootstraping_samples:\n", + " break\n", + " return samples\n", + "\n", + "def find_optimal_cutoff_threshold(target, predicted):\n", + " \"\"\" \n", + " Find the optimal probability cutoff point for a classification model related to event rate\n", + " \"\"\"\n", + " fpr, tpr, threshold = roc_curve(target, predicted)\n", + " optimal_idx = np.argmax(tpr - fpr)\n", + " optimal_threshold = threshold[optimal_idx]\n", + " return optimal_threshold\n", + "\n", + "def find_optimal_cutoff_thresholds(y_true, y_pred):\n", + "\treturn [find_optimal_cutoff_threshold(y_true[:,i], y_pred[:,i]) for i in range(y_true.shape[1])]\n", + "\n", + "def find_optimal_cutoff_threshold_for_Gbeta(target, predicted, n_thresholds=100):\n", + " thresholds = np.linspace(0.00,1,n_thresholds)\n", + " scores = [challenge_metrics(target, predicted>t, single=True)['G_beta_macro'] for t in thresholds]\n", + " optimal_idx = np.argmax(scores)\n", + " return thresholds[optimal_idx]\n", + "\n", + "def find_optimal_cutoff_thresholds_for_Gbeta(y_true, y_pred):\n", + " print(\"optimize thresholds with respect to G_beta\")\n", + " return [find_optimal_cutoff_threshold_for_Gbeta(y_true[:,k][:,np.newaxis], y_pred[:,k][:,np.newaxis]) for k in tqdm(range(y_true.shape[1]))]\n", + "\n", + "def apply_thresholds(preds, thresholds):\n", + " \"\"\"\n", + " apply class-wise thresholds to prediction score in order to get binary format.\n", + " BUT: if no score is above threshold, pick maximum. This is needed due to metric issues.\n", + " \"\"\"\n", + " tmp = []\n", + " for p in preds:\n", + " tmp_p = (p > thresholds).astype(int)\n", + " if np.sum(tmp_p) == 0:\n", + " tmp_p[np.argmax(p)] = 1\n", + " tmp.append(tmp_p)\n", + " tmp = np.array(tmp)\n", + " return tmp\n", + "\n", + "# DATA PROCESSING STUFF\n", + "\n", + "def load_dataset(path, sampling_rate, release=False):\n", + " if path.split('/')[-2] == 'ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1':\n", + " # load and convert annotation data\n", + " Y = pd.read_csv(path+'ptbxl_database.csv', index_col='ecg_id')\n", + " Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x))\n", + "\n", + " # Load raw signal data\n", + " X = load_raw_data_ptbxl(Y, sampling_rate, path)\n", + "\n", + " elif path.split('/')[-2] == 'ICBEB':\n", + " # load and convert annotation data\n", + " Y = pd.read_csv(path+'icbeb_database.csv', index_col='ecg_id')\n", + " Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x))\n", + "\n", + " # Load raw signal data\n", + " X = load_raw_data_icbeb(Y, sampling_rate, path)\n", + "\n", + " return X, Y\n", + "\n", + "\n", + "def load_raw_data_icbeb(df, sampling_rate, path):\n", + "\n", + " if sampling_rate == 100:\n", + " if os.path.exists(path + 'raw100.npy'):\n", + " data = np.load(path+'raw100.npy', allow_pickle=True)\n", + " else:\n", + " data = [wfdb.rdsamp(path + 'records100/'+str(f)) for f in tqdm(df.index)]\n", + " data = np.array([signal for signal, meta in data])\n", + " pickle.dump(data, open(path+'raw100.npy', 'wb'), protocol=4)\n", + " elif sampling_rate == 500:\n", + " if os.path.exists(path + 'raw500.npy'):\n", + " data = np.load(path+'raw500.npy', allow_pickle=True)\n", + " else:\n", + " data = [wfdb.rdsamp(path + 'records500/'+str(f)) for f in tqdm(df.index)]\n", + " data = np.array([signal for signal, meta in data])\n", + " pickle.dump(data, open(path+'raw500.npy', 'wb'), protocol=4)\n", + " return data\n", + "\n", + "def load_raw_data_ptbxl(df, sampling_rate, path):\n", + " if sampling_rate == 100:\n", + " if os.path.exists(path + 'raw100.npy'):\n", + " data = np.load(path+'raw100.npy', allow_pickle=True)\n", + " else:\n", + " data = [wfdb.rdsamp(path+f) for f in tqdm(df.filename_lr)]\n", + " data = np.array([signal for signal, meta in data])\n", + " pickle.dump(data, open(\"./\"+'raw100.npy', 'wb'), protocol=4)\n", + " elif sampling_rate == 500:\n", + " if os.path.exists(path + 'raw500.npy'):\n", + " data = np.load(path+'raw500.npy', allow_pickle=True)\n", + " else:\n", + " data = [wfdb.rdsamp(path+f) for f in tqdm(df.filename_hr)]\n", + " data = np.array([signal for signal, meta in data])\n", + " pickle.dump(data, open(path+'raw500.npy', 'wb'), protocol=4)\n", + " return data\n", + "\n", + "def compute_label_aggregations(df, folder, ctype):\n", + "\n", + " df['scp_codes_len'] = df.scp_codes.apply(lambda x: len(x))\n", + "\n", + " aggregation_df = pd.read_csv(folder+'scp_statements.csv', index_col=0)\n", + "\n", + " if ctype in ['diagnostic', 'subdiagnostic', 'superdiagnostic']:\n", + "\n", + " def aggregate_all_diagnostic(y_dic):\n", + " tmp = []\n", + " for key in y_dic.keys():\n", + " if key in diag_agg_df.index:\n", + " tmp.append(key)\n", + " return list(set(tmp))\n", + "\n", + " def aggregate_subdiagnostic(y_dic):\n", + " tmp = []\n", + " for key in y_dic.keys():\n", + " if key in diag_agg_df.index:\n", + " c = diag_agg_df.loc[key].diagnostic_subclass\n", + " if str(c) != 'nan':\n", + " tmp.append(c)\n", + " return list(set(tmp))\n", + "\n", + " def aggregate_diagnostic(y_dic):\n", + " tmp = []\n", + " for key in y_dic.keys():\n", + " if key in diag_agg_df.index:\n", + " c = diag_agg_df.loc[key].diagnostic_class\n", + " if str(c) != 'nan':\n", + " tmp.append(c)\n", + " return list(set(tmp))\n", + "\n", + " diag_agg_df = aggregation_df[aggregation_df.diagnostic == 1.0]\n", + " if ctype == 'diagnostic':\n", + " df['diagnostic'] = df.scp_codes.apply(aggregate_all_diagnostic)\n", + " df['diagnostic_len'] = df.diagnostic.apply(lambda x: len(x))\n", + " elif ctype == 'subdiagnostic':\n", + " df['subdiagnostic'] = df.scp_codes.apply(aggregate_subdiagnostic)\n", + " df['subdiagnostic_len'] = df.subdiagnostic.apply(lambda x: len(x))\n", + " elif ctype == 'superdiagnostic':\n", + " df['superdiagnostic'] = df.scp_codes.apply(aggregate_diagnostic)\n", + " df['superdiagnostic_len'] = df.superdiagnostic.apply(lambda x: len(x))\n", + " elif ctype == 'form':\n", + " form_agg_df = aggregation_df[aggregation_df.form == 1.0]\n", + "\n", + " def aggregate_form(y_dic):\n", + " tmp = []\n", + " for key in y_dic.keys():\n", + " if key in form_agg_df.index:\n", + " c = key\n", + " if str(c) != 'nan':\n", + " tmp.append(c)\n", + " return list(set(tmp))\n", + "\n", + " df['form'] = df.scp_codes.apply(aggregate_form)\n", + " df['form_len'] = df.form.apply(lambda x: len(x))\n", + " elif ctype == 'rhythm':\n", + " rhythm_agg_df = aggregation_df[aggregation_df.rhythm == 1.0]\n", + "\n", + " def aggregate_rhythm(y_dic):\n", + " tmp = []\n", + " for key in y_dic.keys():\n", + " if key in rhythm_agg_df.index:\n", + " c = key\n", + " if str(c) != 'nan':\n", + " tmp.append(c)\n", + " return list(set(tmp))\n", + "\n", + " df['rhythm'] = df.scp_codes.apply(aggregate_rhythm)\n", + " df['rhythm_len'] = df.rhythm.apply(lambda x: len(x))\n", + " elif ctype == 'all':\n", + " df['all_scp'] = df.scp_codes.apply(lambda x: list(set(x.keys())))\n", + "\n", + " return df\n", + "\n", + "def select_data(XX,YY, ctype, min_samples, outputfolder):\n", + " # convert multilabel to multi-hot\n", + " mlb = MultiLabelBinarizer()\n", + "\n", + " if ctype == 'diagnostic':\n", + " X = XX[YY.diagnostic_len > 0]\n", + " Y = YY[YY.diagnostic_len > 0]\n", + " mlb.fit(Y.diagnostic.values)\n", + " y = mlb.transform(Y.diagnostic.values)\n", + " elif ctype == 'subdiagnostic':\n", + " counts = pd.Series(np.concatenate(YY.subdiagnostic.values)).value_counts()\n", + " counts = counts[counts > min_samples]\n", + " YY.subdiagnostic = YY.subdiagnostic.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", + " YY['subdiagnostic_len'] = YY.subdiagnostic.apply(lambda x: len(x))\n", + " X = XX[YY.subdiagnostic_len > 0]\n", + " Y = YY[YY.subdiagnostic_len > 0]\n", + " mlb.fit(Y.subdiagnostic.values)\n", + " y = mlb.transform(Y.subdiagnostic.values)\n", + " elif ctype == 'superdiagnostic':\n", + " counts = pd.Series(np.concatenate(YY.superdiagnostic.values)).value_counts()\n", + " counts = counts[counts > min_samples]\n", + " YY.superdiagnostic = YY.superdiagnostic.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", + " YY['superdiagnostic_len'] = YY.superdiagnostic.apply(lambda x: len(x))\n", + " X = XX[YY.superdiagnostic_len > 0]\n", + " Y = YY[YY.superdiagnostic_len > 0]\n", + " mlb.fit(Y.superdiagnostic.values)\n", + " y = mlb.transform(Y.superdiagnostic.values)\n", + " elif ctype == 'form':\n", + " # filter\n", + " counts = pd.Series(np.concatenate(YY.form.values)).value_counts()\n", + " counts = counts[counts > min_samples]\n", + " YY.form = YY.form.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", + " YY['form_len'] = YY.form.apply(lambda x: len(x))\n", + " # select\n", + " X = XX[YY.form_len > 0]\n", + " Y = YY[YY.form_len > 0]\n", + " mlb.fit(Y.form.values)\n", + " y = mlb.transform(Y.form.values)\n", + " elif ctype == 'rhythm':\n", + " # filter \n", + " counts = pd.Series(np.concatenate(YY.rhythm.values)).value_counts()\n", + " counts = counts[counts > min_samples]\n", + " YY.rhythm = YY.rhythm.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", + " YY['rhythm_len'] = YY.rhythm.apply(lambda x: len(x))\n", + " # select\n", + " X = XX[YY.rhythm_len > 0]\n", + " Y = YY[YY.rhythm_len > 0]\n", + " mlb.fit(Y.rhythm.values)\n", + " y = mlb.transform(Y.rhythm.values)\n", + " elif ctype == 'all':\n", + " # filter \n", + " counts = pd.Series(np.concatenate(YY.all_scp.values)).value_counts()\n", + " counts = counts[counts > min_samples]\n", + " YY.all_scp = YY.all_scp.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", + " YY['all_scp_len'] = YY.all_scp.apply(lambda x: len(x))\n", + " # select\n", + " X = XX[YY.all_scp_len > 0]\n", + " Y = YY[YY.all_scp_len > 0]\n", + " mlb.fit(Y.all_scp.values)\n", + " y = mlb.transform(Y.all_scp.values)\n", + " else:\n", + " pass\n", + "\n", + " # save LabelBinarizer\n", + " with open(outputfolder+'mlb.pkl', 'wb') as tokenizer:\n", + " pickle.dump(mlb, tokenizer)\n", + "\n", + " return X, Y, y, mlb\n", + "\n", + "def preprocess_signals(X_train, X_validation, X_test, outputfolder):\n", + " # Standardize data such that mean 0 and variance 1\n", + " ss = StandardScaler()\n", + " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", + " \n", + " # Save Standardizer data\n", + " with open(outputfolder+'standard_scaler.pkl', 'wb') as ss_file:\n", + " pickle.dump(ss, ss_file)\n", + "\n", + " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss), apply_standardizer(X_test, ss)\n", + "\n", + "def apply_standardizer(X, ss):\n", + " X_tmp = []\n", + " for x in X:\n", + " x_shape = x.shape\n", + " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", + " X_tmp = np.array(X_tmp)\n", + " return X_tmp\n", + "\n", + "\n", + "# DOCUMENTATION STUFF\n", + "\n", + "def generate_ptbxl_summary_table(selection=None, folder='../output/'):\n", + "\n", + " exps = ['exp0', 'exp1', 'exp1.1', 'exp1.1.1', 'exp2', 'exp3']\n", + " metric1 = 'macro_auc'\n", + "\n", + " # get models\n", + " models = {}\n", + " for i, exp in enumerate(exps):\n", + " if selection is None:\n", + " exp_models = [m.split('/')[-1] for m in glob.glob(folder+str(exp)+'/models/*')]\n", + " else:\n", + " exp_models = selection\n", + " if i == 0:\n", + " models = set(exp_models)\n", + " else:\n", + " models = models.union(set(exp_models))\n", + "\n", + " results_dic = {'Method':[], \n", + " 'exp0_AUC':[], \n", + " 'exp1_AUC':[], \n", + " 'exp1.1_AUC':[], \n", + " 'exp1.1.1_AUC':[], \n", + " 'exp2_AUC':[],\n", + " 'exp3_AUC':[]\n", + " }\n", + "\n", + " for m in models:\n", + " results_dic['Method'].append(m)\n", + " \n", + " for e in exps:\n", + " \n", + " try:\n", + " me_res = pd.read_csv(folder+str(e)+'/models/'+str(m)+'/results/te_results.csv', index_col=0)\n", + " \n", + " mean1 = me_res.loc['point'][metric1]\n", + " unc1 = max(me_res.loc['upper'][metric1]-me_res.loc['point'][metric1], me_res.loc['point'][metric1]-me_res.loc['lower'][metric1])\n", + "\n", + " results_dic[e+'_AUC'].append(\"%.3f(%.2d)\" %(np.round(mean1,3), int(unc1*1000)))\n", + "\n", + " except FileNotFoundError:\n", + " results_dic[e+'_AUC'].append(\"--\")\n", + " \n", + " \n", + " df = pd.DataFrame(results_dic)\n", + " df_index = df[df.Method.isin(['naive', 'ensemble'])]\n", + " df_rest = df[~df.Method.isin(['naive', 'ensemble'])]\n", + " df = pd.concat([df_rest, df_index])\n", + " df.to_csv(folder+'results_ptbxl.csv')\n", + "\n", + " titles = [\n", + " '### 1. PTB-XL: all statements',\n", + " '### 2. PTB-XL: diagnostic statements',\n", + " '### 3. PTB-XL: Diagnostic subclasses',\n", + " '### 4. PTB-XL: Diagnostic superclasses',\n", + " '### 5. PTB-XL: Form statements',\n", + " '### 6. PTB-XL: Rhythm statements' \n", + " ]\n", + "\n", + " # helper output function for markdown tables\n", + " our_work = 'https://arxiv.org/abs/2004.13701'\n", + " our_repo = 'https://github.com/helme/ecg_ptbxl_benchmarking/'\n", + " md_source = ''\n", + " for i, e in enumerate(exps):\n", + " md_source += '\\n '+titles[i]+' \\n \\n'\n", + " md_source += '| Model | AUC ↓ | paper/source | code | \\n'\n", + " md_source += '|---:|:---|:---|:---| \\n'\n", + " for row in df_rest[['Method', e+'_AUC']].sort_values(e+'_AUC', ascending=False).values:\n", + " md_source += '| ' + row[0].replace('fastai_', '') + ' | ' + row[1] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \\n'\n", + " print(md_source)\n", + "\n", + "def ICBEBE_table(selection=None, folder='../output/'):\n", + " cols = ['macro_auc', 'F_beta_macro', 'G_beta_macro']\n", + "\n", + " if selection is None:\n", + " models = [m.split('/')[-1].split('_pretrained')[0] for m in glob.glob(folder+'exp_ICBEB/models/*')]\n", + " else:\n", + " models = [] \n", + " for s in selection:\n", + " #if s != 'Wavelet+NN':\n", + " models.append(s)\n", + "\n", + " data = []\n", + " for model in models:\n", + " me_res = pd.read_csv(folder+'exp_ICBEB/models/'+model+'/results/te_results.csv', index_col=0)\n", + " mcol=[]\n", + " for col in cols:\n", + " mean = me_res.ix['point'][col]\n", + " unc = max(me_res.ix['upper'][col]-me_res.ix['point'][col], me_res.ix['point'][col]-me_res.ix['lower'][col])\n", + " mcol.append(\"%.3f(%.2d)\" %(np.round(mean,3), int(unc*1000)))\n", + " data.append(mcol)\n", + " data = np.array(data)\n", + "\n", + " df = pd.DataFrame(data, columns=cols, index=models)\n", + " df.to_csv(folder+'results_icbeb.csv')\n", + "\n", + " df_rest = df[~df.index.isin(['naive', 'ensemble'])]\n", + " df_rest = df_rest.sort_values('macro_auc', ascending=False)\n", + " our_work = 'https://arxiv.org/abs/2004.13701'\n", + " our_repo = 'https://github.com/helme/ecg_ptbxl_benchmarking/'\n", + "\n", + " md_source = '| Model | AUC ↓ | F_beta=2 | G_beta=2 | paper/source | code | \\n'\n", + " md_source += '|---:|:---|:---|:---|:---|:---| \\n'\n", + " for i, row in enumerate(df_rest[cols].values):\n", + " md_source += '| ' + df_rest.index[i].replace('fastai_', '') + ' | ' + row[0] + ' | ' + row[1] + ' | ' + row[2] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \\n'\n", + " print(md_source)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c4167b83-41cb-4a0a-aa4e-7a8a8790c021", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c4167b83-41cb-4a0a-aa4e-7a8a8790c021", + "outputId": "aa4c4607-2f1e-47ce-9bad-a6d7c4867162" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 21837/21837 [01:07<00:00, 323.92it/s]\n" + ] + } + ], + "source": [ + "# Load PTB-XL data\n", + "data, raw_labels = load_dataset(datafolder, sampling_frequency)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "2507b016-ab63-4263-9e34-6f52346dd468", + "metadata": { + "id": "2507b016-ab63-4263-9e34-6f52346dd468" + }, + "outputs": [], + "source": [ + "labels = compute_label_aggregations(raw_labels, datafolder, task)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "84e05e6c-b826-4638-b950-d78889afa4e0", + "metadata": { + "id": "84e05e6c-b826-4638-b950-d78889afa4e0" + }, + "outputs": [], + "source": [ + "# Select relevant data and convert to one-hot\n", + "data, labels, Y, mlb = select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "95bc3349-5f35-4848-b1ad-ba57cce241c2", + "metadata": { + "id": "95bc3349-5f35-4848-b1ad-ba57cce241c2" + }, + "outputs": [], + "source": [ + "labels.reset_index(inplace=True)" + ] + }, + { + "cell_type": "markdown", + "id": "00e60322-f45b-4815-9d94-7addb100531d", + "metadata": { + "id": "00e60322-f45b-4815-9d94-7addb100531d" + }, + "source": [ + "Superclass:\n", + "* col 1 (indx 0) = CD\n", + "* col 2 = HYP\n", + "* col 3 = MI\n", + "* col 4 = NORM\n", + "* col 5 = STTC" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "58e05225-a5c1-48d0-9bfa-d412d5cbb9e9", + "metadata": { + "id": "58e05225-a5c1-48d0-9bfa-d412d5cbb9e9" + }, + "outputs": [], + "source": [ + "mi_indx = []\n", + "for i,j in enumerate(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==1)]):\n", + " mi_indx.append(i)\n", + "mi_indx = np.asarray(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==1)].index[mi_indx]) #the 3th col is the MI superclass\n", + "\n", + "mi_data = data[mi_indx]\n", + "Y_mi = Y[mi_indx]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "14463a7d-5f9a-41b7-8dfe-bc120d0789da", + "metadata": { + "id": "14463a7d-5f9a-41b7-8dfe-bc120d0789da" + }, + "outputs": [], + "source": [ + "norm_indx = []\n", + "for i,j in enumerate(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==0)]):\n", + " norm_indx.append(i)\n", + "norm_indx = np.asarray(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==0)].index[norm_indx]) #the 4th col is the Norm superclass\n", + "\n", + "norm_data = data[norm_indx]\n", + "Y_norm = Y[norm_indx]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f6f0c951-3995-419e-aa4a-d481dfeed7a3", + "metadata": { + "id": "f6f0c951-3995-419e-aa4a-d481dfeed7a3", + "tags": [] + }, + "outputs": [], + "source": [ + "all_diag = []\n", + "for i,j in enumerate(labels.scp_codes[mi_indx]):\n", + " for k in j:\n", + " all_diag.append(k)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b36fa309-6407-48b4-8dec-8377f3a59d84", + "metadata": { + "id": "b36fa309-6407-48b4-8dec-8377f3a59d84" + }, + "outputs": [], + "source": [ + "df = pd.read_csv(datafolder + \"scp_statements.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "6d733dc3-cf06-4429-8cc1-ade1866be56b", + "metadata": { + "id": "6d733dc3-cf06-4429-8cc1-ade1866be56b" + }, + "outputs": [], + "source": [ + "full_diag_name = []\n", + "for i in np.unique(all_diag,return_counts=True)[0]:\n", + " diag_idx = np.where(df.iloc[:,0]==i)[0]\n", + " full_diag_name.append(df.iloc[diag_idx,1].ravel()[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "8f6b6f0c-2246-4b01-8a9c-91ef2f739028", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 568 + }, + "id": "8f6b6f0c-2246-4b01-8a9c-91ef2f739028", + "outputId": "35f3e2a3-93c4-4bb0-cfd3-6768d1a1d599" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "pd.DataFrame({\"Diagnose\":full_diag_name, \"Number of patients with diagnose\":np.unique(all_diag,return_counts=True)[1]}).sort_values(by=[\"Number of patients with diagnose\"],ascending=False).iloc[:20].plot.bar(x='Diagnose', y='Number of patients with diagnose')\n", + "plt.savefig(\"MI_subdiagnoses.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "43b4d221-2d87-44b9-9cb5-6b177a064dbd", + "metadata": { + "id": "43b4d221-2d87-44b9-9cb5-6b177a064dbd" + }, + "outputs": [], + "source": [ + "pd.DataFrame({\"Diagnose\":full_diag_name, \"Number of patients with diagnose\":np.unique(all_diag,return_counts=True)[1]}).to_csv(\"diagnoses-MI-patients.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "9ac0d7b0-ab44-4306-ae1d-e6d7c9671c48", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "9ac0d7b0-ab44-4306-ae1d-e6d7c9671c48", + "outputId": "7d37e207-8c9d-449b-be71-1443d1aa0d9e" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 20 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "plt.figure(figsize=(20,20))\n", + "plt.bar(np.unique(all_diag,return_counts=True)[0],np.unique(all_diag,return_counts=True)[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "3883b0d8-0d1f-4df7-aab0-3b177f728f1b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3883b0d8-0d1f-4df7-aab0-3b177f728f1b", + "outputId": "828c8283-97a7-4612-c1a2-79b34a42810b" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(15944, 1000, 12)" + ] + }, + "metadata": {}, + "execution_count": 71 + } + ], + "source": [ + "norm_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "42dde4c5-103e-4d1a-a4a5-6f8a288c025d", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "42dde4c5-103e-4d1a-a4a5-6f8a288c025d", + "outputId": "bf112d20-57c3-4860-e2a6-a0c755c6ce7b" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(5486, 1000, 12)" + ] + }, + "metadata": {}, + "execution_count": 72 + } + ], + "source": [ + "mi_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "4ccb2263-9522-4507-bf30-a53cb62a629c", + "metadata": { + "id": "4ccb2263-9522-4507-bf30-a53cb62a629c" + }, + "outputs": [], + "source": [ + "Y_norm = np.zeros((norm_data.shape[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "c81e5f46-3c29-4869-97b6-8431c457f81c", + "metadata": { + "id": "c81e5f46-3c29-4869-97b6-8431c457f81c" + }, + "outputs": [], + "source": [ + "Y_mi = np.ones((mi_data.shape[0]))" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "3fcf47ba-3c66-4068-bb19-076f5edb9fff", + "metadata": { + "id": "3fcf47ba-3c66-4068-bb19-076f5edb9fff" + }, + "outputs": [], + "source": [ + "X = np.vstack((norm_data,mi_data))" + ] + }, + { + "cell_type": "code", + "source": [ + "#X = np.expand_dims(X[:,:,1],2)" + ], + "metadata": { + "id": "uKN4Lx0y4PYc" + }, + "id": "uKN4Lx0y4PYc", + "execution_count": 26, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#v = X[:,:,0] # foo[:, -1] for the last column\n", + "#X[:,:, 0] = (v - v.min()) / (v.max() - v.min())" + ], + "metadata": { + "id": "COAefnPG4XM9" + }, + "id": "COAefnPG4XM9", + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "f51c4ea1-5024-4e12-bacc-ae66213fa316", + "metadata": { + "id": "f51c4ea1-5024-4e12-bacc-ae66213fa316" + }, + "outputs": [], + "source": [ + "y = np.hstack((Y_norm,Y_mi))" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "id": "c9dd1cf6-eb6b-4783-ba2e-6731c48637d6", + "metadata": { + "id": "c9dd1cf6-eb6b-4783-ba2e-6731c48637d6" + }, + "outputs": [], + "source": [ + "all_idx = np.hstack((norm_indx,mi_indx))" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "id": "f13e051c-4edb-4dc1-a285-87a79473c045", + "metadata": { + "id": "f13e051c-4edb-4dc1-a285-87a79473c045" + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test, idx_train, idx_test = train_test_split(X, y, all_idx, test_size=0.33, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "7c37f38e-ae7b-4d5c-83f9-46dfa1cf2083", + "metadata": { + "id": "7c37f38e-ae7b-4d5c-83f9-46dfa1cf2083" + }, + "outputs": [], + "source": [ + "weight_mi = np.unique(y_train, return_counts=True)[1][0]/np.unique(y_train, return_counts=True)[1][1]" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "id": "4102c5e9-6d74-4f5a-901f-51624bdb3219", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4102c5e9-6d74-4f5a-901f-51624bdb3219", + "outputId": "5e9a88f1-5b38-41b0-8a29-410069f02940" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{0: 1.0, 1: 2.88474025974026}" + ] + }, + "metadata": {}, + "execution_count": 80 + } + ], + "source": [ + "class_w_dict = {0: 1.0, 1:weight_mi}\n", + "class_w_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "b5faf7a9-8036-41b0-9414-8c48b617e402", + "metadata": { + "id": "b5faf7a9-8036-41b0-9414-8c48b617e402" + }, + "outputs": [], + "source": [ + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=3, nb_filters=3):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False, name=\"conv1\")(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", + " strides=stride, padding='same', activation=activation, kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3), use_bias=False, name=\"conv\" + str(i+2))(\n", + " input_inception))\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False, name = \"conv5\", kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3))(max_pool_1)\n", + "\n", + " conv_list.append(conv_6)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='same', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + "\n", + " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_model(input_shape, nb_classes, depth=1, use_residual=True):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer)\n", + "\n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\"\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\"\n", + " )\n", + " ])\n", + " \n", + " return model" + ] + }, + { + "cell_type": "code", + "source": [ + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='valid', activation=activation, use_bias=False \n", + " #,name=\"conv1\"\n", + " )(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " #crop_size = kernel_size_s\n", + " #crop_size = np.asarray(crop_size)\n", + " #crop_size[0] = 0\n", + " #crop_size = sorted(crop_size)\n", + " crop_size = [0,10,15]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " incept_conv = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i]+1,\n", + " strides=stride, padding='valid', activation=activation, kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3), use_bias=False#, name=\"conv\" + str(i+2)\n", + " )(input_inception)\n", + " #incept_padd = tf.keras.layers.ZeroPadding1D(padding=int(kernel_size // (2 ** i)/2))(incept_conv)\n", + " incept_crop = tf.keras.layers.Cropping1D(cropping=(crop_size[i], crop_size[i]))(incept_conv)\n", + " conv_list.append(incept_crop)\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='valid')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='valid', activation=activation, use_bias=False, #name = \"conv5\", \n", + " kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3))(max_pool_1)\n", + " conv_crop = tf.keras.layers.Cropping1D(cropping=(19, 19))(conv_6)\n", + " conv_list.append(conv_crop)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='valid', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + " diff = shortcut_y.shape[1]-out_tensor.shape[1]\n", + " crop = tf.keras.layers.Cropping1D(cropping=(diff//2, diff//2))(shortcut_y)\n", + " x = tf.keras.layers.Add()([crop, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_model(input_shape, nb_classes, depth=6, use_residual=True):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer)\n", + "\n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\"\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\"\n", + " )\n", + " ])\n", + " \n", + " return model" + ], + "metadata": { + "id": "sLVXZL7SgkOJ" + }, + "id": "sLVXZL7SgkOJ", + "execution_count": 89, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "batchsize = 32\n", + "model = build_model((1000,1),1)" + ], + "metadata": { + "id": "QEO-kyIs3A2z" + }, + "id": "QEO-kyIs3A2z", + "execution_count": 85, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "2a8d7913-4ba1-483d-b5d5-f3cb7b16a433", + "metadata": { + "id": "2a8d7913-4ba1-483d-b5d5-f3cb7b16a433" + }, + "outputs": [], + "source": [ + "def scheduler(epoch, lr):\n", + " if epoch == 5:\n", + " return lr*0.1\n", + " elif epoch == 10:\n", + " return lr*0.1\n", + " elif epoch == 15:\n", + " return lr*0.1\n", + " else:\n", + " return lr" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "8782a0a1-63d1-4bae-9bfb-b06b3439ed60", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8782a0a1-63d1-4bae-9bfb-b06b3439ed60", + "outputId": "83ac48aa-1973-48ee-bdf7-86891af79f06" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Num GPUs Available: 1\n" + ] + } + ], + "source": [ + "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "7de5a8ea-fc2b-4d25-822d-7cd1d3b579e0", + "metadata": { + "id": "7de5a8ea-fc2b-4d25-822d-7cd1d3b579e0" + }, + "outputs": [], + "source": [ + "class PlotLosses(tf.keras.callbacks.Callback):\n", + " def on_train_begin(self, logs={}):\n", + " self.i = 0\n", + " self.x = []\n", + " self.losses = []\n", + " self.val_losses = []\n", + "\n", + " self.fig = plt.figure()\n", + "\n", + " self.logs = []\n", + "\n", + " def on_epoch_end(self, epoch, logs={}):\n", + "\n", + " self.logs.append(logs)\n", + " self.x.append(self.i)\n", + " self.losses.append(logs.get('loss'))\n", + " self.val_losses.append(logs.get('val_loss'))\n", + " self.i += 1\n", + "\n", + " clear_output(wait=True)\n", + " plt.plot(self.x, self.losses, label=\"loss\")\n", + " plt.plot(self.x, self.val_losses, label=\"val_loss\")\n", + " plt.legend()\n", + " plt.show();\n", + " #def on_train_end(self, epoch, logs={}):\n", + " #plt.plot(self.x, self.losses, label=\"loss\")\n", + " #plt.plot(self.x, self.val_losses, label=\"val_loss\")\n", + " #plt.legend()\n", + " #plt.show();\n", + "\n", + "plot_losses = PlotLosses()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "1f76d05e-fc5e-450f-b56e-ca2634d47a4a", + "metadata": { + "id": "1f76d05e-fc5e-450f-b56e-ca2634d47a4a" + }, + "outputs": [], + "source": [ + "from IPython.display import clear_output" + ] + }, + { + "cell_type": "code", + "source": [ + "#tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)" + ], + "metadata": { + "id": "RBztHZVdz0nH" + }, + "id": "RBztHZVdz0nH", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "ecg_plot = X_test[0,25:125,0]" + ], + "metadata": { + "id": "IjwhZio6Azxl" + }, + "id": "IjwhZio6Azxl", + "execution_count": 39, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "173a2565-c5d4-41e8-a422-cedd293f2c1b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "173a2565-c5d4-41e8-a422-cedd293f2c1b", + "outputId": "b16dc02a-ec81-4d33-b29f-7bec44e1be8c" + }, + "outputs": [ + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"pink\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"filter 3\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m history = model.fit(x=X_train,y=y_train, epochs=5, batch_size=batchsize,\n\u001b[1;32m 18\u001b[0m \u001b[0mvalidation_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msteps_per_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mbatchsize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m 270\u001b[0m \"\"\"\n\u001b[1;32m 271\u001b[0m \u001b[0;32mglobal\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 273\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m 41\u001b[0m display(\n\u001b[1;32m 42\u001b[0m \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 44\u001b[0m )\n\u001b[1;32m 45\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 314\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 181\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 225\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 340\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 342\u001b[0m \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m 242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 245\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 246\u001b[0m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 2124\u001b[0m \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2125\u001b[0m \u001b[0mbbox_inches_restore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_bbox_inches_restore\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m **kwargs)\n\u001b[0m\u001b[1;32m 2127\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2128\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mrestore_bbox\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mprint_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 512\u001b[0m }\n\u001b[1;32m 513\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 514\u001b[0;31m \u001b[0mFigureCanvasAgg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 515\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mpil_kwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 516\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mPIL\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 391\u001b[0m (self.toolbar._wait_cursor_for_draw_cm() if self.toolbar\n\u001b[1;32m 392\u001b[0m else nullcontext()):\n\u001b[0;32m--> 393\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 394\u001b[0m \u001b[0;31m# A GUI class may be need to update a window using this draw, so\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 395\u001b[0m \u001b[0;31m# don't forget to call the superclass.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 39\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1735\u001b[0m mimage._draw_list_compositing_images(\n\u001b[0;32m-> 1736\u001b[0;31m renderer, self, artists, self.suppressComposite)\n\u001b[0m\u001b[1;32m 1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1738\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'figure'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 138\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 39\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, inframe)\u001b[0m\n\u001b[1;32m 2628\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_rasterizing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2629\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2630\u001b[0;31m \u001b[0mmimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_draw_list_compositing_images\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2631\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2632\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'axes'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 138\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 39\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1225\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_gid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1226\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1227\u001b[0;31m \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1228\u001b[0m ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,\n\u001b[1;32m 1229\u001b[0m renderer)\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_update_ticks\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1101\u001b[0m \u001b[0mthe\u001b[0m \u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mReturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mof\u001b[0m \u001b[0mticks\u001b[0m \u001b[0mthat\u001b[0m \u001b[0mwill\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdrawn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1102\u001b[0m \"\"\"\n\u001b[0;32m-> 1103\u001b[0;31m \u001b[0mmajor_locs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_majorticklocs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1104\u001b[0m \u001b[0mmajor_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1105\u001b[0m \u001b[0mmajor_ticks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_major_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_majorticklocs\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1346\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_majorticklocs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1347\u001b[0m \u001b[0;34m\"\"\"Get the array of major tick locations in data coordinates.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1348\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlocator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1349\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1350\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_minorticklocs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/ticker.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2201\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2202\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_view_interval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2203\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2204\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2205\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtick_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/ticker.py\u001b[0m in \u001b[0;36mtick_values\u001b[0;34m(self, vmin, vmax)\u001b[0m\n\u001b[1;32m 2209\u001b[0m vmin, vmax = mtransforms.nonsingular(\n\u001b[1;32m 2210\u001b[0m vmin, vmax, expander=1e-13, tiny=1e-14)\n\u001b[0;32m-> 2211\u001b[0;31m \u001b[0mlocs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_raw_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2212\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2213\u001b[0m \u001b[0mprune\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prune\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/ticker.py\u001b[0m in \u001b[0;36m_raw_ticks\u001b[0;34m(self, vmin, vmax)\u001b[0m\n\u001b[1;32m 2148\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_nbins\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'auto'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2149\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2150\u001b[0;31m nbins = np.clip(self.axis.get_tick_space(),\n\u001b[0m\u001b[1;32m 2151\u001b[0m max(1, self._min_n_ticks - 1), 9)\n\u001b[1;32m 2152\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_tick_space\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2188\u001b[0m \u001b[0mends\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransAxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2189\u001b[0m \u001b[0mlength\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mends\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mends\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdpi\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m72\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2190\u001b[0;31m \u001b[0mtick\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2191\u001b[0m \u001b[0;31m# There is a heuristic here that the aspect ratio of tick text\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2192\u001b[0m \u001b[0;31m# is no more than 3:1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_get_tick\u001b[0;34m(self, major)\u001b[0m\n\u001b[1;32m 1941\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1942\u001b[0m \u001b[0mtick_kw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_minor_tick_kw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1943\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mXTick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmajor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mtick_kw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1944\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1945\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_get_label\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, axes, loc, label, size, width, color, tickdir, pad, labelsize, labelcolor, zorder, gridOn, tick1On, tick2On, label1On, label2On, major, labelrotation, grid_color, grid_linestyle, grid_linewidth, grid_alpha, **kw)\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 157\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick1line\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick1line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 158\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick2line\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick2line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 159\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgridline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_gridline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 160\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlabel1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_text1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_get_tick2line\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[0mmarkersize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 478\u001b[0m \u001b[0mmarkeredgewidth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_width\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 479\u001b[0;31m zorder=self._zorder)\n\u001b[0m\u001b[1;32m 480\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 481\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_xaxis_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwhich\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'tick2'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/lines.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, xdata, ydata, linewidth, linestyle, color, marker, markersize, markeredgewidth, markeredgecolor, markerfacecolor, markerfacecoloralt, fillstyle, antialiased, dash_capstyle, solid_capstyle, dash_joinstyle, solid_joinstyle, pickradius, drawstyle, markevery, **kwargs)\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_color\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 377\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_color\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 378\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMarkerStyle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfillstyle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 379\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 380\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_markevery\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, marker, fillstyle)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker_function\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_fillstyle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfillstyle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 225\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_marker\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 226\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 227\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_recache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36mset_marker\u001b[0;34m(self, marker)\u001b[0m\n\u001b[1;32m 294\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_recache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 297\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36m_recache\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_capstyle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'butt'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__bool__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36m_set_tickup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 726\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 727\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_set_tickup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 728\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transform\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mAffine2D\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 729\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_snap_threshold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 730\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mscale\u001b[0;34m(self, sx, sy)\u001b[0m\n\u001b[1;32m 1998\u001b[0m \u001b[0msy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1999\u001b[0m scale_mtx = np.array(\n\u001b[0;32m-> 2000\u001b[0;31m [[sx, 0.0, 0.0], [0.0, sy, 0.0], [0.0, 0.0, 1.0]], float)\n\u001b[0m\u001b[1;32m 2001\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mtx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscale_mtx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mtx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2002\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minvalidate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "epochs=40\n", + "batchsize = 32\n", + "model = build_model((1000,1),1)\n", + "for g in range(0,epochs):\n", + " for layer_name in [\"conv2\", \"conv3\", \"conv4\"]:\n", + " for i in range(len(ecg_plot)-model.get_layer(layer_name).weights[0][:,:,:].shape[0]):\n", + " clear_output(wait=True)\n", + " fig,ax = plt.subplots(figsize=(20,2))\n", + " plt.title(layer_name + \", epoch_\" + str(g))\n", + " ax.plot(ecg_plot)\n", + " ax2=ax.twinx()\n", + " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,0], \"r\", label=\"filter 1\")\n", + " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,1], \"g\", label=\"filter 2\")\n", + " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,2], \"pink\", label=\"filter 3\")\n", + " plt.legend()\n", + " plt.show()\n", + " history = model.fit(x=X_train,y=y_train, epochs=5, batch_size=batchsize,\n", + " validation_data=(X_test,y_test),steps_per_epoch=(len(X_train)/batchsize),\n", + " class_weight=class_w_dict, \n", + " #callbacks = [plot_losses],\n", + " verbose = 1, shuffle = True)\n" + ] + }, + { + "cell_type": "code", + "source": [ + "batchsize = 32\n", + "model = build_model((1000,12),1)\n", + "history = model.fit(x=X_train,y=y_train, epochs=20, batch_size=batchsize,\n", + " validation_data=(X_test,y_test),steps_per_epoch=(len(X_train)/batchsize),\n", + " class_weight=class_w_dict, \n", + " callbacks = [plot_losses, tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)],\n", + " verbose = 1, shuffle = True)" + ], + "metadata": { + "id": "KzoC-omnK0kn", + "outputId": "ab814309-4817-4576-9f3e-e49ae51be0fc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 376 + } + }, + "id": "KzoC-omnK0kn", + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r448/448 [==============================] - 36s 79ms/step - loss: 0.8209 - binary_accuracy: 0.7257 - ROC: 0.7961 - PRC: 0.5695 - val_loss: 0.5064 - val_binary_accuracy: 0.7633 - val_ROC: 0.8106 - val_PRC: 0.5828 - lr: 0.0010\n", + "\n", + "Epoch 3: LearningRateScheduler setting learning rate to 0.0010000000474974513.\n", + "Epoch 3/20\n", + "296/448 [==================>...........] - ETA: 10s - loss: 0.7829 - binary_accuracy: 0.7488 - ROC: 0.8143 - PRC: 0.6043" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv1d_95\").output, model.output])\n" + ], + "metadata": { + "id": "XEoxcIU7KrqU" + }, + "id": "XEoxcIU7KrqU", + "execution_count": 138, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(20,4))\n", + "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" + ], + "metadata": { + "id": "JZv28B--LxD3", + "outputId": "a918e0c5-8083-44ae-c13b-e1db1c78ae1b", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + } + }, + "id": "JZv28B--LxD3", + "execution_count": 139, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 139 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv3\").output, model.output])" + ], + "metadata": { + "id": "OVce6_vhM1DZ" + }, + "id": "OVce6_vhM1DZ", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(20,4))\n", + "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" + ], + "metadata": { + "id": "Q0a7PE_7M5ic", + "outputId": "8cd9a710-073c-437b-fa16-1a76ef9cb01f", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 285 + } + }, + "id": "Q0a7PE_7M5ic", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 210 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv4\").output, model.output])\n" + ], + "metadata": { + "id": "GR7LtK8uM6uv" + }, + "id": "GR7LtK8uM6uv", + "execution_count": 72, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(20,4))\n", + "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" + ], + "metadata": { + "id": "sawQr7PPM_Um", + "outputId": "466e3d22-9df2-477a-e652-a5191b84e339", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 284 + } + }, + "id": "sawQr7PPM_Um", + "execution_count": 73, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 73 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABIcAAAD5CAYAAAC9FlU5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9a4xs2Vmm+a59jWtmnltVucpVLpeBBtPcy4wxQozcfxCtHgGCnukfzPALEAyCGVqCGY00zEU9QE8jpkVjMEJC0J6mEXZ7BgZMucFA+4rL5bsLsKvsup465+Q1Mi479m3Nj73X3jsidkTsiFj7ZOa3v0eyfCpPZGbkOivXXutd7/d+QkoJhmEYhmEYhmEYhmEYppkYF/0GGIZhGIZhGIZhGIZhmIuDxSGGYRiGYRiGYRiGYZgGw+IQwzAMwzAMwzAMwzBMg2FxiGEYhmEYhmEYhmEYpsGwOMQwDMMwDMMwDMMwDNNgWBxiGIZhGIZhGIZhGIZpMNa6FwghHgXwuwAeBCABvFNK+X8tee1bAHwEwH8lpfzD9GO/DOAfIxGi3g/gp6WUctn3u3nzpnz88cc3/DEYhmEYhmEYhmEYhmGYZXziE584lFLeKvu7teIQgBDAz0opnxFC9AF8QgjxfinlF4ovEkKYAH4JwFOFj70NwHcC+Mb0Qx8E8N0A/nLZN3v88cfx9NNPV3hbDMMwDMMwDMMwDMMwTBWEEC8s+7u1ZWVSyttSymfSP58DeBbAIyUv/SkA7wZwt/jpAFoAHAAuABvAncrvnGEYhmEYhmEYhmEYhqmVjTKHhBCPA/gWAB+b+/gjAL4fwDuKH5dSfgTABwDcTv/3Z1LKZ7d/uwzDMAzDMAzDMAzDMIxOKotDQogeEmfQz0gpB3N//asAfk5KGc99zlcB+DoAr0fiNnq7EOK7Sr72jwohnhZCPH3v3r1NfwaGYRiGYRiGYRiGYRhmS6pkDkEIYSMRht4lpXxPyUueBPD7QggAuAnge4UQIYCvBvBRKeUw/Tp/CuA7APyn4idLKd8J4J0A8OSTTy4Nq2YYhmEYhmEYhmEYhmH0stY5JBLF57cBPCul/JWy10gp3yilfFxK+TiAPwTwE1LK9wJ4EcB3CyGsVGD6biSZRQzDMAzDMAzDMAzDMMwloIpz6DsB/DCAzwohPpV+7H8E8BgASCl/Y8Xn/iGAtwP4LJJw6vdJKf9o+7fLMAzDMAzDMAzDMAzD6GStOCSl/CAAUfULSil/pPDnCMCPbfXOGIZhGIZhGIZhGIZhmNrZqFsZwzAMwzAMo5exH+Lff/xFeEF00W+FLC8djxFE8foXMgzDMExDYXGIYRiGYRjmAvmdD38FP/fuz+Kf/uZHMA1ZINLNa2cevuuXP4C3/eJf4HA4vei3wzAMwzCXEhaHGIZhGIZhLpD/+IU7AIDPvHyGT790dsHvhh7P3xsCAO6dT/HvPvbiBb8bhmEYhrmcsDjEMAzDMAxzQdw99/DJl07xA9/6CADghaPRBb8jerx8OgEAtGwDT79wcsHvhhZxLC/6LTAMwzCaYHGIYRiGYRjmgvjQlw4hJfDffMfjMESSjcPo5dXTCYQA/sk3PoxnXjhBxIKGFqJY4h/9yl/hn73zozgd+xf9dhiGYZgdYXGIYRiGYRjmgnj5OHG1/IOH+nj4oI0XWBzSzisnEzzQd/G2r7qB82mIv79zftFviQSff/UMXz4c4SPPH+HffOBLF/12GIZhmB1hcYhhGIZhGOaCuD3wcL3roGWbeMONDl44YnFIN6+cTvDIQRvf9th1AMAnXzy94HdUP3/z5WP824++UOv3+NCXjgAAt/ounr/H5ZAMwzBXHRaHGIZhGIZhLog7Zx4e3GsBAB673sWL7BzSziunEzx80MbDBy0IAbw28C76LdXOP/3Nj+B/eu/nav0eH37uEF/zYA/f/OgBXj6Z1Pq9GIZhmPphcYi5UkjJOQEMwzAMHW6feXjdfiIOveFGB8cjH+decMHvig5xLHH71MMj19qwTAPXOw6OuJ39zsSxxNNfOcF3PHEDr7/WxssnY96jMQzDXHFYHGKuDH/2+dfwjb/wFL50d3jRb4VhGIZhtHBn4OGhfeUc6gAAXjpmF4YuDodT+FGM1x+0AQA3eg6OhhyevCvHYx+TIMITt3p4/bUORn6E0zGLmgzDMFcZFoeYK8NTn7+D82mI//b/foY7jdTIMy+eIIzii34bDMMw5PGCCEcjHw+lZWXXuw4AcOcnjdw9T1xCt/rJGN/oujgk7hy6H86z186S0rwH91p4/bVEeOPSMoZhmKsNi0PMleHuebIR+dvXznH7jDcgdfCpl07xA7/+Yfx3f/Dpi34rDMMw5Lk7SEQK5Rzaa9kAgAGXlWlDuVmudZKxvdl3cTSiLb4VnWd1lXopceh1+y08krqyXjnlvCyGYZirDItDzJXhS3eH6DgmAODcCy/43dDkQ186BAD80adfxce/cnzB74ZhGIY2KhhZOYf2UwHjbMLikC5OJ4kQdC11Zd3oOjg8p+0ceukkF2nqclrfVnN3v4VHryXlkE1wDn3m5VN2sDMMQxYWh5grwbkX4PaZh2997BoAYMAb51r42JePs9vVZ28PLvjdMAzDXDy/9hdfxBderWc9VC7Y12XOIQsAMJjwBYguTlLn0EE7dQ71HJxPQ3hBdJFvq1ZeKnS8C2sSMe6ceTANgZs9F3ttC33XaoQ49OHnjvDHn7mNY+LuM4ZhmgmLQ8yV4Ll7IwDAtzx2AICdQ3UQRDGe/soxvvcbXgfTEFm5QxP47Mtn+LPPv3bRb4NhmEvGxI/wfz719/hnv/XRWr6+Cka+2XMBAF3HgiG4rEwnZ2l+k3JlqbGmfLgvijR+TRmCt888PNh3YRoCQgjc6tPPcgKSNQEAaXGRYZjmwuIQcyVQHcoycWjKG2fd/N1r5xj7Ed76xA3c7Dm4k1rGm8A/+bUP4sd+7xMX/TYYhrlkHI2Sw64h6vn6p6kLdi91tRiGwF7b5rIyjZyMA3QcE66VlKXfSMUhykJGUfgKo5oyhwYTPJg63oCkbO+kAUHqk1QUmoYsDjEMQw8Wh5grwVcORzANga9/eB8AO4fqQNnQn7jVxQP9VtbhhWEYpqkoZ48Sb3QzmATouxbMgvq017K5dFojp+MA1zpO9t83esmfKbeznxRcLUFNzqHXzrysHBIArnUcHI/oz1vlHJr43NWVYRh6sDjEXAleOhnj4YMWDlJbOG+c9fPKaWJDf+SgjQf6LotDDMM0HuUcUl3EdHM2CbJyJ8Ve28KgQRcg7/rYC3j3J16u7eufjn3sF8S9Ww1wDhVLnvywPnHoob129t/XuzZOCJfqKZTw5t0H55CUsjZxj2EYpgwWh5grwYvHYzx6rQPXMuFaBjuHauDVUw8dx8R+28YDey3cO29OWRnDMEwZh6m7ZL8m59DZJFj42vsNKyv7d3/zIv7g6Zdq+/qnkwDXuvkYq65llDOHlLsFqCeQeuyHGPkRbvXd7GPXug6Oxz6kpN3FK3cO1SsO3T338LZf/Av893/w6Vq/D8MwTBEWh5grwUvHEzx2PWmV2m/ZjbpVvV+8ejrBwwdtCCHwQN/F4dBvxI1VzO1oa+NvXxvgX/zJszzGzJUlLyuzavn6ZeJQ08rKxtOo1nDfk7GPg3ZeVtaxTQgBjGo+3F8kdZeVKWHtRjcf1+sdB34YY0x4XIGCc6jmQOr/4d2fxe0zD3/06VcbsRdjGOZywOIQc+kZ+yEOh1M8mopDey0L59zJRTuvniXiEAA8sEffdq8odgWifuN5v/nFP/1bvPOvn8dHnj+66LfCaCCKJYbTZgnzR+kaaJv1bJeWikMNesYNp2GtgsLZOMhK0oEk9LtjmxgRnsuTIIKTztk6hIWTNFvoWkEcaoIjCyh0K6upXE/x3L1hlkX2uVfOav1eDMMwChaHmEuPasn6+muJcNFvs3OoDl49neCRgyRc8oF+8v9NaGd/VNjIBjV1dWkqT9zsAQD+9HO3a/9e/+qpv8Ov/+WXav8+TeYn3/UM/uH//GeNElHV+lDXzX1pWVmnWWVlYz+acbroREqJ08msOAQAHdfC2Ke7j/D8CP1W4nar47l2nHYlu14o17veaYg4pJxDNTukTsYBvufrHwIAfOzLx7V+L4ZhGAWLQ8yl58WjpIvWY+wcqg0viHA49PHwfuocSnMEmhBKfTwjDrF1WyeqAdOffPY1RDWWlkkp8a6PvYh//edfbNSh+n5yNgnwvs+/BqAZ64JCuSfrEo7LnUMWvCBuRKtsKSVGflhbfsv5NEQUy5luZQDQcy2MpnTHdxJEWYe9sBbnUPLcLI5r5hwi3s4+dw7VN3/CKMbZJMBXPdDDm2518XEWhxiGuU+wOMRcel46ScShR7PMIYsDqTVz+ywJn1ZlZTdTceioAWVlxXbG90Mc+vyrZzglvnlWqM3z8civNUPltYGH45EPL4jxnmfq63rUZP6w0E3quXvDC3wn9xe1PtSxNnhBBD+Ms0O8Qv13E55zXhBDStRWVnaalj/NC3Adh35ZmXIO+TVmDl0vZg6lf6besUw5h+oMpFaXHNc6Nt50q5d1k2UYhqkbFoeYS89rZx4cy8iCD/uuzc4hzdwZJOLQQ/tJOdleuqlswuGk6Byqq+Wv4vbZBP/4X38QP//uz9b6fS4LXpCPZxDXN7ZfeHUAAGjZBt7/hTu1fZ8m85d/dzc7bH75cHTB7+b+odaHsAbnkDoAlnUrK/49ZUZpadckiGopVzxJhfiDOedQ17Wy702NOJbwghh7LeUcqmdcDYHsewANLCsL6numqXl7revgRs+ZKX9nGIapExaHmEvP3fMpbvVcCJHUqPRbFgYTmpu6i+J0PHtI6ToWhEAjQlGPR7k7qo4b1iK//Z++DAB44Xhc6/e5LBS7udRxQFEoceg/e+ONTOhk9BFEMT7xwgm+75sfQcs28Py9ZohDUkocpetDHWvDMnFIHbib0LFsXCjtquOwnWfjzIlDjkm2rGyaXnLkmUP1OIeudRwYqnY4/X6mITJhgyr3o6zsZKycQw6udx2cjPxGZb0xNAiiGB//yjHP3SsGi0PMpefuuZd1zwISy/0kiDgfRiODuUOKYQj03WaU792vQGoviPD7H38JQHO6ot03cej2AI/f6OCNN7uNysO5X3zulTOM/QhvfeIGHr/RbYxzyAvibE2oI7dlqTjUTg71TWi8UHTv1BEQfTxcbLkOJIHUVJ1DytmiRMY6nmsnY3+mUxmQ7BuudWzSziEp5X0pKyuW7V3vughjyZeizJXj/V+4gx/6jY/gF9/3txf9VpgNYHGIufTcO59mAclAfhs2bMDGWfFnn38Nn3rptLavfzpR1vv8kNJv2Y24uT65T2VlH/ziIYbTEG+61cXLJ5NGCET3q6zs2dsDfN3r9nCr7+LcC2dEKWZ3/iYNQ/32N17Hm2718HxDMoeK86iOA/bZmMvKioJQHR3LskN2by6Q2rFmXEuUUONYt3Po+lypXvI9bQyJjiuQrAOquUKdgfGn43xPpoTNoxFffDBXi1fTrKzf/Kvn8cJRMy6VKMDiEHPpuXs+xa0Zcag5YZ2KH/u9T+D7/s2Havv6Z5MApiHQc63sY3ttuyE318UDYH0CxlNfeA39loUfevJRDKdhVspHmfvhHPKCCC8ej/E1D/azdeIeu4e08vd3hnhor4VbfReP3ejgpaaIm2G9awOXlWFGSKjDiXE89mGbiRO2SMelG0itxlEFm9cxd09GAa517YWPt20TY6LjCszO0XqdQ8nvfuIcakaWE0OP4l7sS3ebcalEARaHmEvNNIxwOg7wQL+VfUzdhjUhD+d+cTYJsNeyslwnQHWFoz/GRQGjrswhKSX+/Nm7ePvXPoA33uwCyLvwUabuwzUAPH9vhFgCX/1gLxOHuLRML2cTPzugHLRtRLGsrbvUZWLG+VbD/D1dWlaWikMNWH+LQkItzqFhko1TfLYBSa7eyA9JipzenHOoDmH+eOwv5DgBQNc1Sa8NxTlaZyD16diHYxlo22Y2zodDFoeYq8WdgQfHTKQG1RWZufysFYeEEI8KIT4ghPiCEOLzQoifXvHatwghQiHEDxY+9pgQ4ikhxLPp13hcz1tnmoB6GJaVlTVh4zxPXQfss0lYcnttNcI5NC1s8OoqKzse+Tga+fjmRw/w6LUOAODlE/qtab0gRstOHjNhXM8h7It3zwEAX/1AH7d67Byqg9NxkJWcKudmE9Zfdch2LaOWsrLj0RSmIRbW3pZtwrGMRpSVFZ2bdYgKR6NlIoaFWObhzZTw5jKHdF96SClxkgZSz9N2rFqyoy4LM+JQjWVlqmxPCIEbvWY5h148GuPxn///8MyLJxf9VpgduTOY4usf2YMhwM1CrhBVnEMhgJ+VUr4ZwFsB/KQQ4s3zLxJCmAB+CcBTc3/1uwD+pZTy6wB8O4C7u71lpkncTReTYlnZXsPKyoo3my/V1OXqbBJgf26jt9eym+EcCqOs5KAu8e21dB4/tNfC66+3AdT3b3mZ8IIIPVe1U65nbL94ZwjTEHjjzW4WXH/vvFmbkMNhvWLY6aQoDiW/K01Yf3MHhl3L/C3r+KTYa9mNCKCdyRyqQRw6WeFwAYAhwRKo+cwh3XN35EcIYzmTUajoOrSdQ3XPV8VJQZBXItxxQzKHPvr8EQDg3370hQt+J8yu3Bl4ePigjQf6LXYOXSHWikNSyttSymfSP58DeBbAIyUv/SkA70ZB/ElFJEtK+f7084dSSvonIkYbygFQLCtrmjhUvLGuq0vQ2dhfuL3ut6xGZF54QVRrcCeQ35g8uN/CXstGv2VlQX2U8YIYe9nY1uccevxGB45l4EbXhSGa5Rz62PNHePJ//4943+deq+17nI4D7LeTA0ouDjVhbchbgvs1zN+job/QRUux17Ya4c4qtpOvK5C6VBxyknlMMZR6MXNI79xV+wK1FyvSJi4OKcHYEIBXo+usKGq2bBNdx5zprEoZNW/PGpDLSJ07Aw8P9lt4cL/FzqErxEaZQ2lJ2LcA+Njcxx8B8P0A3jH3KV8D4FQI8R4hxCeFEP8ydRgxTCVUdkixlX1WVtYA4QKY3TA/f68mcWgSlOZeDKch4prKgS4LXhBnpTJ1lZW9dpbM44f2EpHzetfJ8kYoMw0i9NTtdU3dyp6/N8KbbvUAAKYhcL3rNipz6BOp9f6TNVnwpZQ4m/glZWX0xXlVNtJvWbXM32XCBZDkEDXhGTeeaWV/H8Wh1DlEsZ39Qit7zXNXXcz1S8ShLvWyMj8Zy4OOA69W59Bs2d71ntOYsjIrdVI2oayWMsNpiJEf4cE9F6/bY+fQVaKyOCSE6CFxBv2MlHIw99e/CuDnpJTzTyALwHcB+OcA3gLgCQA/UvK1f1QI8bQQ4ul79+5t8PYZ6igHQHFz12tQWQMwG5j8/GE9af+JODTbzaXfSjIZKG6ei3hBhL30Z6/DHQAkZWVC5OWRB227Gd3KwijrgFeXK+tkHOBGLxePH+i7jXIOqcws167n3mXkRwgiiYNUPN5r0PqrDn8910JQg3B8PPIXWqwrkrIy+mtEnc6hIIpxNglKxaFO6hyi2LFsPpA6CDU7h1JHm/r6RTquOZMjRQ0lfF3r2LVmDp2M/JlucNe7bmPEIZWRxeLQ1SZzzO+18NB+C3dYHLoyVBKHhBA2EmHoXVLK95S85EkAvy+E+AqAHwTw60KI7wPwMoBPSSmfl1KGAN4L4FvnP1lK+U4p5ZNSyidv3bq15Y/CUOTcC9FzLdhmPlVt00DHMRtR1gDMikN1bA6klBh4IQ7ai5lDAP1D4CSI8hvWmpxDd8483Oy52Tze79B3DkWxRBDJgjhUj/A28GZdbzd6Dg4bsokG8kBd16qn+ejpOBnLeedQE9bfonMoqMFBeTRaVVZmN+JwNPbDbI2YaL6IOEnnbtkYd9PvSVHImBRETUPod22q3/299qJzqGNb8MO4toy5i0YJmNc6zszeTCdRLHE2CWadQx07m8/UmabrbhPWP8ooceiBPRcP7bdwPg1JZrxRpEq3MgHgtwE8K6X8lbLXSCnfKKV8XEr5OIA/BPATUsr3Avg4gAMhhFJ83g7gC1reOdMIRtMws38XSdqsN2ORKd6m1tGSdjgNEcWyJHOoGV2JpkGc3YDW1cr+tYGXlZQBiXPojPhGT22cezW2U/aCCH4YZ84voDnlOIpiR606UA63xcwh+uuvyhzqubZ259sqVwsA7Leb0S1yOA2zbky6y8pORsncvbaqrIzgYWWSztu2Y8IyDe3PtbysbNE5pMZ1XJNwctGo9fZa16ktkHowCRBLzIhDvZY947KjjHLDsjh0tbk7SBzcD+61sv3va+weuhJU2U1+J4AfBvB2IcSn0v99rxDix4UQP77qE6WUEZKSsj8XQnwWgADwWzu/a+bSMPZDfNcv/wU+/KXDWr7+cJrfKhbpt2zyooWiuAGp4/Y6P/zNZw7RPwRGsYQfxYXgzvoCqR8sikMdm7xzKCttcOvLHCoLRj3o2JnbpQlkzqGaysrUBv1a6hzqOCZMQzTDOVQoz5EyWS90scrVAuRlZcVulRQZ+0lDAMcytJeVqTEua7neJVxWNikIxo5paBfm1bpbJg61nVQcIipkqP3Y9Y5TWyB1Nm8LZWU9tzkXouqZNq0x8FshpWQ3S03Ml5UBLA5dFRZX9jmklB9EIupUQkr5I3P//X4A37jxO2OuBPfOp3jpeILPvXqGt33VTe1ff7k41JwH5axzSP/DUh3+5i3imXOIsIgxDWezGWoLpB54+LY3XMv++yAtGYljWdrGmgJq49yrsVvZoKS8Yb9tY+CFkFIiMb7SRs3hqCZhU4nHB+kBWwjRmPVXOYf2Ct0MTUOPCKdKhK933dK/32vbCGOJsR9lJVAUGU1DdBwLHcfU7sRQz7b5iw8gLyuj2FnLCyK0bRNCCFim0H7poRxtZd3Ksi5wRLMKxwXnkB/GiGIJU/MzvEzU7LcskkJmGdNCltOyM4Au3vFXz+GX3/d3+MbX7+P/+cnvbMSe4X5xZzBFz7XQc63cOcQdy64E9fjQmcagNlZ1hesmZWXlzqEm3FwD+e11xzFrKc0ZLNlANyF4Nm9VnXYrq+GA7QURTsfBjHNov+NASupjq3IvkrGtR9hMxq84dw/aDqK4ObeByoJfV6bTyVzmENAccX6+NFLnIft4qMSh5c4hgH5Z79iP0HVMtG39LdBXiUOd1OFCcZ2Y+FHm4LFNQ/vacO6FcEwDrRK3YuYcIii6AUlIvRD5nJrWEEqdlUMWxKGuY2ESRGSznIqoZxoA3K1ZTHjmhaTL52dePiO5Flwkd869rNN07hyaXORbYirC4hCzE5k4VJO7ZNmtwV6rGXkMQN46NQlFrc851MTMobq7ugCFspzCIVB1fqJcU79wsK6hJDJzDrVmM4eA+gTry4Y6nNSVl1W2PvTdZojzXhjBMZPSHECvAHeUOoduLOlWpsZ7MKH9nBv5ITquhbZjai8rGyxxxQJJyZVpCJIOl0nqHAIA26jDORSUlpQBRecQTXFIjW3bTtaEOnKHjkucQ+o5SjFAfZ5iOdndmjuPfvFu3gH4cNiccnQgCZavU2y8c+bhwX4iCrVsE9c6NjuHrggsDjE7oQ6AZzUdxFZlDjXhcALkZWX9ll2Lcyg7/HXmxaEmOIeSse06FswaNtFA+eFauTBOJ3Q3I5krS2UO1TC2ZYc/NY8pC29FvMw5VFdZmY+WPesS6DdEnJ8GMVzbgJ2Gfeucw3lZ2bJuZcnvDfV5PJ4mzqG6ysqEyNegIkIIdB2TZMjvxI/QSsUL2zK0rw3nXlgquAG5c2hEUHQDEtGrbZtwrOTnrMOxeVqaOUTX6TZP0Y1V5yWPF0R48XiMb33sAABwOKxXiLpsfMMvPIWf+fefqu3r3zn38OBeXjb94F6LM4euCCwOMTuRO4fqOeQOp2F2Y1KkUc6hgrvlfokXQKL0O5ZBOnNIHaxbtgHbFLW4L1aKQ4TdLdOsrKy+bmVlgdT7DXBlFVHOh/rEoaDUVUhZNFao7BbbSLZKOteHo5EPIcrDkoFCWRnxeTzyk9LxpKxM75w6mwTYa9lLc926Ls0cl2TflMwfyxC1BFIvdQ6lIkZdnbwumkkQoWWbsMxkTtWx7p6MA1iGmLkYVeXZwwasu0XnUB2NLBTP3RtCSuA73nQDQJKh2hRUvuYff+Z2LV9fSok7g+lMnMLr9lvsHLoisDjE7ITazNVxyJVSrsgcsuCHceb8oIzn54fssIbSnLNJANNIblHnoS7CeekNlWubsE2jlkDqs5JucFnpE+GDnzcX9l1HSWQWjFpoZX/QMOeQEmnqyhwaeIvi0F7LIi9aAIk41LJN2FZyENR5yD4eTXHQtpeG2WZlZYQdslKmgdtO0q1M9xw+myzO3SJd1yJZ/nTuBZlbyq6llf36sjKKohuQrAkdx4SV/t7q7GCoOBn5uNZ1ZsKRu01yDhUyh+oYX8WX0pKyt70paabTJOdQ3fPobBLAD2M8UBCHHtpn59BVgcUhZieUOFOHODQNYwSRXFpWBtAueVIo59Bey66tW9l+2y7t0rDXskkfTtT8bVkm3Brs90C5c2i/nbgFzgi3XFeurF6NeU6DSYCWbcC1cmGzac4htcmrq9PeYBIudCVKAqnpj68XxGjZBixDZQ7pLStbVlIG5KWSlOfxNO321HETcV73822tOOSYJMufhtMwE2/qGNdzb3FNUFAPpB6nYd9WmkNWh7PlZOzj2pIy/0aIQ2ES+g3Ud+kBJOKQaQh82xuuwRDNcg6p57dVU7fcO4NkLItlZQ/ttXE49GvbqzD6YHGI2Qm1AahjA6tunkoDqdsqD4fuxlnhBRFsU8C19d+sAqs30NS7Ek1nyspqcg6VikP0y8ryLnsWhKhnEz3wgoVDShPGtsjQq7es7Hy66BLot2wMpyGkrG/jfhnwwtQ5VEMg9eHQx40lbeyB/DBIOZBaPeO7jgXLMODfZ+dQxyFaVublWY22KbTvGxodSO2na4KhysrqcA4FC+WmykFPcb7OMw3jbB5FNZaVvXIywUN7LbRsE9e7bqOcQ2pf76MOFBYAACAASURBVFr1yAB30vKxh2acQ+7M3zGXFxaHmJ1QrpbhNNR+OBmuEoeyTlr0H5Sqxt02jFoO2GeTYGm45F6bdvB35hxKD4B1OoeKHbUcy0DXMXFCWMCYyXMy6hM25+du2zbhmAZpx4UijiWGNWcODSaL4bMHHRuxpL/+ekGElmXCriFfZJ1zyDaTNYKyc1MJCB0nGeP77hxyLZKB1OeFrMY6nmvnXpi5t+dp2QaEAMkucECeQ2bWWFZ2PPYXxCG1D25K5pAqo6vTOVQMTL7Zc3DvnK6Te55MHLIX4yR0oLrM3erPBlID4NyhKwCLQ8xOFEMHdWdQKHGoLHMob/NLd+OsUJsRy9QfLAkkY7jKOUR5jFUujgrfrkvA6LlWZkNX7LebU7Jn1XDwA1TJ0+z6IITAXtvGGeFOcIqRH0KZd+raRJfli6iDyynhskggETjd1FUI6HW/HY98XF/Sxl6RzGO6a4Qq6eq6Vi0ixmASzOSRzdN16ZWVxbFMysrcesShMIox9qOlZWVCCHRsk6xzaOxHqZipv9RUce98OnOoBoC+CqRuhHMoKjiHahSHCoHJt/ou7jXIOaTmUV3OoZOSbpxq30D5TEEFFoeYnShuAHSH66obkjL7chPyGBSTtMa9TmfLMnFoj3hXIm+urGxaQ1nZMvFtr22TfkgWhTfLELWEqQ+8ctfbQYf2oVpRPCjU0WlPSolBSb6I2vCpduxU8eY6E/macrOiWOJk7OPmCucQkGa+EZ7HyrXTcZIx1ilwSilXumKT70vPOTQOIkiJgnNI79p7vmJfpmg7Flnn0KRwWQdA+3PNCyKcTQI8MCcONS2QWl0K1+WIBZLypkwc6rk4bGDmUF3i0OnEX+y416DcrKsOi0PMTkwK3cJ0Z3wUbxXnycvK6G6cFZO0tKGuA3YiDpVv9Poti/QYK+dbyzLhmKI28a3sgEI+7NtPQiVdy6hN2BxMFjOHgMSV1QhxqCDcBjUIm5MgQhTLhfl7LRU1Tog7h6ZhnLgKNTuHTsc+pMTKsjKAvrtwXHjGO6besulJECGI5Mqysp5rkhMx1JqgWp9bmrP0qohDXZeuc8gLIrScvKxMt5tbhSIXW4ADyb9jyzYakznUSYPN63IOjf0Q516YObRups4h6jl6itw5VE9Z2ck4wEFnttFNVhrZgDl81WFxiNmJYlmZ7jKOc2955lBeVkZ/kZkEMVppdwzdGxHlDFjlHPKCmGx3gcWysrqcWeWh6pTn7/k0RNexYBiitpLIJPuiTDy2GiEOFTN/6hHfyg+CqpPO8Yj2GCeZQ0ZWEqprjJXj6npveSA1kKwRZ4TXiDqdQ2WNAObpOEkr+7jG0pX7zXCa/NzqdzYR3fT9fEqsbJojSzH2I3QKIfW6cyDvnid5LLf2FteGnmvhvAEH62kYZfv+Oi5EAeDuYFaEu9Zx4Idx5ianTp45VI8McDZedMx3G5SbddVhcYjZibEfZrZE7c6hdHNRJg4lZUCC9K2qwvMjtG0DliEQaN6IDKchonj57araYFINpVYbAeVuqUMEG3hLysqIO4dG07xjjmUY2ucukAhQZcGoXdfCmOjhpEhRnK8jcyg7CLbKnUP0M4dUtzK9nYmOUnHoRsPLyjLnUNqtTKfAWUUcUuvTOKCzVijBWJVwWJodsWpNWOUc6jgmJgG9A6CUMikrc8ysBbjuSw8lWsyXlQHJfG2Mc0iJQzVl6amOWSqQmvped5664yJOSkLVO7YJIZrRce+qw+IQsxOTIM6Ud92b2KzNrbtoexRCYK/VjNKRYo27lHpttus20Op2kGru0DSI4FgGDEPc90wn6plDo2mU/e7aNTiHpmEEP4xLDyldxyIXNFuGCv3uOmYtmUPnSw6CfdeCZYgGZA7FWR4ZUINzaJ04RLysbFRoOuFYep2xyvW20jmUrk9jQoeVLKuxEEitc1zVXmBZIDWQiEMUnUPTMIaUKkdPOYc0i0PnShxqLfxd17Ua4brwwxht24Ah9DuzFHfmyvfUM456B06FerbXVRWgysqKGIZA17EwJLg2UIPFIWYnJn6YdQPRfXOt7LOqa8E8+8QP1wp1U1VHd4x14lCfeLaTKhsBkvbyfk3dysqdQ4lFnFJJQ5HzgnPI1pwnAhSzNUrEoYY4h1RZ5F7brrWsbL6ERAiBg45DOnNISgkvVM6h9CB4v51D7aQhQJ0dey6SUep867qJE0PnHM7Lq1a0snfoZWCon6UYSK1TOK4qDlHLcgJyp6YqgwSgvQvn3XMPpiFK14bmlJXFcK1EgKuvrCx1DvVnxaGmOIfUOlHHpRIAnI19HHTK57Bam5nLC4tDzE4UW5rqXsRH0xBdx4RhiNK/77ftRqj8Ez8PpAb0jrMSh5blB+QPTJrjnDgDkttjxzTgh3oFhWkYwQvipc4hKYEhwU00kJaVZaUNhrZOTwq1uSl1DqUtqqmHS6qyyH7LqkccWlJWBgDXuzZOCGcO+VHRJSCyj+ngNBWHyjbPRfZatDMaxtMQQiQNAew0G0fX7+yqzEKFysCgFJ48L5rrLpdWF3IrA6nTLCdqqAYs7WKpqW7n0GCKmz2ndN/bmLKyIIJrGWlWYT3ixd3zKVzLyC63lYhMda87j/o56+oGdzIOsmzCIl2XpquQGiwOMTsxCQrikOZFZujlh8symtKRaOyH6LpWFoqqc5wH68rKlHOI6DgrZwCQ3LDqdr+tcmZRH9uhF2Y380k7Zb3rw6rDX9e1EEuQD5dUZWX9lo1As/gG5Bb7vZJ1+FrHwTFh55BynrXTsHpA30Z64AUzX3cZWeMForfZozTcNynr1ZvrtEo8VnTTjkiUDtzKWdJPu5W5Vj3dylbtzdoOzW5lmTjkmDDTsrJIeyD1dKFTmaLXski53JYxDWO4tgHT0L8nUxwNfdzoOlk3LeoXofMoEbmOsjIviDAJonLnUMtuhPvtqsPiELMTEz/KFlXdNyjDVBRZxl7LwjnRg3WR4TQZB92bZ6BKWRntB2YSOFsoK9P8oByscGapGyuqHcuGReeQoT9zaNUhJTv0EXVlKXJxqCbn0Ir5e73r4IRw5pASZPbbtvbw2WVd9uZR4071EmTsh1nwrKW5+9OqslOF+t6U1glVFqPWRdfSm0c28AJ0CmXuZXRdi3RZWdFNqFu8uHs+LQ2jBprhHAqjGGEs4aZuwrpKaofTYKbkVP25KSVPgxozh9Tzaj5zCAB6rkl+DlOAxSFmJyZBlNRfG/rtn0MvzEIVy6Ae1gkkZUlBJNFziwGI9y9zaI945tBgEmY/o1VDLk4l5xDRsR35hW5lNYR9qxvUspKnTupYor4JKTqH6gmkDmGbIutIWYR65lAx0NjW7Bw6X+OKVai5TVUcGk2jTMjNM/X0OYeESPJhltFzlXOIjstl6IXoOCbMVLxwreSArWt/du4Fa4XNtm3CC2JyWVnKOVQUx3RfepyMFrs8KXquRfaiTqGeY66VOIfqCqSeX4OpX4TOo/ZPdTiz1L7goL0kc6ghY3yVYXGI2YmxH6GVhvPVkjm0QhxSZWWUc0XUpjUpK9PfOvVsEsA0xNLb1S7BzXORYli0XYOFeaU41KZbVialTMpC3WJZmW7nUHpDvqSsDKA7bxVeEMMQSYvYujKH9lp2Zr0vcr1r42RMd/3N8pbaNmxDr3Ax8IKVQckK6geWsR9mQm7ujNUowLlW6dxVUBSRh4VGAADgps7YqSaHQOJ6Wz131b5BiSlUUM6htp2Lb7rLyobT5ePbcy1Mw7i2nJjLwDTIxSG7BsexYt692XMsCNGkbmX1lZWdjpNnZ3nmUDNKI686LA4xWxPFEn4Yo2NbsI16nAGrLOF7LRtBJEnniqhNa2+mrEyvc2ivtXwDbZkGXMsgZbsvcjYJsN8pOIc0z+FqziF6YzsNE2u4EmksQ//YrgukBmiVi5SRlEUm2TV13ACee+HSsPqDtoMolmQ3enlYv/6199wLS3Oc5lFzm5J4USQpmZ51Duk6DA6nq53HQN6tbEQoH+d8bt/kmHrFoUQwXj2uSnQbE5u3SuxqFQOpNa67cSxTx2252y2/9KA1rkXUPHVtE2YNl0qKeRHOMAR6jtWIbmVSypluZboveE5T59B+iTjUZ3HoSsDiELM1RYtt0lVAfzeiVeIQ9bBOoNCW1rUKZWU6nUPh0pIyRZ9wCOLZJMisr5YptOdmnY1XOYdU5hC9+Tsv3NQR9r0qc4iiI6CMYqv1oIYbwMFkeQmJGneqa0OWt9SyM5fA/SzNAXJXHNUxHvtR9ruaZ7joGeNit8RldNJDOCURY95x7aYNF6aaOnFWcQ6pUj5qodSzrez1l/mPgwhSLg/7pr7mAvk8dUwDdo2t7M+9YOF80W/RL9sDEkEzimX2e6p7b6acQ2WB1N00N4uq45gKLA4xW6MCB9vpg1J3bfBwzeZOHa6p5jEA+SagGEitu6xsnTjUJVojHEQxhtNcHHNqcQ6luTglY6w2JhTFTSXKdJ2Cc6iGbmWOacC1Fm9Z1dhSO5zM4wVx0lbZEjVlDgWlmU4A/ZKnYlmZEAKOaWCq0TmkukmtgvphsJj7kWcOaQqkXnO5pL6nYxkYEnIYjv0I7ULOksoLm2pyWFcJU8/EeULjCsx2K8tC6jWKF6PCfq8M6mIxUHQOpZlDNZXQDUrcm71WM5xDah6rZ7vuvUP27CxZJ3otC2EstTkZmXpgcYjZmmL9dR15Lesyh5pgsS2KQ3UFUi8rG1F0HZodMgZzHRUsw0AsoTVE82wSoLuks4tlGui5FsluZZnjTXUrq8VZuNx9oW7EKG+igaSszLUNODUEfgPJBnqpc8glLg5NQpiGyAKTdbYEr9qtzLVMOKZBdowPh1Pc7Ca3y1lZmab1NxGeKghwroUxoWyyiR/NhHAr8VzXAXBQYc9A3TnULnQr0/lcy9ywa8QhivsxRZ45pC6d9TtMpmEEP4wX1uB+yya/ZwDyRhbqgl236/jcS5oBqMvBIk0QOCnA4hCzNTPChWbXRd6la4U45NB3B4wK5TlWDTXugwrOoR7RGuHTuTwgq6ZMp1Xj229ZJJ1D822kbdNAoNtZuKLjU+YcIjhvi3hBjFba8le3sAmkB8GlziHV+pfmGKtsFZXH5qYdmHYliGJMgqhSIDWQCKwU2ytPwwjnXoibvaRtt1p/dQlwVTKHgETIoORwSUK+L9Y5pHKkqO3NiplDuktNgdkYgTK6xAV5oFBWZhm1dEEGFvcniqaUlSmRU+1NdTuHVDMAw1jMMs3EoQaM81WGxSFma1QnoF7aSUtnXsuyxbtIE9wBo5myMhXYef/Ei+R709o8K7Kw6NQ5lJXtaXYOrbpl7bpWVp5JCTVf8kBqgSDUnzm0bH3oZIHUtA4n8ySB1Ib2khxFEkhdPsZ5WRk94QJY/N1t2QamGrovqWdbFecQQLf179EwCS292U/EIUezc2i4Yn0oQs0ZO/EjtO2ybmW7z10viOBH8VLBWKG+PzVxfjQNYRkCrmVACJGIFzWUlS2bt33iZaZA/szuufV0QQZycW1eoO+37GaIQ8GcOFSDc2jZGtFl59CVgMUhZmvyA6CZBMdpPJgUhadl5LkidBeZoRoHx9Je4y6lrCQO9Vo2yZbgKiz6oJ2XlQF6xbd1zqyuY5Ic23l7vG3VkDk0XX6D7ZjJrSOlQ18ZqluZEjZ13gCuc7hQvwGcd025lqElJ+F8Q3Eoaf1Lb41Q4tCNbt4QANC3/q7LLFR0XZOUw2UczJaV6exWplyuTXUODdOoA+Um1C1erGqyADSjrExdNvRcO3UO6ReH5sveFX3OHNLCqoYL/QbMYQqwOMRszWimrEzvIn6e2uhXZQ5l7gCCG2dFPsZ5dwxt3Vz8CFEsK5SVmSRvU+bbzNfRmnad+NZxiDqH5sTdOjLJEmdA+dgKIVJXFt21Aci7lTlp6YjO7AD1O7+sbTX9QOpZ11TLNrOsht2+rjpgVysrS1r/0juwHA6nAHLnkBLndRxU4lhWCqQG8u45VBjPZw5p7FZ2tqILUZF2ljlEZ1yBxZBz29Cb9bbOOdSEsrKis9IyDO2l0sBykTMp86c7tgrPV5lD9TmHlolD7By6GrA4xGzNaC5zSGdZWRXnULcB7aqH0xCuZcAyDe3dyubFkWVQs90rTsfJzbXa6No1tKZdJw51XZrOodHczZzuTDIgEZBX3WAnrix687aIF8RzZWV688iA5SJG17EgROLgosi8669lm1qdQ8tEt3mSzCF6Y5yJQ920rMzS93xTruYq7qwOIfdmFEv4YVxbtzKV03dQYc8A0HMOjebEIdMUWsWLdZlDuXOI1rgWKbp6kriKOrpwqjV4dh7vtWz4YaxFSL3MZM6h9PdYezn6NFjuOG5AaSQFWBxitqZY8mRrDo5TN6WrbOFtm36uyLBQOqO7W5m6BazSyn4SRLXc4FwkWZv5goABQGs2TlOdQ0ow6KS/o7ozyYDkhnHV4a/jWiSzsop4QZQFUgN6N3nFVu5lGIZAz6GZhwOoQOrZsjIdziG1Ka4cSE00c+gwyxxKy8oMfXN43SG7SJfQOqGeJWWB1DocWSej5N/s2jrnENG9WVJWlo+tZRhaBflik5cyTEOgbZsknYQK5dzpplEKdew7l2WaZl32CItvwP3JHFoncLI4dLlhcYjZGnUr31HBcVofknko3TKMtM0wtdDDIqO0xh3QX/ZU1TmU3VYR2UArTic++qnrDSiMrybxzQ+TzJa1ziFiG2gAmKQdc1S3Ct2ZZFLKlRsQQJWL0BvbIl4Qo+XUkzlUxeHSI5zRsBhIbcLTcKN8XjG3RUHVOXQ0nKJtm+g4eUdDQM/zbbgmu6UIJWds1mq90EI6KyvT6RzqrN4zGKmIMSG2ZxhOI/QKoq5t6r4UDWGbIhP0ykjWA7rPNRUkbxoCpmbxTbFsDc4cbxouAS4zC93KLqCsjMqaS5W14pAQ4lEhxAeEEF8QQnxeCPHTK177FiFEKIT4wbmP7wkhXhZC/JqON81cDkZ+CMdKShp0t6rOlf3Vm5DEHUB3IR9Nw+yBZWkue1Li0KpuWkC+waa2mM8f/vJAas3i24qNdMexSIqbYz/Kbo+BxDkUyyQLRAfTMEYYy5WHvyaUlU1T55BTh3NoTVkZkLpaCI7xNIzgBfGMMJZ0K7v/gdR9omN8NPIz1xBQ7BapYYw3dg7R2EOoMq6OXRZIrS9zaNUzTUHx4mPoBTMXlpbusjJvNvC6DKprrmI4DfKsQlMgqqGsbFkgtcoxpbgnK+JlgdTJz6/zUim5uFteVtaxTQhBt5EFFao4h0IAPyulfDOAtwL4SSHEm+dfJIQwAfwSgKdKvsb/BuCvd3mjzOWjWH+tu6tAMYh5FdQPgMO5MQb0OYdO0syd693VFvEsQI7YYj6fKWJlziw9D8rj0frx7TomxkGkTTS5LEz8aCb3InMFaNroLWtFW6Tj0Dn0LSMJpC5kDmksicycQ0ta2QOJwEHxoDIsmV+upds5VL2szAti7bkQF83hcIobad4QAK0NFzYR4LqOCT+kMb6ZODQTSK2vW9nJ2IdpiKzj0CraBF3do2mUXdYBaVmZ5lb26wTNHrEA9XnOvbzLoFlTt7JzL7nYdq3Z80WWY0p831BnWdk0jBFEcunam1R80Ha/UWCtOCSlvC2lfCb98zmAZwE8UvLSnwLwbgB3ix8UQnwbgAdRLhoxV5jRNMrEG8vU27VB3fwVH8RlUM1sURTb8WaByZoellXECyAv7aN2CBz70Yz4mN9cax7fFfkMHdeClNBy6LxMTObaKSthU9fczQ7YKzbSPdckvTaEUbIJa9kmbI25IooqXbV6LZtkdxd1yC5mf7RsA56O0pxxgI6Td5hbB1Ub/uHQx81eLg7pLJtWzQb226ufbUCyBgM0ckYmQTJHSgOpNRwATycBDtr2SmeLoktQnB8V9mOAuhTVu+9dJw51XZPcRV2RYs6mbRra9mNFBl5YWi6dddkjttbOM/GTOZsHUtdwqbSqHJ1oB05KbJQ5JIR4HMC3APjY3McfAfD9AN4x93EDwL8C8M/XfN0fFUI8LYR4+t69e5u8JeYCGRZKnmxTaF3Eh16IbiGzZBk94rkiiQCnysr02e6BRLzoOCZa9jp3Fs0OGV4Qzdwc5eKbnvHNnFm91c4hgN7Yjv1oJvfC0ixsVgmc7RC/YfXSw17iHEozhzTeAA68EEKsFuD6LQtDgplDWTDszCHbxFRDFsXxyF8b6FtEHUapta8eToOZA4TOUPWzitk4QH75QSFTL3cO5eOalZVpmLtn46BSSRmgMt+u/pgqpJQY+rPijaVZvKjmHLLJXdQVKWYJmprFN8VgSdkT1S5780yCCI5lZHt/P9L381ZxxlLt0kuJyuKQEKKHxBn0M1LKwdxf/yqAn5NSzv8W/wSAP5FSvrzqa0sp3ymlfFJK+eStW7eqviXmgimGJVuaA2dPxz6urXG0AEmNMIVN3TKSsrJkAbcNfYGdQNJ5ZJ1rCKDbenIaJm3AFZbm8T2q4hzKNiO0xnbiR2gXxtbRHJg8rFA2Ql04VrkBLbu+zKGea60U6PuuRU60AApdnwoHNdc2MkFuF47HPm6sEIznUeIctfXXC+IsLBnQ64w9rdiJE6C1BpeVlQmRBBxPNawNpxN/bRt7BaUsJyAZWylnLyR0O4eGc86kMnrE97znhS6Rui+dFYO5vElFh5BQvAovSDIhlXtV56VSlZLeXsvOqkOYy0mlREQhhI1EGHqXlPI9JS95EsDvp1bTmwC+VwgRAvgOAN8lhPgJAD0AjhBiKKX8eS3vnrlQRn7eickyhVZr4vG4mnDRdSy8dDzW9n0vG8Vgt8w5pGkzclRVHCJa1uAF0dzhRG/mkGr7e7BCHFJlbdREjHEQ4oF+K/tvR3PZ06BCN6KOY2ISRIhiCXONA/EqkolDNbay31uTi0M1HHVU0i2zZSXZNHEs1zpaV3GypXOI2jhPg2imK5POzLfTcSJsqt+LVXSzsumrvwbn3cpm3cCupSdM/WQU4HX7rfUvRPK78+rpZOfveVkoazNv1eCYf/R6Z+Vr2o5F2tkym7NZU1nZJMB+yRrcGOdQ2jAk73Kqv6xsdSML2lmxFFgrDolE8fltAM9KKX+l7DVSyjcWXv87AP5YSvleAO8tfPxHADzJwhAdRtMQjxwkGwXbMLSVOwHVN9AdxyS7kPthPNMxx9KciXMyrjbGXco31zOHE73d4I5HPvota2W2CKVb6yLzgdSqfE/XDZWai/0V3Qy7hbGtGv57lVD5N24xkFpzK/t1gb79lo2xT0+Ay5xDzqxzCEgEzpaxuhR3FUcjH0/c6lV+vTooUcsZmYZxNqaAXmfs6cSv5BoCCusEgedbmXMIABzL1JI5dDYJ8LWv61d6bcehVVZWVspsG4bWwOThNERvbc4mvaDvIsOFQGr9ZWVnkwCP3egufDzLHCJ6plBMgmR/5pp692VAXla2qjyy51o4GtK91KdAlbKy7wTwwwDeLoT4VPq/7xVC/LgQ4sdrfn/MJWY0DbPNs2Xq7SpQ2TlErK69iFpklf013zzrEy9ubOAcoiYOJWVli6HJuhxwxxWcWZlziNhmZDLXyt7JQlH1/JzDrK59RSt7l/YtoHIOJfZw/TeAg0kF51CLpnChnEPFhgitVOD0dsxu2dQ5pNb/AaFsJyllsv5aJQ0BdGQOjYNKeUMArcuPTNS0Z9dF1zK0rL2nYx8HFUK+AXquwlGJOGQaQuulaNIkY00gddrhVEpaHU4BIIolRn5UCKSup6zsbBJgv6QLZ6cpgdRBlDay0OuWB6qVlXWJlqNTYq1zSEr5QQCVrwSllD+y5OO/A+B3qn4d5vJTtH/q7ipwMgoqulpMjPzkQVmlg8ZVYjC3yBqGgCH0diurkuvkWgZMQ5AT4ebLGnR3gzupIHB2CN1aFxnPdStzNde2q43Fqo10t9Bl70Et3/VyoQ57LbtQVqY5O+Dhg9UlJMUw36pBtVeBPHOoUFaWip27ODC8IMLIjzbKHFIOGBWyTAE1hkXnkHKe6WgNfjrZXByiICIvLSuzjZ2dQ34YY+RHuFZ5XJPSESp7s2HJM8cyBSaBnv2ClBIjP5zpoFpG20k7nAbxwr/zVWfenWXWUFYmpUy7lS3OY9s04FgGucu6ebwgQss2sqxCrc6hqepWtnyd6LsW+Vynq85G3coYRiGlTAOp01b2Gu2f0zDCcBrierdamGQUSy2W6cvGID0MFBdZyzQQaLip8oIIYz+q5M4SQqThvrQWcy+MZpxDtuZucEdDf2UYNVDoBEdsMzKeKytzNLZTBpJNpGsZ1Ur2CGSJlKHa0c6IQ/c5c4hqWeSwxDmkBM5dnEOqg+EmziElDqmQZQpk4pA1G5zsmIamzKHqDpesYySBOTwOItimWFgXk057u43r6URl6FUX3WKZl79edbJS5rkOe5Em8WIaxpByUdibJ3O3EJiv85zPOYJtU39Z2Sgtg15WdppEVdAb2yLK2W2ZBgxRU1nZGufQ0AtJut+owOIQsxXTMEYsUSgrM7Tc+AH5JriKq6VH6NZvnrJgN9vQU753rDppVRhjQFnE6YxxFEsEkZwra9DcDa5Cxz3lTKC0GYliCT+MZ8rK1CFQRygqkNxOrcsR6hLvPKKEhoOOXY84NAnWZg5RCvMtMvZDGAIz3QyVkLzLYTdfd6u7rGzTQNcxaTmHUoHNnRMxLE2HwbNJ9ZbrHUINF+bLeRWuZezcDOBMdYCrKGxSK0dXz5HuXFmZrjVXzb9uhcwhgOaeNxfgkt9d0xCIJRBrdA+pdXSZONQlHvgNpJlD6TphaxLkFedeiK5jrswg7LUshEQv9anA4hCzFfP2T50K/3GFFuAK9aCksLGbZ5BlDhVtzIaWcVZjXPUGu+uaGE4JHU7SkpxiWYPObjlSShxVyHTKnEOEDteTYDEUNSsri/T8nFXCkvOx0FxebQAAIABJREFUpbc2ALMCb2YP1yRsxrHEcBqWtvstQrUscjSN0HWsmXIYJRTtkt1yMkrW0Otdd6PPO+g4JJ1DrTkhwzJ273oqpcTpOKjccr1j0+kYOfbDmRB1hWMZmSC3LafpobpyWRkxV2FeVjbrNtZV9rQsTHyeDuGOWmqMi3EVgL4mLEBB5GyycyiI0ErnmWPtXnJapNhheRnUhGOKsDjEbEV2y1FoOalL4VctwKs4h9T3p+gOKCsrs02hxaGlDpZVsy+S4G86mxHlYGkVu5UZKnNo9wfl2I/gh/HaOdyyDQhBZwMN5D9Lu3BIycrKNDmHhl6wshsGUFwb6MzbIkcjH0IkAq/uYMmRHyKWq0MlgXyTR22Mx344kzcE5O63XZxDR6MpgM2cQ0ASSk3KORSWO4cca/db7JEfIYxl5fInwxDoOiaJg8rYj0rFBVfDAVDtyyqX6xE7ACp3ZLFDpmXoKysrcyaVQbusLBWHCt3KAH2l/kDuHFp28dEhttctwys4DHWV8iqqXNz1CLk1qcLiELMVp3Pqe+a60LCIH4+rlzzlziF6i3lZ6r9l6HEObZp9Qa3ziFcI81XYpr5uZVXdb0IIdB1amxEVitqxy5xD+jKHqpY8UXO1KI5HUxy0bZiG0B5Irdae9ZlDNJ2bIz9aKO9QzqGdMoc2dGwqDto2ztLMFwoogW2hrExDa/DT8WYiBpAcRil03Jv40YIbC0gzh3ZcG5RzqKrolh8AaTzbRtMQYq7U1NJaVlbVOUS3rCwPM1aXzkoc0tiF01vjHLKb4RzKxCHL0Jw5FK7MGwJyAZQ7ll1eWBxitmI+syZvQ6vROVRhA51nDtFbZAZeAEPM1qAnmQy7j/HhMBnjmxWdQ9QCqbPDyUxZmbIwaxTfKgqclOavKisrDaTWlTnkhWudQ8p+T0nULHI8yrvhqU20roPKIAsGXZfrRNO5OZouOod0dCs7HgcQIikT24R9os6heSHDtnY/bGcXVxt0z6Ny+eFH8Yx4oUi6le0mJqhynOqB1LSEYz+K4VrGTKmprv0YkO9h1zuHmlBWll46G/rOFYq1mUOuSXJsi0yCvGGIoyGPrEiVsrI+O4cuPSwOMVtxpMqS0sOJmZXk6HBdVN+EdAjnigwmSemMUQh2szUFfx8Np7AMsfQBOU+XmDiUHU6sepxDJ+Pq+Qxd1yJVljMuaaecBVJr2oRUup0ifMMKJN3wbqTZNarTk67Mocw51K52A0itI9xoupjdoqNbWdHttQn7bZtW5tAS55Bt7P58W3f4K6PfsjPXwlVmGsaZi7CIaxk7C/MnYx+mIdaK8gpqZWV+GGfZbgrLNLSVPFXNHGqTLiub7XSl88JOMVhXVkY8kDqOJbwgzoT5OgKp17u6aa0NFGFxiNmK4zQ7QWXW2BrLyk7GPvotq3STM09+O0VvMT/3FgNhTUNP8PfhcIobPWfmFmwVPdcisXlWlDmHbI0C5+mmziFCY1taVqbCfHcMRVWce0F2+7QMyzTgWgY5V4ui6BwC0jwyXc6hkryzMpQ1ndomb+xHmbioyLuV7RZIXWVNmOegQ805pNbfuUBqU+xcGjl/cVWFfsvKDqZXmSCKF9rYA/rKyg7aduU9Q5eYO2AaxnCsuflq6AykrtatLCuXJihgDNPSPbX21uUcEgJL9w9d1yQzZ8uYL91zTM1lZdMw+9rLyDvJ0pvDVGBxiNmKo5EPxzSyWyRL48H6bBJUvvXrEOuIUWTgBQuHMx3dXIBZ10EV1ANTSn0P6YtEHfCKziHDEDCEntKcTbrBdR2LlIBR5hxSN646umKoTlpV1ghqjrcixyMf1wtlobaGMF9FXla2epNnGgJtghkNIz9cKO/IBM5dysoqdDAsY69tYxrGOwlTl4ls/Z0rgbI1ODGOhuriqvrzrU8kcyiIFt0tgAqk3r2srGpJGQD0iJX1+mFcS0aWonLmkE23rEyViysBUjmHdIV+A8nFR3/OkV+kbdN2Di1Eglj6HMdAtbIydW6bENs3UILFIWYrjofJrXW+iOvLvDgvEUWWkbdEpLeYD0rsmS3b3HmTBwCHI79ypzIgOWTHcrdOPZeJ5TfXhib3W3I7VU3AoFXjvrKVvQZxSHXSWtdmHUjHluDaEMcSJ+NZoUFn15G8rKx5ZZFAUiY3f4OfdyvbpazM3ziMGshLrKm4h7L1d96JYRo7X34cDX0YApVb2QOEMoeWlJXttZKfbxfX8cnY3ygri5qr24/izCGv0OnWVAJ7Z40jNisrIzBf5zn3whlHj+4sPSC9fF4hcib7MToXofOoqg/lYHVNA76GMwWQ/Dt5QbzW1d3N4kBorA0UYXGI2YqjkpIGQE9XgTJRZBkUW4ErBpNg4XCmS0g4Gk5xc5ObVWI1wuqAt5h5oSdg8mTkY79itkiHmLtlUtLKXmXi6HAODSp20gKSTQiVOVvkdBIglphbgw34oZ4NrSorq7IOU7ThlwdSa3AOjf1KXTjnUSIzHXFoSSt7DYfto9EU17vuUmdAGT3XJtE5J4gk7JKyslt7LUiZuwa24XQcbCS4qbJeKnuzIFws2TMNoa+VfXpQbpd0myviWAZsU2BMxEVYZDiddZ2oS2edzqF1lQkdJ7kI1bFXuYwcDWfLbnV2KyvrsFwG5dwsKrA4xGzF0ZzzJC8r03D4m6y3JSootgJXlAW7dRw9QsLR0K/cqQyglx+QlzUs3lzrmMMn4+oOga5Dyzk0LskcApKDoI5NSB4ouV646BAbW4W6/SsKDY7GsrJzL4RrGQvOjjI6xNZfKWVSVjbnHHLM5CJi29wsKSVORv52mUNpW3YqodR1trI/3PDZBqRlZdMQscZD6EVQFpoMALfSi6C759Otv/bZJNi4yx4VRxaQOIfmxaEkkFpqcZmM/RBt26x0odS2zSzbjxLD6Wyjidw5dP/EIWpd9uYp6zSta3zPK3Y5VQInNccxJVgcYrbieDSdKWnQ2enp3FsfaFaEWitwRVnobtcxs7KdbRn7ISZBtFEmA7XuAnlZw2LmhY5ucKcb5DPoEvwuC2Wt7AE97ZSB6mHJgCp5ojO2ivz2L/8d1hpI7S26FpfRc2mtv9MwRiyx4BwSQsC1jK1LmAdeiDCWW2UOUXUOzYvzLXv3APlNXbFAftN91deKRMBYFBdu9ZPxuDfcXhw6HfsbZQ4BtDLfyoQ329DnmB/7USZMrIPankExfyGqLp21Zg55q/MKlXOL4qUSkLhXgXzvUIdzaF0nWSCZwxQFTiqwOMRsRZI5lG/AMueQhryW8w0OJgCt26kifhQvZOIkJUi7LaiH55t3c+lRE4eWOIdsU083uOORj+tVnUNpqSCVGveJH0GIspIRzWVlVfJwiG6iy9p162xJO5hUL+2ldlBRP8u88w0Avu0N1/D/fvrVrTa1JxuE1M+jDuWqC+JVZ1kr+8eud/Di0XintXDe1VwF9Xy76qVlQVSeOfSAEoe2dA75YYyRH21UVgYk4hCVPEi/rKxMY9nT2I+yoN51dFyTZllZGkitMDV2QVacTVZnmqqLULLi0NBH2zazyzvbNODf50YWQHLRTWnfQA0Wh5iN8YIIIz+aLSvT5BxSnYiqHkyA9EFJcCEPIrlwU9XR0BnoMC1J2eR2lVpZmRIp5rvlWKaezKHTDcI7O46FMJbaHtAXjRdEaFnmQstj1zb1lpVVdQ4ROZwUKZu/ySZPU+bQBk0Buq5Jyh7upWM773wDgJ/+R1+Dw+EUv//xFzf+uurGdpvMoT1iziEvjGAaIutGpHj8Zhfn0zBrR78Nh+fTjTpxAnkZxFW//AiWlZXtKA6dTpJ/j02dQz1CeWTTaLGVvZ1eiuoQ5UfTcG2nMkXHMWkGUs/t/e0anEPrM4dUm3V64wukF5dz5ei6nEPDDfIg20RL/qnA4hCzMapm9cZcGCqwe+aQ6kS0kThE7OYaSB6GUSwXbgE7btJmc5dshKwkZYPbVWrOoTyQenGzp0OkSYJnKx6us+4jNB6UQSQXblgBPe2Ugfx2qkrmUJdYyZOirNuTYxoING3yNmkKQG39VWNY5sD49jdex82ei7+/M9z46x4PtxeH+q4FQ9ARh6ZBjFbJGvHGm10AwJcPR1t93Ym/eHFVBVUGoTIzrip+FJcGUrdsE/2WtbU4dDJKxmXTvKyOQ6est6ysTF2K6rhQSsrKqq+5FA/W823QTc3dyrwggh/GK13Hyr1FZT82z7yz0rX0OYeqBlIDdEv+qcDiELMxaoNavEWyNNVe54tL9RuqrmOSW2TUw9Ceyw9QQsIuuUNHae7AJplDvcw5ROOB6QUxDIGF1rQ6nENeEMEL4urOIZdG3oXCX1LaoOuGajBJ69orbKSphSUr8syWgnPI0pc5tElpb49QrghQWHtL5jCwvci5i3PIMAT22jYdcShcLJkGdheHjjJXbPPKyqSUpW5jxa2+u7U4pD7v1oZZTpRK/v0wWshz0rXvBZLn/ybOoV2zJy8bqg168blua+5WNigpx56nQ7yT1rxzSGc5etVAakC532jNYUqwOMRsTNmttbKH77rInG9gS1R0XYvcIqPGeKGsTIOQcFTi/FoHtQ4O0zBCy14sfbJNY+fcrJPxZtkiqisSlZvA5IZ1MRQ1OVTryBwK0HOthZKUMnquCT+KtdmmLwt5t6d8DdadOVR1DVYd4ahkZqlb1DL3G5AEq28zn7LMoS3EIQA4ICQOeUG0kDcEAI8ctGGbYntxqCSovQqqAcZVFjJUSf+yeXurt4M4NPSSr9HfbFy7hMrKyoQ39QzSkbU5nkYbiUNUxlWhSpJmMocMfc4sIL/YXnXxQT5zaL6szNRXVnY2Uee3KplDFsYBrTlMCRaHmI1RC0lxE2JrsteebxBopugSsi4rgiUHlMw5tMOD63A4Rd+1FsKYV6EEjHMiGxIviEsPJ5Zp7JyblbcKrXi4Jia8BUtKGxxd4tAkqNzNUFnEqXXFUM4Vt6bMoXOv+hh33SQzS8e/7WUgO2QvER+33Uwfj3w4lpGt4Zuy37bJtLKfhnHp88cyDTx6vYMv39vRObShiJGXlV3dNdjPHG/lrdBv9d2tu5UpUWnTcaV0cVcWSJ27THb/GUd+mO2z1kGxrEwJszOZQ5n4plccWtnKvgGZQzORIBozh07GPvoVL+7a7By61LA4xGxMmTikq1vZJmn3io5Lb5HxlzmHnN3Luw6Hm3dzMQxB6rbKC6LSw4ltiJ3nsDrAVS0ro+YcWtYxx7U0BVJvUPKkHG9DYhu9sm5PjibnkBdEmK7JZSiSbaaJrA1ry8pscyshTHUwnHcrVoVWWVm5cwgA3nC9g5dOxlt93cPh5q5YoJCpd4XFoWDJnkHxQL+1tXPocOjDtQz0K2biKHpprggFV6EfLYpDyl050PB7Ofaj7KJoHZTK9RRleTW5c0hvN62VreyJZUAW8YIIkyCaca86poEwljvlmCrOJgEOKmdt0rvUpwSLQ8zG+FGyaBY3IbambmXbZQ7R2YAolh1QdNRDHw2nG+UNKShli0zDZc4hsfMc3rSsrEPscO2Hi0HqgMZA6g1KnjKLOJGxVXhhBMcyZoQG29STObRJqCQA9Ih0elL44WoHhrulc+hk7G9dUgYkYjMdcah8/QWSZ/+2a+E2zRaAZA8hxNV2xuY5heXj2mslgsI2+6R751Pc6rsbC5td10Isd8tIvCwk5dKz4o1qijDYUVSUUiYH63a1edvf4d/ysqKqBnpu/mxX+whdgclVnEMdYpd1RdTPVHSoKcFTxxifjP3Kc5jipT4lWBxiNsYv6eaiq/ZaPWSrdCJSqA2IyuGgQJk7Cyhk/+zw4Doa+hvfrAK0bquWOoc0uC/ybJENBQwim5Gg5IYV0BhI7QWVhQu1CaIybxXTkrJIW1O3MrVJryrA9QmU5BTx1xyyXXs7kfNotN26q9hvW2TEoSRzqNwlkXQY3G4tPBxO0XHM7IBXFcMQ6DnWle5WNi3ZlxVxdzgEKnFoU7qEupyWlZXpcg4NvBBRLGeavKyi51qQks6eAcjLuLoF91RHQ4xCkbPxenHINARatkEykFqJtMVGFo6mvFggcc1XncNJ5hCdrEJqsDjEbMy0tKxMb+bQZoHU9GqE/aXOod2dEEej6cbZAUDaepLAJg8AvCXdcixj925lJ6qsrOINCrUa9yCqP5C6elkZLeFNUZbZYlt6Moc2FeizA9IlP1hX3fyuK89xzO1a/56MdnQOtRPnEIXNdNKtrHx8d8lTSVyx241xr2Vd7bKyaLHUtIj6+DZr8OFwiptbuY2VK/Zqr79SyvKysraete9s01L0rHvs1Z2v8/hhsq4VRWN1ubPLZWgRFZi87nKJasmTl4lD+RhnziENe7PTsV95DrcdExGhrEJqsDjEbIxaRIqbEF3BcYNJCNsUSzc4ZeQ5PHQW87IxBnZ/WEaxxPHIx80tDild1yRxAwgkbWndksOfDufQ8SgJ5VvWNWaeTlb6dLU30IplmUM6W9lXD6SmVbKnKMts0ZU5tEk72uR1aWnF5HKO8SunE/zAr38I3/S/PIVXTydrX7+u65NjGVnm0yYkmUPVLz3m2W/biGJJYg1OnG9LnEOOuXWZeOLO2lzEAPJSnauKmrersrIAbDV3t3UOUdmbZR0M5y49cufQbj+fKkU/qHjpkbk1r/i4FsmbsORjnOf/6Pk5B16ArmMu/R0pfl8q+7EiyoFVFId0lu6dTgJcq+wc0hfmzuiHxSFmY8pa/VqmnuC4cy9Av2VvVNueB6LSWWSWbfRUYOFky1uNk7GPWGLrzKEhkTEOIll6+LPTcL5dOB37lUP5AKBt03IO+dGyzKHtgnyLxLFMOmlt6ByiMraK8rIyPZlDg6wdbbUxVq+7rCU5v/XXz+Nzrwww9iP8h0++svb1awOprc2dQ0EUY+CFuL6lcAEA++mmm0LHMi+MljuH0pKZbcrED4f+Vg4XIHm+XeXSyLJy/yKtdL3wNsz/CaIYx2Mft7bcMwBXv6xsmWDcsg3YptjZOXSalqVVLUWnEKA+T9n8dSwDjmlodA4FK0vKFF2C3eCAvMtpu8Q5FIS77XujWOVmVe3SS0M4pgqLQ8zGlHXSsg1Vt7rrwbr64qKgVNeuWJo5tKNzaNvAToBWIHXiblkUIC1T7CxwnoyDymHUQFLj3ra3z9m4bAThsm5luwdSj/wQsawuXHSJlDXMMw0XM7N0uN6AzTtGXubMoTiWeN/nXsN//g9u4S2PX8N7nnl5rSNlXUvwbZxDyhlwfQPReB51qKGQOzQNYrSWOIc6O5TZHg2nuLl1WZl9pZ0YZZd2RTLn0IYC/fHIh5Sbt7EHimW9V3dcgeXdY4UQ2GvZO2cOnSrnUIPLypY2YXHNrS9D5xlMql0sdVyT3IUSAEz8ZIxLy8qi3fZI514AKavP4SxPikBYPUVYHGI2pky4ULeA3o6Hv21q29WmWUc70ctCsOSA0rINCLG9zfZomLSy3cZ6TylzyF8iYFiGoaVb2SbiEJCIGFTGNgmkXjxYO1Yytru0TN00D6fr0DiczFPW7SkRh+TOmTRZ7tumJQ6XUBz69MuneG3g4Xv+4UP4L77pYTx3b4QXj1e3SV92EFS4lrmxc+hkpJwBu2QOERKH1mQOAZuX2cZpyfS2mUP9loXhJXW/VWHZnkGRZw5tNq53Bh4A4IEtxCGVOXTVHcf5nndR0Nxr2zt3K1NNLKpejCrn0FUWM+dZJg4l+T965s9wGla69Og4dC7riijX4IxzKF0v/B2dQ1nW5gaB1AAtgZMSLA7VxHP3hvjQlw4v+m3UQqk4lNo/d6293mZzpxajUwKbZkVZ6DeQ3FR1bHPrh+Vhugm51W92t7Igiku7Edmm2LnjXiIObeYQ2CWE9bKxLHNIZYzsUtuuBOCqziG1Cbrqh5N5yro9ZfbwHcXNwSSEIfJy3XVYpoGOY17KQOoPP3cEAHj71z6AJ271AAC3z7yVn7OurCxxDm02n47Tdff6hqJxkcteVvblwxG+/9c/hM+9crb2tdNgMTNLsW1A/8ALEMZy+8whImVly0XN7QKpXzpOcroevdbZ+D1Rcbgsc3IDwF7L2t05VKHFehElcJAqK1tSupcINXp+zuE0zIS1VVDajxUp7VamqZW9cr9VvRjtcObQpYbFoZr43Q9/BT/xrmcu+m3Ugh/FECLvUAak9tq2vfOt5tEW4hAlu70iC+cr2eh1XGvrh+Xd9BbwVq+18ed2XQvTMNZSunLR+FFcOra2uXtHrZNRUNlaq0jyLmjM32WuLGfLw0mRTByquIk2DIGuY2oLtLwsJN3KFjOHgN03edvkvvVbl3P+PndviAf3XBx0nCxQ9+75dOXnBOvKc7bIHMrEoS1dLQAyR+3hcPX7vwi8IMIP/caH8ckXT/HBCpdiifNtSVnZlh0G1bhs3a3sil9+rJ+3yXhvmjn08knitHv99fbG74mMOJSW3JSKQ21798yhcYB+y4K1JihZQTFLb9met+OY2srCh16IXoWLpa5GQeoyUdatLAuk3nHfqy4t9qs6h4isDVRhcagmemnnCwptZ+dRB+v5w8N+e7cblDCKcTLevNtIcpABzlLlmgKrbqq6OzwsXz310HHMymU5RXqEFvMglKX2+4NOkh+wbemTH8YYTkNc37B8ZK9tXdpuT5uyPJB6u7KGIllZWUXnEJAcNiltooHybk9qzIMdN3kDL9x4fei37Evpunj+3ghvSh1DqixGCeTLWNf1aZvyyOPx7s6h6x0Htinw2pr3fxF89PkjHKZ5duv2AHGctAWfFzcVeRebzeaT+v7bBlL3WzbGfrRz5pxONnkv6xxvarw3FedfPplgv21vtOYqVOnIVRbdgIKTu2RsdWQObVqKnpWVXcI1d1uCsLwsMnHx6OpWVtE55FrkcgqBJa3s1b5hV+fQZDvnELW9GRXWikNCiEeFEB8QQnxBCPF5IcRPr3jtW4QQoRDiB9P//mYhxEfSz/uMEOK/1PnmLzP9VtJ2dpuOG5cdP4xLRYv9HZ1DJ+Mk0GzTmz/TEOi7FknnUNlGb5eH5e2zCV6339rIFaCg0nkEWF76dL3rIJbbu9DyB+RmG+m91u63j5eFIIoXWv4CBRvxDpuu3DlUXbzoEdzolXV7sjVt8s69AH130/l7+UpypJR47t4QT9zqAkieT45l4N4a55C/5JCi2MaGn2WK7CAOGYbAg3stvLamLO4i+Ojzx7BNgYOOvdaZpQ7aS51DWRbFfXYOtbb7vnXhhzG+4Reewi+9728rvX4arhaH1HhvGqb+0skYr7+2uWsIyJstXNYLpbNxUGk/k1/WLa4Je21r58yh03FQOasFSC5abFOQ2IspgrQiwTRmxzjJY9SVORRUyxyyqTqHknncdkoCqTU45oHquVn9rMspvXGmQBXnUAjgZ6WUbwbwVgA/KYR48/yLhBAmgF8C8FThw2MA/7WU8usBfA+AXxVCHOz+ti8/ubJP48BXxC8JQwWwc1nZ0Wj7sOT9jk0qc2hV55H9tp2VKWzKq2ceHj7YbqOX20Avx+Z5F/yoXOBUjp+jLcdX/btsGjy7q7B6mVgmvKmb511EMPW5GzmHCFrEy7o9qRvA3bMDqrX7LZI4hy7X/D0c+jj3QjxxM3EOCSFwq+euFYdUJ8NlAnp2yN5gM3088tF3raUlP1V56NKKQ0f4ptcf4LHrnbXjq5yDyzKHOls6h9S4PLS3eck0UAhWn16Oefylu0NMggjv+MvnKj3vleNt2bi69nbOzZdPJlvlDSm6rnUpM98GXoBv+l+fwo//3ifWvjZrZW+WBFJr6la2iXAshCDVIAQApum+YX7d1eUcCqIYXhBXdg5Ngmin5hmXkSxzqLBG2Nr2DT6EoNHIgqkgDkkpb0spn0n/fA7gWQCPlLz0pwC8G8Ddwuf+vZTyi+mfX03/7paG933pyTca9Cb+skyR/R1rr3dps37QdsgcroHi7fXiOD9yrY1XTidbfd3bp4lzaBu6WeeRqz+ngyWZQ0ocOtmyRFEdjB7obzbGe+3dN5iXhWCJ8KZq0Xf5PVWld1XbrANJaQOFOVtkWuYcSm+1dw2kPh77G2fj9Fu7357r5vl7QwDInEMA8MCeu9bZsuz5pnC2KI+8M/Bwa2+7cqciD+23Ll1Z2XAa4rOvnOGtT9zAA/314psS1YqlDUU6rio32LyrlmsZGwubiv4lK9V59vYg+/Nb/8Wf4z988uWVr19XVpaV9W7gHJJS4uUdnEPA5e3E+X/8SeLIqpKRtTKQum1jGsYbZzkVOZ0EG7uNe65FKpA6CGXpnqzr6ukcpuZgFXGo65iQcvfuy5cNL4hgm2Im28rV5Bw6Hvs4aNsLzq9lKPfbZVlvmVk2usYSQjwO4FsAfGzu448A+H4A71jxud8OwAHwXMnf/agQ4mkhxNP37t3b5C1dWiirostcF7u6H5Qt/OYW4hAl5wWQq/hlt4CPHLRx93z6/7P33mGSXPW58FsdqnOcnpw2J2lX0molrSQECghhsgXG2FgYDNckY9nmw77X3GuM4RqMMQb8WQbZBJskAxIgIRRQAgmhuHl3djZMjj3TPTOduzqc+0f1qenprtzV07XDvs+jx2a3Z6antvrUOe/vDZoXc65YxkIqj66Avo3exrKViefiUL80JSq1Yj5BySFtB8GAy460yfIu9IAQInltjQiOT+QK8LBW1cGdgHGbSzNBqsoeaNxWtpTmNGfjmFE5NLKYBgAhcwgA2r0ORJPKbWVyCh89m+n5RE63oqUaXX4nZleypsoyfGksjlKZ4OCWNrT7lMk3Sk5It5XRKnuNyqFEXrdlGli1lZnl+TY0m4DDZsG333sNPA4rnj4rT2Io2SFXFW/q18LFFIdcodwYOWRgZoxRyBVK+PHhaQC8jUnpsywbSF25bxoZjC6lOdV2HAqvw7ahhs9UsVkLo5rD6FnMq8ZWtoFU8tXtMFBzAAAgAElEQVTIFkp1imOjAqmX0gVNinmGYeBz2pEyiVLzItZC9Q6bYRgveGXQnxFCEjV//UUAf0UIEb27GIbpBvAtAO8Rew0h5G5CyAFCyIH29o0hLPJWMhs2ErNPwRXFVRcBV2NhvoJySKetbMWkFb96UChKh6L2hlwghM8P0oL5RA6EAD06lUOrmQwX9j1dKhOUyuIEBlWt6bXt0YNnh0aVwOoG88K+tgWJOlrAIHIoW1AtW6ZwX+AtRLUghCBXKNUpL4zY5JXKhJ9i6wlUN9m9OzSbgIe1orfKRqtKOSRBblLoqQSfT+SNIYcCTuQKZVOF1z8/yucN7R8Mot3rQDydR0lmD0Cn8bXKNwqXXZ9yaG4li84GrjHNwDDLnm1oLoEdnT68YnsEOzp9mIhlZF+v1FamJ5CaNpX1h/Xbyvwu8+VBPjcSQ7ZQwpsu60GpTDC5JH9tOZlA6kazU/LFEhK5Ito0Bql7N5itTIqU97BWpLnGy33oHsCnxlZm12dtNTtyhRKcbI0d3WbQUCmjZ6hkvqzCi+ChihxiGMYOnhj6DiHkPpGXHABwD8MwYwDeBuAuhmHeUvlaP4AHAXycEPKcIe/6AsCqcshcD0UjIBdIXSZASueCGk9zsFoYXbLwjaccKsFqYUQlmn2Vw870kjZyaLaSydCtN3PIxM0jhBD816/HcGRyWfG1gvxeJFySKofiaX110dFEHj6HTQhVVQtKeJjRWvbA0Rl8/8VJVaTDqrVBJLjTaYxySGtrjs+xsTYgxTJBmdQrL4xoHVnJ8qUAYR2B6lyx3FATndE4NrWCS3sDsFStoR0+J5YzBdn3KWU5pdCqHCqXCaLJHDoMIIe6K6rP2YQ+W3Ez8NxIDPv6gnCzNrT7nSiT1fxAMVDlUO0Em8JiYficMM3KoZxuyzSwqow1QzEAIQRDs0ns7vYBAAbCbkzEFQgMRVuZ9qysycoeo6+BzKGwh8WSyQZ3T56Owmm34PeuHgAAjC6kZV+fl7GVNVrJTYei7RrVxrQReaOAk8gqdDtsvMWrwXIfeq3UKIdohMJGUxznCvUtkXoKFsQQT3Oah0reDbY320hQ01bGAPgagCFCyBfEXkMI2UwI2UQI2QTghwA+RAj5McMwLIAfAfgvQsgPDXzfpocQSL2BFm8KKVuZcPjTuRGIpfMIe9g1m3m1CLr4QGozye0bAW/NEb8OvRWJ95TG3CGqNNKtHDJxlf2p2QT+5icn8TtfeRa/UsgQECasIhsRp90KD2tFPK3vHo4m9WWLGKGqaQZKZYKPfO8w/vLeY/jkAycVXy+Xe+G0W8BaLQ1nDmmtWQ9soDwnQLrtadVWpn8N1BuoTochZlG0FEplnJpNYF9fYM2fU7vnooxtVMreQMFqVA7FMxwKJYIuQzKH+O8xa5JQ6nS+iGNTKzi4JQyAt+0BPEkuhbyCcgioWEk0ZLgQQjC/kkdnA+SQz0S2sniaQzzNYWeXHwAw2OZGNJlHVuawStXGUsQmH7IOTdk4VDnUiK0s5GaFtj6z4NnzMRzc0iaQb6OL8uQQV5S2QlIiQa8FiWZ0RXQoh8xwrxqFQkkic8igynM6qPepGC7R4d5GUw5luZKgzKQwzFamUzlkFqXmRayFGuXQ9QDuAHAzwzBHKv+9jmGYDzAM8wGFr307gFcCeHfV117e6Ju+EODfwDV9eQlbmb/BA+5iikObxkMJRcBlR6lMNEvRzQop6x7AT48ZpgXKIZo5ZMJ7+v6jM7BZGNgsFjx8Yk72tfTwLDVhDXtZ3cqh+UQenRrDqIEq5ZAJptbVOF8J9QWgSLoB8tNrhmEaDt7WoxwyIjDUTKC/R+0EkBIajSiHaBB7WOM6TJt2lnUGuRuN4bkkXwXet7Ycla59MzLEulTbHgVtLFK7mZ6vBEh3NUBcUNC8uHmTkEMnZxIolQkODFbIoQr5tpCSXj9zBXFysxpalUPxNAeuVG7IuieQQyZ4vo1VLGSbI7xih9q6pmTsT1ypBJuFkRyuMQwDh82iTTkUzyLsYYVnvx7wyiHOVM1PM8tZbI54EHSzCHtYIZ9MCnLPNU+DRALN2tSqHPI5baYh441AQaIIwCVkkDX2/BYyh9TYytjGCD+zIlest6M7DFAOEUI0Zw4BPFFntj3vRfBQ01b2DCGEIYTsI4RcXvnvZ4SQrxBCviLy+ndTlRAh5NuEEHvV111OCDnSjF/EbBCanUyw0TAacrYyQP8BN5bK62oqA4BgxQZhlsNJNaLJHD7wrZcVW1yqIaXOAvjJdYfPobmxbHY5C5/TpurhKPVzPazVdBJxQgh+enQWN2yPYFuHF+NK8nuZJjgACLtZ3VX2vH1k4yiHDk8sAQBu39+LsVhG0Sa7Wvkrfm0DDeZPJHLaM4cCJrbs6YGkcsiATZ6gHNI4AaQlAnKKnPXE8ekVAMC+3rXKocHKIXtM5jCo1FamtRKckkNG2Mo6fA4wjHmUQ5OVtXawjb+uVJkl96xTqrIH+MOZlkEPbXBrxFbmslthYcwx0JuI8/fnQNhT+b/89R2XyR2SKgKohtNuRV6jcqi/AdUQwK8lZWKewUcqX0SaKwn5VJsjHowupmS/pqDCVqZXxaO3iCXkZrGc4TaMWp4rlUWt/kYph4TMITWB1ALht7HIoSzXnKzCNFcCVyprbtzbaJb/jQRNbWUXoR42qwVu1rohk9g5kaYcoPFDWCzN6Qqjrv7ZZjtcA8Avhhfw8Mk53PPChOqvKcgohwCgJ+jSHEg9s5JDj86mMoq2SuComTC9nMX0cha37O7EQJsbEzH5KaBScCeddGoFIYRXDuk4BFI1jNkmgYfGlxFw2fGGfd0AgFMztV0EayEQbyKbPIBavPT/jolsUQjvVgszrw16QA93tbYcIXOogU0etX9oVQ5RS8SijGJkPTGykILDZhFIC4rekAtWCyOb38KViGxbGatxMz23wl8TIwKp7VYLIl4H5kxCDk1V1Ks9FUVWuypySL7KHuAP3FqUGPR6NBJIzTBMJQOj9evE2GIGDAP0h/nrOtjGk0Sy963E0K4aWpVD00vZhvKGgNW1RG/Jg9GgZG1nZYizqc2jbCuT2TM0mk+j11YW9rAolonpigD0QkqxSZvDGiVqUhqUQ6v/phvj2lLkiuW6dZdmmzakOG7Ajr6RrJEbCRfJoSZio4ZtSVbZuxs7hMVSXAPKIXNtQKoxPJcEANx3eBpzKzn8yXcPydoaADpFkf548k0V2h6WsytZdAcbO6CEPfpVNc3C2Sg/9dvZ5cNA2I2ppaxsWw4nE5oMAGGPA3EdCohEtgiuWNZcYw9AyNExy3SV4sjkMi7vD+LSigLjpAI5JJc5BDQWHF8uEyR1KIcatbuaDVLKIbomZxuwz1FVoFblELUDx0xCDk0vZ9EbdNXVmtutFvQGXYJtRwxKxLxDY+vTfCIHhtFuG5FCd8ApKGVajenlDDp8DuHA4bRb4XPaZMkhaotUVA5peL5RBVNvoyoXD4tlE6wTE/EMegIu4TMectvhYa2yrVpSgb7VcNisqu215TLB1FIWfeHGrilVdZtFcUzzsKj9e0u7B/OJvGyWolxbWaOB1IspDn6nTZYsFQMl3cyW56QXUopNqhxqlKhJ5YtgmFXLmByocmijxFRQ5LgSXCJZb6zV0pByiJ67tGcO2ZHKN95EdxHG4yI51ER4nbaNGUgtlTlUmejrOYTlCiWk8kXN0xOKXhVZEq3C6bkkGIYPPTz4mcfx02Oz+PX5mOzXKDfmWDVNAAFgdjkntN3oRcTLmsY6QnG+Qg5ta/diMOxGsUwUM0UAaetT0G3XdUCYr9TY6zkEuuxW2K2MqQgMQggm4hlsbfeiw+dEu8+BEzMrsl+jZNlrhBxayRZQJtpVLRtNOZSTUA71hfgsshGF5h05LGU4uOxWuFRsoKsRcrOwMDANcTy9nJMkCgYV1IUFCXsDhXblUA5tHofiwV0tOv1OUymHasOKO3wORJPS708gN2UCqT2sNuXQ2WgKAZddCMTWi5CbNcWAaSyWXqN6YxgGXQGnoHoRA09qypd5aFEOLaTy4Eplw5RDZiEx6L3ZUWUrA+RDqVefa/XXl9aeNxJIHdGxZ6AqjbgJoxT0oFASdyQIRI0BmUNeh61uYCAGSiBpbUw0O8QyhwD+vm6IHMroUw55nTaUymTD2fc2Ai6SQ02Ez2nfmMohCYbf67DBatF3wKWHCr2B1F0BJyzMqszdTDg9l8RbLu/FHxwcEP5MaeOrJvdCS3ZArlBCLM3pbiqjaPOYz1Z2dj6FiJdFyMNioLKhlpPf01YXqevrsluRLZQ0TzNoJa0egpNhGPid5mrVSuSKyBZKQkPSri4fzkUVshkUiDd/A+RQTKflqdEsNLNhVTm09hq7WRs2RzwYmpVXd8khnuY0X1+Arx8PexymsZXNLGclLbSDbW7ZXDKlQGqHXVsg9VgsjU1tjR2wq9EdcGq2FDcLU0tZISyZot3nkLeV0UB1mUBqp92iqbr6XDSF7R1eVQc/Oei1FBuN8VimzhLZ6XdiXqYFriCTU0jhsKsnh+gz1IjMIcA8JEatrUwNOZSvXFux+8tmtcBpt+jOxFlI5XWRmlSlYRbSrVFIZWattsE1rhzyqczbpI1eG420EGsrA4CIz9FQjp1eO7qZGiIvYi0ukkNNhM9hQ2qDHEiqIbUJ4Q+4+hoUqI2nTefkz261oDvgMh05tJjKYzGVx6W9AXz6LXtx4pO3AVBWMXAlImsrc2pUDs012FRGEfayiKXMFYJ4NprE1nYvgNXgTvlMEZqLI0EOsVYQoj3Yl4aha7XkUDSiqmkGoom1OR6bIx6MLqRl/+2FQGqJaxtw8e0UepprlnReX0E5ZBJbQ6OQy2zZ3e3HqQbIoaU0h5BHm22PwiyqwlyhhIVkXsjBqcVg2IPlTEHyfuAUgn0p8ak2kHp0MS0cQI1Ap9+JRK7Y8jyMUkWhWascavc5VWUOySmHeGWs+oPZuWgK2zq8ql8vhZCb1WUpNhKJXAHxNCfkDFEoKcbU2MqcGq4rHQTQZ6temE05NJ/Iw81aheyZTW3qlENyNkgPa9NvK9OpHDJbllOj4En5evLNJzQ/N/b8TuYKqlv3LBaGb0zcaJlDBXHl0J5uv2JkgBwasZUBjf/bXoTxuEgONRE+5wbNHJIJPtR7wF2sqFH0TK0pekMu2arXVuBMJW9oV5cPAK+uctotyuRQsQSHknJIw+Z5pjJpblw5VAlBNElwMiGEnxp38hvY7oALNgsjZFCIoaCQOUQfnjlOGzkk5LXoPFw3oqppBmiuSVcVOZTMF2UJADWZQ4RAl902rnM6tWp3Ncc92yio8kJMnbWn24+ppaxuldRimtNNbka8DlNkDtEDtJStTEldyBVL8oHUNvWZQ6l8EdFkHpvbjSOHaCNXq61l84kcimVSZzvibWWNVdlrUbjE0xxiac4QcqjNy7Zc4TJRycMaDNcrh6LJnCQ5zxWV28p4xbG663oumoLTbhEs+3rhZq1gbZaWX1eK+USu0vrHP/9drBU9Aae8ckiJHHLoJ4f0KodCG4wcklLLU3VJo8HbiWxRU16hm7VtvMyhQn0gNQBc0hPA9HJWd9vzcqYAq4VR1QRXDaP+bZsJQgj+69djG+ZzphYXyaEmwuvYmEnseRn5sl5yaNWSo58c6guZTzlE6+b7qzbQaq5RoURkcy+cNqsm2f3ssjHKIaGVyCTWsniaQyJXxJYIfzCwWhgE3axs+KWS9clZmWjnNJBvgH5lC0XIbceyidQt9PDZFdCQzaBAvPkbaDTUK122WS3wsFZTEW+NgF5jp4jyYnc3T0Kfnk3q+t6LSX0HFYA/WJtBOUTzxnokwvcpuSKV31IoEYW8N/Xk0Fjls7LFQOUQJWtbTQ7RZ20tedDucyDDlSQPy/liCXYr35AjBaddfXAyVbhs7/Sper0cQm4WuUIZ2RYeCmldfb1yyIFCiUg+21TZymxW1c+1c9EUtkS8sMj8O6kBwzD8sy1tjvU3mswLeUMUg20ejMvkkOULZVky081adREJXLGMZK6oa9/rMRnp1ig4iZxNu9UCl93asLpkJVsQVMRq4GatGypzqFQm4EplUVvZpb1+AMpttFKIZziE3HbNawW1+aVMTA4dn17B3/zkJP77xclWv5V1xUVyqInYiJlDhBBeYmtwpgidOOu1lQFAX8iNuUSuoWA1o0EnqB3+1d9LDTkkFfpNoVU5REmq7gaVQ2aTMtMMhurfK+CyyZIPSuoW+vDUekBYznBw2i2aW0coeFLLHNcVqM5m4K8ttReMLkrnDhUUAqnptVV78KtGvAHyzWyWvUYgd/9SklTOVikFQggWU/osDgCfR2YG5dDUsjhpQUHv53mJ0GQpewOFlkDqkQo5tMlIcqiy1jWSEWEEaO5R7TOFkotS1jJehSG/RtLgZDX25fML1P7U+DUOV1SfrTxwj1VIigGRzCFAmhTMcEVRwrgaDps25ZARaiygYtczybMtWlEOVaPd55AltjmJsGQKr0NbgDrFss4gX4An3cJu1jR2vUYhl/Xmd+mLq6iGLnJoAymH6J5LbI24pEddG60UltKc0BitBau2MvOek18cWwKAhuz6FyIukkNNhNfJK4f05GuYFUqZIn6XvlDdWJqDw2YRaiv1oC/kAiEwTVgnwG+QfTU1pUEXq0I5JJ8f4LRZUSgR2cr2akzEM+j0O3QTFxRtXnNVVq82j6xu9oJuFstZmY0eraWVyhyi5JBGAiOeLuhWDQGVljQzKYcSOQTdduGe6Qm6wFotwoFXDErrgxZLTi3iKX1NWkBlXdogvnYaqG4TWR/otdFCHFOk8kXki2Xd6s2Ij0WaK7VUdQHwteYMs0qi1KLNwzerSYX7Kq29FgsD1qrO9kSVQ5vajCOHaJbSdIubOSl5XHud6VosZS3LFUqyB22AVw6pzX0bi6XBVjIHG0XIBCG/E7EMIl6HkIlDoURqxtMc2jzyxK7Tri6rMMMVMb2cNYwc4lWF5tgzLKa4ukZRNSHqcqost8OGlI42LUqYac1qoQh5WMRNoshqFHJqeb/TjmS+sd8zkdNGDnkctg1FDkkVWQD80DfidSgWjkghnuZ03cMXQpPsS2NxAMAphabejYaL5FATQSVzelsMzAi6WTM8cyiVR8TraKhthAZjmslaFk3WT6l4dZVyW5ncZoSGeao9BE7EMhgMN35AEWxlJrCPAEC0csDr8K0eUIIueZKFK8m3lTl1qluWM/qmJxQhN4tUvmga5dvcSl6wsAC8ZW+wzY1Rmap0JVUWvae1hn0D/EZabybZRlIOyVn3BMuTBsspxWIDbXsAEPHQtaG1h8CXxpawp9svqU6xWS2IeB1C4HotlJoiAf4+VvM5HV1MozfoapiUr4bTbkW7zyGbq7YemF3JwcNahekvBT14yyuHlBUu9LVKmIxn0Bd2ydrU1MIMytjaGnsK2q4ldd/GVYTJ84os5efaSGWNN4oc6vK7Wm6DBPhneipfrFvjIl4HsgU5K6SSckifBYneZ3qUQwCvdDOT2rgRFIplsFbxddKns+iGolQmSOa0Zg5ZN9bZTRiKSl9jrQNRiqWMviKLoJv/GrlhbitBCMGLFXJoZDG94QLK5XCRHGoiaNiWmSVzWiEsMDKBs4lcQXOb1dRSVnLSqxZ0cmiGTQjFfCK/hrgAKtdIsa1M3lbmrGxU1OYOTcQzdZXDekAnqzGzkEOVKWr1JFCJCCgo3MNOncqhpYrvWi9CJntQzidywrSaotPvlD38c0X5zCFqR9VDXizprFkH1H3mLhTIZWYJxKYO5RD9d9VLDgmqwhYerHOFEl6eWMLBLW2yr+NrwWUyh1SQF6oO2QY3lVH0h1yYbHH5wnwiJ/rMpoSyVDlEvigeiloNR+Xv1awT47FMXXizXtBDeisP3BPx+hp7YPUZN7dSv/6WygTL2QLCCsohh82ias9wulKkscOAHCeAz/+KJvMo6hgKGAm6NtWqI+n/lnq25YslhcwhfYHUSxXVj97nWmgD2cq4UllaOdSg8pfmFWnPHNo4yiElxTy/Nuj7fePpgq572Gm3wmGzmLZJdmopi8UUh1fuaAchwPCcvizHCxEXyaEmwlshh8weSj0Zz+AHL6kL21JinwMuOwolovlgPWbAJppO1qRk161ANJlbY3kCNGQOySqH1NtHcoUS5hI50Q2nVrA2CwIuOxZS5rjG0WQe/hrbXsBtl33YCOoWiY2IEEitWTlU0D0BBCCojsxiLZtdya1RDgH8tV2WuXc5hbBvqnjTpxzSf33N1gTXCOTUWWwD5NtisjFyiH5dKy2nhyeWwRXLuFaRHHJI2sqUiHmA39Qq2ecIIRhdSDWHHAq7MRlvrUJ2dkWcHAq6WfQGXTghkV+RU7DoAKvKIaU1mBCCiVgGAwaRQ9Qa0SrlUK5QwuxKTlTl67BZEfGymF6uJ92WMxwI4S2TcnDY1VXZD80m4LBZDLt3uwJOlMoECy1WFdI1rtZ+R3PWpMmhsvDsEoPXoa/ZqpEcPYD/924lGS+H/3x2DO//1kuqX1+QWXcbzW+lz35NtjLWhkzB3Gc3LVAqC3HYrcjpUK0TQiqDUX33sNniFKpBy1fedFkPAGBIZ9HHhYiL5FATsRq2Zc4bn+LjPz6Bj/3wGA5PLCm+Vol99ju1e0jTtO63wY2Im7XB57Rh3iTKIUIIool8na0s4LIjlS8KhzwxKGYO2dUrh6j9wKgNdIeCP389EU3UN48EXHYk80XJKaViIDVLbWVaq+wbVQ61Pu+CIpkrYDGVrwvSDbpUEm9StrKKbFyPdS6eziOs8/puJFtZQcYWqSUPpxaCcsin86CiMH1fDzw/GoOFAa7aHJZ9XUelFrwWpTKf46ZkK1MzyV7KFJDIFQ0No6YYCLsxu5KVfYY0G/MrOXT5xXN+9vYGcHxqWfTv+IO2ciA1fa0cljIFJPNFDBiU6eR32WFhWrcG03DtLRLh2ts6vDgzX58LsqQy2Fht0PfQbAI7u3yGWPWA1dDyVoeox9K0+GTtdVoNURf/d+cUbGVu1op0vqhZMU/vs6DO51rIw+dXtlqRJYbvvTCBR07Oq/osFUtllIn0vsHvlC8ZUYIecsjt2JjKIan72GmzIK9DOZTIFVEqk8bUbya1RtJij2u3toG1WjAel45U2Gi4SA41ETRQ0My2spfH4/jlmQUAwN2/HFF8PVfiFw+5zCFAGzlE2zmMCO3k7QLmIC4SOT7gtdaaE3Dx94Xcw05ROWRTrxyiC1xt+4ledPgdkmGj6w2xTKcgrUuX+NwpZQ7paSsrlQlWso0HUgOQrCpeT9DMidpDSrCiHJLaBK+qspQCqbVvQpbSyrYJKQRcdmS4UksP00ahoDQBVGl5qsVCigPD6A9HNUMe2dBsApsiHsVDQKfPicUUV0dSKqkKKfwqMjBoq5+RNfYU/SE3ygSYXW7NYbtUJphP5tEVEP887usPYCyWESWS84WSYIuWgtrcN/psM8pWZrUwCLpbp8Y4XZlM7+4Wt3Pt6vLjzHyyruSE2ryVlEMehw2EQDZolxCCodkEdnf5tbx1WVDLf6vuVwqpXDUhJ0tGOSS3H/M4bChWqsK1IJ7m4HfaFMloKdADuZyatxWIJnKCNfHwpPLQWW7gAayS8VrJNwpd5BBr21CZQwWFvFinTuUQJf/07n0DLnk1eisxEc+AtVnQ7XeiN+TCVIvVuuuJi+RQE+G/ADKHHjw2B6fdgjsODuKRk3OKvum8kNcivnkWyCENB9yxRX6DtynS+Aavy+/EnESWxHqDBkfWNmME3PIEGiEEuWJZtpaW/p3aTAbAuA10h88pBEG3GtFkvTJr1Z4lvsGXy2wB9OW2JLIFlAkaCqQOCvdF66coVE5be7ANuVmUykTSKru6yZMmLgDtyqEsxweJ1k581YKuSxshd4hWrUuF9ztUNhLVYjGVR9jNiragqYHTboXXYWtpHtnZ+RR2dCjnpFALcu1hUGltoFCjRKMEazNsZX1h/rA9IRNKXS4TfOmxs7j/6IzhPz+WyqNUJuiSaAjb1xsEAByfrm94yRmoHBqXqH1vBJ1+Z8tyC4fnk2BtFslB2a4uHzJcqS5vKq7ygOZTEXUQTeaxlClIElR6sKocau3hSiDRap4jlGRZlAxRl88coi27aY1Kk6UGShYAc6mNq/HMuUXh/z80Lq4grIaS5cnntKFQIrqea4BecsiKXKGsuhHY7OAUVN0OncohwRqpI5Aa4Pe9Zs0cGo+l0R9ywWJh0GeCnL/1xEVyqIm4EDKHzi+ksLXdi6s3h1Emyk1fq3WI0plDQOuUQx1+6Raa9QZV14gFUgPS1yhf5B9Inpoq22rQ668mF2cinoGHtTa0CakGtZXpneIYBUIITw6J2MoA6WlaQSE02alDOSTI+o2wlZngQTmykIKFqT90CddW4j0qBdazOsmhmcqhoieoL7T+QqhMVYtCSd72xG/y9GUO6c0bomhlZXWuUMJYLI0dXSrIIXpYramDV5pgUwRU2MpGF9OwVTaVRqM/xH8upcihfLGEv/7RcfzzY2fwsR8cNbzZjNqDajPJKC7p4VUnQ7Nrc4dyhRJynLoqewCKh5WJmLGWaQDoDToxvdwaEmNoNoHtHV5JgnZn5d4+XROMSg9oSuT5qppd+t49PsUTent6AuretAoEXHY47ZaWl4UspvJws1a42bV7K7vVgpDbLp05VJC3ldG9mtZQar5hTv++rM0E7Xpi+PX5GMIeFpf0+HFIRVwFJeWlrjGNq9A73KEqT79Lek9dC0/lHtHb4GU2KO3NnDqHSssN5mYFXWa2lWUxWDmX9ofdssOYjYaL5FAToeZB3GqMLKawpd2L3soGVizssBr0wOxmxckhuvhKWXrEMLqYRqffIUuGqEWXn2/FqJVdtwInKlPT2smx0kGVbjA8rBw5pL7qdyKewTs4FU4AACAASURBVECbR1JpoBXtPge4UrnlB+1Elq99r8t0UlBmFUplMAwk8xRcOqrsKaHTiK3MzVrBWi2meFCeX0yjL+SuI4GpMkru2sqpWvRW2VM7glTGiRLoutTqe1YMxVJZ0wBBqWrdYbfobivTmzdEwQektoYcOr+QQpkAOzqV67e3tfOvqc1vUZLeU6gJOB9ZSGMg7NatxJJDb9AFv9OGYyK5PtFEDm/9t2dxz4uTuOPgIGwWBp97ZFj2+5XLBM+NxPD02QVVP3+kYpmTImWCbjvcrLUuY+a6zz6B4fmkcluZWuVQPINOv0Px+2lBT9CFmRaRQ8NzSeySsXPR9rDa1px4Sl12jXDIltmf/XokBtZmwb4+48ghhmHQHXC1PnMolZck0Np9DklyiCupJIc02pCWMpxuGy+wmjFlNnLo9FwSl/T4ccVAUFQ9WAulrEKqeNPbWKY3cwjQTviZFZyC5d9p19dWFm+wcS/okY8qaBX4soO08IzrD7mxnCmY+jxvJC6SQ02Eh7WBYYCUSW1luUIJU0tZbG33CNNNJeWQQFxIEDl6JvSTcePaRroCThTLxBQNDk8OR7Gry1fX6EJzU6TsF1SaLEeWqc1kAHhp5EDYuOm14M9vce7QVIXI7Amu/d2UrI1ciYC1WiQJDLuVgYXRFki9rDIQVA4Mw/CZPunWP3xGF9Kioaj08CGlHFIKUhcOfRqVLRtVOTSznMXrv/wM3vT/P6Oa0KYEnBQcNqs+5VCKa1g5FPE6WmYrOzPPH5h3qqjf7gu54HXYcHpurbKFPt/kLL2AugyrcwspbOtQJqr0wGJhcGBTGC+Oxdf8eb5Ywjv+/TmMLKRx9x1X4lNvuRS/c6Afj5yck733P//oMN5x93N419dfEIYacjg5zbdZbZUITmYYBl1+J+arVLy5Qkk4xJ6ckf8ZajP1JgzcO1D0Bl1I5IrrfghYSOYRTeaxS0b55nHY0Bdy4Wx0LakZz3DwOWyy1iegylYmsyd99nwMBwZDhhJuAL92T7XYlhFLS69xEa9DMi8tX5C3Qq4OlDSWWKQbazilB/K4CQZKFKUywdloEjs6fRgIu5HMFRVJnUJROXMI0DZ0rsZKtgC7lRH+ndTgQikUUgsl5ZDDZtVFDgmZQ3rJIRcLrljW/NlpNuJpDmmutEoOVc5QrW4JXS9cJIeaCIuFgZe16V7Qmo2xWBqEAFvavWj3OuCwWRTJoYyCcsinQ/45s5JFb9AY8oJauOZbbC1L5Ap4aWwJN+3qqPu73qALFmY1L6EWdPrkkbjGgPrJarlMMLm0Ko00AvQatzqUWqqFLShYn6SbR+QyRRiG30RokROvKof028r4r2+9xLZUJhhZ5O2mtRCurUQuUl5B1dKwckikOlsNzEoOfe7h0xieT2JkIY2jEu1OtVBDwOkJpF5MGWErk56+Nxtn5lOwWxlV7WAMw2BHp7fOnkNtL7UlArWgeYJSzzmuWMbYYlpQejQDV20K4/xCGrGq6/31Z8YwspDGXe/cj9dc0gUAuH1/L7hiGQ8dn5V8r997YQI3bI8g7Gbxt/efVJzinpxJYFe3X1YV1VmT/1f9TP79qwdkv7/aNk6+xt7YTCc6bJhZ5/Dkh0/w/z7Xb4vIvm6wzV1nE1RrT/Iq5GDG0xyGZhO4bmubmresCds7fDgzn2pphstiiqursaeIeMVbWAkhyBdLsnsGh3C/ql93CSGIpxvLHBJKLEwwDKWYjGeQK5Sxs9MnfJaUgsiVVC2N2spWsgUEXHZN6nmz7hn0Qsm657TrbDlN52G3MvDpdH4IA0cTZG1WY5yWHbStKocA/MbkDl0kh5oMn9Nm2swhGpi5tZ23HPWGXIqTnVVySHwhsGqsUi6VCeZWcnXqD72gwYdKJFez8fSZRRTLBDeLkEOszYLekAtjMfFrraTOAtQrh+aTOXDFMvoNnK52VMJcxaqg1xOUwaeLNsXqQ10qNLksuQmhcLHayCFKRDUSSA3wk8BWS8RHFlLIFcrY011vbwgoKIdS+aJgpxUD3WBr3YTMrmQR8bKKk3Ep+E0aSD08n8KBwRDsVgYPnZhT9TVKmUN6NnkZrogMVzJAOcTfv604AJ6ZS2JzxKO6+WdXtx+nZxNriBBqe+mWCFqmoJ8DqcHPWCyNYplguwqLm15ctSkEAHhxjM/0WMkW8K9PnsOrd3fgxp2rz529vQFsaffgvsPTot/nidNRLGUK+KPrN+PPb92Bl8aX8PxoXPS1AH+oPTmzIuQKSaErsDbYmV7b77zvGrzvhi2yX0tVGnIkZ65QwlwiJ2zejcIqObS+e4j7Dk9jV5cPexSu60C4nhyaXc6pIhno8C6VF18HqRLt4BbjyaE9PX5kK7lgrcBKtoCJWFoIo69FRILYLpYJykT6UA1UNZxq2DPE0hyyhZJkbpcaOGx8CUDcBGpjiuGKgnNHl09YR5U+S5xC0Y1AxusctCeyBWEPoBZBhXzFCw1cUd6657TzyiGt9q6ppSx6gi7dsRUhgeA013WmeXYCOVQ5Qxmd32dWXCSHmgyv02ZaW9nIAi9Nppk4fSG3CuUQ/7tQP64YtEyuF5J5FErEMHJoR6cPNgujegrfLDw5HEXAZccV/UHRv9/U5pHcJKU5aitrXDk0YXBTGQAh46fVjWUT8Qz8TptwUKOwWS3wO22SCgYlWw6gXWIbT3OwWhhhE6MX7T6HZJ3ueuFExfJxSa8IOaQwTUvmioJ1QQwMQ8ljbcqWmZWc4oFdDmqyNtYbhBCMLaaxry+I67dF8OhJdeQQp8ZWppEcWkyqC7RVQsTrQJlIq/aaiTMVK4Na7OryIZErrlG30DalbgWFmtLn4Gwly6hZtjIA2NsXgN9pw0+P8W1k335uHKl8EX9+6441r2MYBrdf0YsXRuN1w58sV8IXHzuDTr8DN2yP4G1X9qHNw+I/nh6R/LlTS1kkckVFcqjT70Q0mRPskpQoUqP+o1X3csoh+rsYbSvrE/IX148cml3J4vDEMt58ea/ia/vDbsTSnDB0/P6Lk3hhLI5XbpdXHAHVOZji6+CpmQQYBooElR7QYUNtSPl64d+eOo9MoYTfk1CtRXwsMlxJ2ONSCCUssu2x6gLUq3EuaswaEfa0Xm1cjbMVcmh7h1dwBCh9lpQyh7wq7JByoMohLTC7cmhsMY0Pf+cQ/vb+k6r2UwIBJ0FyOmwWlMlqKYNaTDVo7Q24Ku3CJlMO0fDpvsrwOeS2w8NaWy48WC9cJIeaDJ/TjqTElKbVmIxn0e5zCCqg3qBLReZQRTkk491lbRbVbUT0odFrUKOLi7Xikh4/Xh7np6mlMsHXnhnFJx84KRAlzUa5TPDUcBSv3NEuKbvf1ObB6GJalKVXoxxanawqB3YCxm6gvQ4bXHYr5ltMDk0uZSQrjDdHPEJoai04BVsOwN9HWgOpgxply2Jo94lL29cTNE9km4itzGGzws1aJQ//KQVyiP8e6tcHitnlrOKBXQ5OuxUOm8VUG735RB7ZQgmbI25cs7kNY7GMqkrXglIgtY5KWkpItjeoHKJ5ZOsdPJvOFzEZz2oih7ZXKu8pkRNN5jCzwiswlPJWKNkoSQ5Fk2AYiFozjYLDZsXbD/Tj4RNz+OWZBdz9yxHcuLMdl4i0TFHS4SdHVmvtCSH4+I+O4/RcEp9722WwWS1w2q34w+s24bGhqEA61YLmBYn9nGp0+R0olIiQh6LUcLbmd1OhHBqnTWUGK4favQ7Yrcy6kkPU3nigogaTw0DNBPtbz43j0l4//vSW7Ypfq0QOnZ5LYHObR1IZ3gi2d3phszA4NbP+5BAhBN95fhyv29uNS3vF71u69lGinII+q+RUq3qUQ0aRQyEPa4qMTYqz0RR6gy54HDa0+xywWRhF5ZASOUQVx5wOuzTAq7TaNNr3ggrFJq3G/Udn8ODxWXzz2TE8MRRVfL3SNXaqWHPFMBHPCASKHgjX2WQKrfFYBl1+p3BdGIZBv4hqc6PiIjnUZHgd5lUOzaxk0VN14OoLuRBPc3WTk2pkCkWwNots1gCvHFJ3+KMPDaMyhwBg/2AIL4zG8U+PDuPLj5/Fp356Ct98dgyffXjIsJ8hh+PTK1hMcbh5V7vkawbb+KA+McmqlrYyJQJjrFKnbBT5BtBF0tXyWseJeKbOUkaxrcMnHPpqUagEUsvBZbdqDqRWaopRg3afAxmu1FIr6smZBHZ1+SQ/40GXXchYqoWSrQzQRh5TzBpgPQ247KbagFDycnPEi0srKi2loF6A3+TJtWk5dFTSUpVdo7YyetA5FxX/7DUL9OdpIYeoQmR2JYtz0RSu/r+P47vPT6giIQMKNsWz8ykMhN2Gh/rW4l3XbkKZELzr6y/AbrXgE2+8RPR1/WE3rt4Uxo8OTwsDia89M4r7Dk/jo7fuwKt2rD6rPvCqrTgwGMJf/vCY6F7g5EwCVgsjG5wMrCqEqGJobiULv9OmqpVUjXJovAmqWIDPiuwKONfVVna+cv+qIRNryaHlLIftHdLrdTWsFgZeh02SHBqaTWJXd3Nyshw2K7Z1eHGyQg49PxLDd54fb8rPqsVCKo9kroirN4UlXxOhRRuptcQ2PSzLrbmuSj5kllO/7p6LpuBhrQ0NPQAg7LabLnOIWnGslc+S0rCAU2iJ1JtVSBFP5zVnO1ELplltZcemlrE54kHE68D9R8WJ/GrklZRDOkLVU/kiljIFIaxZD4TcLJNd58l4/fC5L+S+mDl0EcbA65R+ELcatQcuaheqnZxUI5MvyQYlA9oOf3QD1ugDshpXDvLTt3954hy+9PhZXNYfxIdu3IqHTsyty6GFWtqu3SIt86ZWvhMih0FVyiGVtrLhuSS2tntV53CoxUDY01IGvVwmmFrKSiqitnV4EU3mRVsylJQXAJ/bkuW0KIcaC5ak6GhxExwhBKdmE7K2goCblc8ccsqTZFrJoUSugFS+2PAaEVBRP76eGFvkPz+bIm5BhXFSxVRdMXNIh3JIIIcarLLf1OaBzcIIzWHrBSHnQkPGT6ffCYbhg4ejVdYyNfZFv4LlYGg2oao1rVEMtLlx7wevw/9+/W7c+8FrheeKGN5yRS/ORVPCPfaTIzPYPxDEn9y8bc3rWJsFH7ppKzJcCUcn659PJ2cS2NbuVSS+aKg3DaKe1WANtVktsFoY2Sn2RDwDr8NmyLpbi951rrM/v5BGyG1X9bvQZx4dzqxktFlmeHKo/r5N5YuYiGewu8t4SxnF3t4Ajk0to1wm+MdHhvHxH53Ay+NLGJpN4CdHxDOxjMBoJV9TrIGTgiqHFmr2v7T5US5zyGlT3x5LcS6awtYOb8Nq45AJcgqrMbWUFYh3gM/wUraVybeVUdWW1qESUB38rW3wYbUw8DltptozVOPY1Aqu6A/iDfu68fjpqGKrGr3GUvex2oFzNaRKYbQg5DanrWw8nq77vfi8t6zmXKYLERfJoSbD77QhacJAakIIZpazazZrdGq8mJY+mKa5oqLkmM+8ULfAzCzz00SfwoFSC16xLYJrt7Th7958CV57SRf+71suxR9dvxke1oY/+e6hpqsHppeyYG0W4aAvBjphv+NrL+Dxofk1f6cmc4hhGFX2kdNzzZkEDra5MRHPtGyRpEHbfRIPpe0yCgY+kFp+Q+bU2Fa2nCk0HEYNrNpyWkUOJbJFrGQL2BKRPmSH3HbJjINkTlk5pEVZCKw2nXQboRwy0UZvLJYGa7OgJ+BC2MOiJ+AUJYtroZg5pCOQWsgc0riBrgVrs2BLu2fdyaEXR+NgbRZNrYyszYKI14HZleyaZ3RPUINySGRDnuGKGI2lm5LbIoYrBkJ43w1bFH/31+/tBmu14L5D00jnizg1m8B1WyOih9P9A/yA5dDEUt3fnZhWDqMGqpRDFXJoLpHT1DbIP9+k7+OJeAb9YXfDh2sx9ARdmF7HbImRBfF2SDEEXHb4nDZMxDMolwmS+aKmrDupkpThOZ403C1SRGAUrtoUxlKmgJcnloR76857DuPtX/017rznSNMGTiOLPDkkR54K+9+azL+8CluZk+WPUlptZWLWba1o87CIpfOmOLDmCiVEk3n0Blf3ZWqI1oJCzTp93ukhh5L5IgolotlWBvCqFjPtGSjmEzlEk3ns7QvglTsi4IplnJFQylOoCaQGtJWFUIJaSsGvBoLl30TKoVyhhPlEvk6V2h92IVsomcrG2SxcJIeaDK/DhkS2YIqFuxqJLN9OU70Rpg/HWEr6xs9yJckaewptmUPGNZVRBN0svvfHB/GuazfhK3dciUt7A2jzOvDVO67EuWgK//rUOUN/Xi2mlrLoC7pgsUhvWgfbPPjGe64CAIwurg2mTueLsFVa3+TgVLCPrGQLmF7OYlcTJoEDYTeyhVLLSAya0SA1nRfsLSIPTK4kX2UPrDY3qMVShmu4xh5oPTlEJbNyMmEaNCuGVL6geFDRqhyiIcE9G0w5NLKQwmDYLawTe3oCODGtzlYmnzmkz1YWcNllrRNqsb3Tp7hRNRJPno7iBy9P4R1X9cMqs+aKoSfowuxKbs3GVE3TmtNuBSuRYTU8lwQhzT1k60HAbcfNuzpw/9EZHJpYQqlMcKVExk3QzWJbhxcvja1tLVtI5hFN5lURX+1eBywMML9SrRxS/xl22q3IyWYOpQ23lFH0Bl2YS+RQ1GljUYOVbAFffOwMookczi+kZVUt1WAYBr0V8irFFUEINDUxSanZnxvh/6339clnSTUCmqn0T48Oo0yA//Vbu+Bz2oUMLyX10GIqj396dFjTsxng91iUiJcCDeOvJYdWM4ek10bWagHDqFddnF9IYS6RM2Rw1+5zIFcoC0PFVoLax6qVQ51+J+YTOdkzkJLliWEYsDYL8jo+j/Q8o0dhaLY9A8XRSd6dsK8vKAz45xSteyVYLYzkM9LZgHKo0TbkoNtuKvueUHZQYysT6ux/A3KHLpJDTUaHz4l8sYyERK12qzAjtLKsLuJSD8dqpLkS3AYqAxaSOUF+3mxcvy2CV+1ox0+PzggNKs3A1FJGVcbPjTvaYbUwdYtihivB47ApTkQdNovsQj5cIVCaoRyii2arcodoqKXU79YfdoO1WXBuQUI5pCpzSN1DkhCCpXRBkMc2glVp+/oG+lLQh6JcwGCH34H5RP2kslAqI1coq8sc0rDJm9XQciQHv8suqvRoFc7Mp9Zk5Ozo9GI8llEkJ4oKmVlK64IYFlN5RBpsKqPY2enDRDwjm11nJL7x7Bj6wy789et2a/7ankq2TLWkXSqwthZ+p100c2holl9395iMHAJ4a9liKo8vP34WALC/XzoA+cBgCC+PL615VqoNowZ4a1jE68BcIodSmWAxlRfIbzWQUw6VywSTS1nDa+wpeoMulAkw3ySSnhCCj37/KL742Fn87t3PYTGV1xRe3hN0YaaK1NRCDvElKfWfzSdOR7G3N4COJu7HqHLnuZE4Il4W/+OGLXjozhvwzF/dhGs2h3HfoWlJEqFcJvjdr/4a//LEOfz81Lzoa6QwspDG5jaP7MDObrUg5LaLKIeUM4cYhtG0Z/iPp0fB2iy4fX+fqtfLIeJt7UCpGqv7h6pzhYdFoURkHRRCC7LM4Nlh1Z5VCPB5Q4C+Js6gizUlOTQ0yxce7O72CYR7deumGHg7upziWHsg9dRSFl6HreHBaMhtrsa9uRX+nqktTxDq7H8DGssukkNNBl0kzRZiJVT2VimHKLMekyGHMvmioZlDC8l8wyGoWvCGy7oxs5ITlcsbBd5zrbxpZRi++rzWa5tScY0BZeXQaSoTb4JyiE5sx9epAa4Wp2YT6A+7hIljLawWBpva3HWqLIAnG5Q2Ci4NtrIMVwJXKhtiKwu5WVgtTMvq7Cfj/LogJxPu9DnBFct1pCYN3vcqKYc0VtnPLmfBMGiYRA57WMRSnClUnBmuiMmlzBpyqD/sRrFMhLVZCoVSGTaZTZ7TbkWxTDSpHnhyyJh1mFqOnhpeMOT7yaFQKuPlsThu3NGhK/y5O8Arh5YyBditDJ75q5vwjqv6VX1tb8glur4MzSbgc9jWHJDMgpt2tSPgsuPFsSXs7Q0gILOpv2ZLGIlccY3VkeYVqbXMdQWcmEvksZzhQAg0WTt45ZD4PUxtxY1OrKVA1cxGWssm4xm85xsv4APfehnv/9bLeGxoHu+4qh/pPF/ycUAmLLkW3QEnZleyAtkt9RwUg89ZnzkUT3M4PLGEm3d1qP4+esAwDG6/gm/O+9I7rhDIGoZh8Nb9fRhZTONIRRVRi58PzeN8JTvo2fOLGI+l8Vc/PKaKFBldTMlayigi3vq20LwK5RCgfs+Q5Uq499AU3rq/15A1lxKuckPd9QJtO64ejtJzRVzGkZCpqJ5cMvteVqMdnYIqh/RYpgMuu2QzaysxPJ/AYNgNN2tDwGWHw2bBnMK+gSvKK+apckjOylsLvqnM1bC1N+CyY9lEJBxVxtcS5cJ5/qJy6CIaBSUJlCri1xszlRyPapmt026Fz2nDosIirmQrU6scIoRgMcVpmiY2ilv3dMFuZfCYiupHPchyvB9V7cEg6GaxUqMqy3BFVY0uSgqBs/Mp+Jw2dPqNv759ITcsDDDeokVyaDahOJnf1ObBWM3hbSVTwHgsg729Qdmvddotqlsb6MTDCFuZxcIg4mVbNgWcWsrA57DB75K+/6iCZ75G3URzLJQzh6wabWU5dPgcDYeq9wR5v7gZWjHORVMgBNjZtaoWWJUsK2zyFG1l2ptdxmKN1dFW41U72rGj04vPPXxa16RXC05MryDNlXBwS5uur+8JOpHhSpiIZRBwsegLqc+wubwvgGNTK2uUXuUywS/PLmBff6ApWTiNwmGz4i9u3YG3XdmHr95xpexrX7WjAxYGeLzqWXlqJoGBsFt1AHKn34n5lZwQmBvWcBiWy9QTmsqapByi5JCRodQPHp/Fk8MLODGzgkdPzeMvbt2Bz9y+Fy98/NUY/tRrhSINte9vOVMQwr61BFL7RNrKnjm3iDIBbmoyOQQAf3/7Xpz85G24ftvawo7f2tsFh43PxKrG4YklvOFfnsbPjs/CZbfi5l0deGwoird/9df475cm8ePD8la0XKGE8VgGWzvUkUO1+186yHAokM9OlQ2nI4spcMVy3e+vF622oldjeinLN5RVHarDlUFcTCbLlJJDcmcLPS2nAKrWHh22Mre9bn9uBgzPJYXBEsMw6K6Q8HLgSmWwcrlZtK1Mw+BuspL71iiCbnM1yUYrn6Xa3FiPw4a777gSb7qspxVva11xkRxqMihJMGVC5ZDNwtQRMxGvQzZsK6MikFrtIp7IFsGVyobZGdTA67BhV5cfx6fFp1ONYnq5XlYrh+rJBCEEf/HfR/DYqaiidQ9QVg6NxdLYHPE05ZDC2izoC7lxXsS21WxkuCJGF9OKmR6bIx6MV0I7KY5XMl2UchWcrHrlEFXQhAxqzWn3OYSH03pjcimLPoWQV0o21nrc6YFDKVxee+aQ+pYjOfQ2QQ2gF9TyuVY5pE5lWlDIzHJonAAupvJYSOax2yD7qc1qwcdu24WxWKYubF8vfnx4Gv/21HlM1nyeaU7K1ZvVqy6qQUmAodmEUKmrFpcPBJHhSmvCt391fhHjsQzefkCd+qgV+MPrNuHzv3OZYtZf2MPiioEQvvT4Wfzt/SeRyvMqIjVh1BRdfifmEjnhwB3RsEY6bBZJ5dCEUGOvPoBcC2gWo1jL0ngsjS88Oox7X57S9D1fGotjS8SDp//yJpz6u9vwp7dsF9ZZrc9oaiWh2XtyZH4tfE6boPKkOD61DNZm0fRvqxdOu1V0+OVz2vGaS7rwrefGcdPnnxL2zN9/aQonphN8u95gEDfubMdCMo9Smb8OT59blP15p2YTKJYJ9vXJD4QA/tmrJ3OI/70sqvYMVG0oV/qgBe0ms5V1B5ywVT2f2gRHglyWKX8/OmXIC4dOcoieZ/QEUvOZQ+ZQG1PkCiWMxTLY1bX6vO4KOFUqh+SLLPjvr+4aEyLfGKwFQZe5bGXRRB5uVnydes0lXU1TrJoJiuQQwzD9DMM8yTDMKYZhTjIMc6fMa69iGKbIMMzbqv7sDxmGOVv57w+NeuMXCoJuO7wOm+mUQ5PxLLqDzrpwsjYPi0WZh0yaK8m2aAHq28qodWY9lUMAnylxYjrRlAWfelG1kEM0t2IlW8B9h6fBlcrwKlxjgCq0pK/z6GIamzS092jFzi6fcMhdT9DAVyXl0GCbB1yxLORrAcCxCil4qUJmhsvOq1vUZFPRTZmezYcYuvwuxXDBZmFqKYN+hXu3w8cfTKI1kyqqHPKpCKTWIg+fWck2XGMPrH4mlWp11wNno6m6dq2eoAsWBphSUOMVivJV9g6NrSNDs8a3FN20sx1tHhYPHJvBqZlEQ1PBDFfEX//oOP7h4dO44XNPYtffPIz3/edLmFrK4IcvT2J3t1/3M4QShqOxNIIa1BcAcEUlr6faBvPfL04i7GHx2ku7dL0fs+HWPZ0AgG8+O4Z3fe15jMcy2sihgBMr2YKgwNEyvXfYrZLKoZHFNOxWZo0t3ki4WRvCHrZurSiXCd73ny/hy0+cw8d+eFQxQH4ilsEXHzuDXKGEl8eXcOVgCAzDKA7YlEDJcvr81WYrsyNbKK05aB+fXsHubn/D6sxG8dFbd+D9r9qCxWQeH/j2yyiWynjy9Kpy7epNbXjjvh783tUD+P77D+I1ezrxwmhMch9ULhMhvPfyfmVyKOJ11O1/1drKnHYrcipCoUcWlJvTtECwopuAHJpezgprKoVgK5MdOvOOBLlMqEaUQ27Wqst2HHTZUSgRTS10zcb5hRRKZYId1eRQhYSXA1csy+ZmUWJOreV/McUhWygp7hfVIOjhbWVmIeEWUnnZtunfBKh5EhQBfJQQsgfAQQAfZhhmT+2LGIaxAvgHAI9W/VkYwCcAXAPgagCfYBhGn/8P1QAAIABJREFUvXZ2A4BhGPSFXKYjh8Zj4sRBm5eVl3/mi3DZjTn80YdZ+zpmDgHA3t4AVrIFRfuGViRzBXzlqfOwWhjVlcpB96rXdr7qsK1m8+i0W5GV2IzkiyXMLGexyaANiBh2dfkwupjWHH7bKE6pPMxuitTnIh2bXMFgm1s2awPQJrGdWqaEoDHTBLperPeDMpUvVjzk8r9HR0U5NJ+otZXx97GaKnu1mzxCCOYMUg4JOSImIIeGZhPY1u5dQ87brRZ0B1yKYYeFUhl2m1zmkLbWkWaQQzarBb+1tws/Oz6H1335aez/9M/xpcfO4idHpjWvF4+enEeGK+Gzt+/FZ27fi3deM4Bnzi3gxn98CucX0viLW3fofp90fSQEmpVDg21uhNx2HK7Krzs6tYzrtrbJ1l5fSPij6zfj3g9eh8/evheHJvhDtpowagqaE0bXbC2NQXL29HNRPkOmmWTGQNiN0YW1tuRfnFnA2WgKn3zTJQh7WPzdA6ckv54Qgo/9kA+dvvOew1jKFHCVhlwhOVBl0+lK+LnS86waVKE4HuN/t3KZ4OR0Apeug2pICZsiHvyv39qN//PGPTgxncD3XpjAXCIntI9etTmEkIfFZ27fiy3tXrxieztyhTIOjdcrwXOFEq777BP45AOn0OV3qsqsi/hYpLnSmjB9qsBUanJ0KbTrUYwspNATcMrm62hBq63o1RDL26RZP7KOhILKFmQdbWXxNKerqQxYtWuaqUlrWKSptyvgwvxKfUlINZSKWIQ9r0rl0IRBTWUArxziimXVP7vZiCZywhD0NxWKT1ZCyCwh5FDl/08CGALQK/LSjwC4F0B1mMttAH5OCIkTQpYA/BzAaxt+1xcY+MOeuWxl4/GMqBww4nVIyj8JIcgU1CiH1B3+FlukHNpbaaM5rqI2Wgs+/dMhvDS+hH/6nctUBw0GXasVjtWHbTWNzHI1m5PxLMoE2BxpnvxxZ5cPpTLBuej6WsuGZhPwOZUDX+lkjsq4CSE4NLGEy1TIy12VB6UU+VaNqaUM7FbGsElDX8iFVL6ouuHw+NQK/uS7h/Ceb7yAZ8/LS+zlcPcvziNXKOONl3XLvs5hsyLsYesyh5JqA6k1KIcS2SIyXEk4DDWCkNsOl93aclsZnWZf1l9/yFbzrFDOHNKmHDo9m0Sn36F7Ay2Ftx/oh4e14iM3b8Nr9nTinx87gzvvOYJ/fGRY0/f54ctT6A268PYD/fi9qwfwiTdegofvfCVec0knbt/fi1fv1p+TEnDZBVtzwKXt92cYBpf1BwXlUDpfxGQ8u0buf6GDtVlw5WAI77h6AHe9cz9u2tku1JGrAc0eoe2SYQ2h/U6Z9qdz0aRAGDQLOzt9ayyDAPCfvx5Dl9+J379mAH/8yi14YSyOkRpr9cvjS/jo94/iS4+fxfOjvJXskZPzYBg+5NsI0Ny34Xm+tcirQYm0vYO/P8/M8+97cimDZL6ouqVvPXDbJV2wWhj8w8PDsFkY/Pu7DuBTb74EBzevzRaja+hwpXyjGk+cjgpqCrVrG923LSZX98BC5pAC4etipYd11RhZTGOLhmY6NWj3OVpWYkHBFcuYS+Tq9mUu1gqX3SqrHMpyJUWyjNXZVhZLc7pV3bRkxEyWp9HFNCwM1gygu/wOcKWy7DVWUg5RZZza4Y1Q925Q5hCAunKeVmEhqa1ZcyNC09iFYZhNAK4A8HzNn/cC+G0A/1bzJb0AJqv+9xREiCWGYf6YYZiXGIZ5aWGh+Q0n642+kLslSgAprGQKWM4URMMc27wOxDNcXZ1yIlfA//eDYyBEWdWiVTm0nm1lALCjywvWZsFTw8aFUh+bWsb3X57Ee1+xGW+5Qow7FUegUq9dLpM15JCaFrCg2y450aBBzGoVTHpAD0HrbS07NZPA7m6/Yk5Dp88Jh80iXIvxWAbRZF5VPolLUA4p38dTS7yUWk4SrQVUlq2UPbOSLeCff34Gv/PVZ/Hs+RhOzSbw+//+PO566pzmn5nOF/HvT4/i9fu6ccWA8uGvw+cQ6j4phMwhNcohlRNAaglstMYe4A/zvSGXoSGzejAaSyORK4raHPrDbkVFo+rMIZXy8KG5JHY2odFwX18Qx//2Nnz0NTtx1zv3494PXoe3XN6D/3x2TGhSVMKLY3E8c24R7zw4sObztSniwV3vvBJfePvlDWeqURJZq3II4K1lZ6MpJHMFnK2Q5NU5UhsJr9vbjW+852rFTLFqdAX4Z/upSqaTTYPSxynR/pQrlDARz2BbR3Ov884uH2JpTtinrGQL+NW5Rbz58h7YrRa8+fJeMAzw4yMza77un39+BvcemsIXHzuLV+/uwIN/egO+8e6r8MRHbzTseeywWQVS0++0a3r2bG33gmEgEF+PnJwDoGy1Xk8EXHZctSmEVL6IN13eg80RD+64dlPd79nudcDntOHcQgrffX4CDx6bFQiEB47OIOJ14KpNIbz/VVtU/Vwh3LmKaBFsZXb5e9dhsyKroHwghGB0IY0t7cbuy9pFWtbWG3MrORCytqmMIuxhZYmLdL4ItypHgnaVejSRQ7tOFQhttZV77+uN8VgGPUHXGqKH7o9mZeII+EBqZeWQ2qESbewyQjFPy1yW0uZQaEUvkkPqySGGYbzglUF/Rgip3dl9EcBfEUJ0acIIIXcTQg4QQg60t7fr+RamRk/QiVS+iGTeHKn343Fp4qDdy4KQ+maBB4/N4t5DfACjcluZujaixVQediujqWnDCDhsVvzBNYO499AUTs4oq4eeH4nhYz84ilv+6Snc/Pmn8CuRAMR7XpyE285PybUg4OavdzJXXBNCrEbGGnKzWM4WRHNxxiqS8c1NJIc2tXnA2iyqD3pGoFwmOD2XVMwbAni5dU/QJUwPXxjlw2uvUUEO0Y2gOuVQvZS6EfSqyMYplwk++O2X8eUnzuK6rRE8+uevxC8+dhPefHkPPvfwMJ44rS0I+MnhKLKFEt51cFDV6/mK6rXvbzVzSCGQ2irdQlQLWutuhK0M4K1lrbaVHZmgGRj1JFynn58Ay8vDFTKHNCiHCCEYj6Wx1eDDCkV1VfWVgyH8nzfsQdBtx4e+fUio4ZZCsVTGpx8cQofPgfdct7kp7w9YDYbVmjkE8KHUhADHplYE9cLODaQcahTUyrOSLWhWpvUEnZhZzqJYQySPLqZRJsD2ZiuHuqjChidRnjwdRaFEcFslT6rT78R1W9vw778cwWcfOg2AX7N/dX4R77iqH194+2X46h0H4GKtuGlXh2EZM7XvT0sYNcArOQbCbnzp8bPY+4lH8NmHTuPGne3rEkatBVQ99IFXbZV8DcMw2NLuxYPHZvHXPzqOD3/3EH7w8iSSuQIePx3FG/Z14wcfuA5vvlzdwI5GHCyKkUNKtjJWOiOLIprMI5kvYovB90K7r/XkEFWSiCm6+bgKGeVQQYVySGPLKcVcIieQ1FqhJi9pvTEez9QN9tsq962SckhNy6la5dBYLIMOn8MQeyRV7ZpBOZThikjli0J8wm8qVJFDDMPYwRND3yGE3CfykgMA7mEYZgzA2wDcxTDMWwBMA6iu7eir/NlvFOgGqVUhs7UYk6mB7ai81/kaVYCtamKj1husFOa7kMyjzeMwTHGhBXfesh1BN4v3fvMl2catVL6ID37nEB4+MccvwAxwx9eex78+eU7YQBBC8MRQFDdsb9c0VQVWDyTLWQ7RRA5+pw133rIdd79LvmYY4CfdpTKpq6UF+Br7kNtuWIOWGGxWC3Z3+3F0Ur09b2g2gZ8c0b8EnF9IIcOVVJFDAD+RoJLg50fjCHtYVXYEQTmk4kE5vZRRHUCuBpRoksspu/vpETx7PobP/PZefP3dVyHidcBpt+If33YZtkQ8+PSDQ5qyXR46MYeIl8UBlZkYPUEXZpdrModyRVgtjJB5IwWH3apaOUQnYUbYygB+4zq5lGmpivPI5DI8rFX0Pgy4+M90WoKULJUJSmWlQGr1bWULqTwyXAmD69S+0eZ14K53XomJeAZ/fs8R2WfElx8/i6OTy/j463cbls8hhs3t+pVDl1csqkcmlzE8l4LTbkG/gUTxhQ6f0y7sMyIebZvt7R0+FEpEyLagoDbmptvKKuTL6bkkvvGrUXz6wSF0+h3CvzkAfOa39+EV2yP4yi/O4/mRGH58eBqEAB++aRtu399XV/hhJG67hCepaosB1GBrxdYU8rB47ys2419/f39L9mFyuOPgIJ746KsUlXhb2z1YqgzTGIbPFXz05Dy4Yhlv1Fg5HZEhh+TUmgDgtCm3ldFh5B6DVVodPicWUvk6InU9QfcrYusfrxySr7JXPFdYtRVZAPz+bTlT0D1cUtO0tt6YiKUxUNPSSEksOfsbVyrLEpwWCwPWalGd+3M2msL2TmPWYPrsNUOd/YJQY38xc0gWDK/Z/hqAIULIF8ReQwjZTAjZRAjZBOCHAD5ECPkxgEcAvIZhmFAliPo1lT/7jQJdmMxCDk1UVCViXlHaClSbfF+tZFFK/acLkNIBcCGVR8S3fjX21Qi47fj2e69BtlDC52UyMO568hziaQ7fet81+P77r8VPP/IK3LK7E//4yDBu+Icn8ZVfnMd/vziJuUQON+vIvqCqqZVsAfOJPDr9Tvz5rTtU1a6GZPzQx6ZXsFfF92gU+weCODa9jILCvzUhBKOLadzxtRdw5z1H8I1fjer6eQ8cmwXDAK/coU5hGPasZmidnFnB5f1BVTYUehhVIlhyhRIWU5yh5JBSNs6xqWV8/pFhvG5vF373qrWV2azNgr954x6MLKTx4e8cUrVZ5IplPHU6ilv3dKo+zPQGXYiluTXXJ5bOw+uwKV5fLdkBs8s5WC2MYQ/qvb0BLGcKQg5VKzA0m8AlPQHRa70agCm+yaOfM5tMJa2W1hGhEryJCsNaXL05jL954x48fjqKT9x/UpQgGl1M466nzuO3r+hVPfXXC6ro8OtQDgXcdmzv8OLeQ1P45dkF7Oj0me6Q3WrcvIt/Lmol+Cj5U5tpd3Y+CQtjXNuTFCJeB9o8LO4/Mo1P/fQU+sMufOHtl6/59x1oc+PL77gCEa8D//zYGTx6ah6X9QfXpeqYkkNaD8zA6vDjr1+3Cx9//R7RyuZWw2a1qFqXKNG1JeLBK7ZFcGJmBQ8cm0Fv0IX9A9r2QNRGVK3CyRdLYG0Wxeeai5XOyKI4Mc2rC/cYrNLqD7tQKhNZW1GzMbWchYURt4CHPSziMgSLGnLIYdceSE3PXGrCyMXgd9phtTCmUQ4lcgUsiUSC0Cw3ufepFEgN8NdYzb6BEIJz80khv6xRUHIoboJsJ3rPXGwrU8b1AO4AcDPDMEcq/72OYZgPMAzzAbkvJITEAXwKwIuV//6u8me/UaChjEpVg+sFKgcUyw4S3uvK2oNpNQGh9ABczbyQX8iH55LYHGnu9E8Oe3r8eP2+bvzizILo7/SNX43irqfO4637+4R8EDdrw913XImf/ekN2D8YxGcfOo3/ed9xWC0MbtqpnRwSgtgyBUSTOU0PsZCn4tOtWVCzXAln5pPYtw4Bk1cOhpArlIXGIzGk80W855sv4qbPP4VUvoBrNofx9z8bQkxjgCIhBD86PIXrt0ZUZ9CEPXbhgbmYyqu+vpQAVZoE0mmZkbay1YbD+syhdL6IO+85gnafA5/57X2iG9Ybd3bgU2+5FI+fjuKLj51V/HmnZhNIcyXcsF29pZcqeWh+z2Q8g/sOTeMV2yOKX8vaLCgTqCKuZlay6PA5DJvA07yp50db9xiaWspKHh6pvFoqaJ6SQ7KZQ0JbmfL1lVORNhN3HBzE+1+5Bd96bhxffqL+Hv3Mz4bgsFnwv163q+nv5crBEPb2BlQF1Yvhk2++BJPxDMZjadx5y3aD392Fj1fv7gQAzfZjanU8W0MOnZpNYku7V1c1tVa88+Agjk6tIOhm8c13X43rt9Wvby7Wig/duBXPjcRxdHIZtzYQkK4FnX4n9vUF8J7rN2n+2r987U587LadeM2eLuPf2DqDWrSu3hzGnh4/Ts4k8NTwAt54WY/mPDK71YKQ275GOTSznFNs4AR4wk1pv3BiegVbIh5V308L6POkVmW3nphayqDL7xQlICJeBxbTnKRiN8sVFbNMHToCqemZq1tnZqHFwiDktsta4tYTdJhTO9gPuOywMMq2MkX1m92qat8ws5JDmisZpt7s8DlhtzKGN0jrAY0dEMvO+k2C4gpFCHkGgOoVlhDy7pr//XUAX9f8zjYQhOpn0yiHMqI19gAv+7dZmDoiaynDIei2485btuNNl8tLdQXlkMxCPp/IYXYlJxrKup64dXcnvvv8BJ4bieHGKnJneC6Jv//ZEG7d04nPvnXvmq9hGAZ7evz49nuvwdRSFrMrOTjtFl0BZoJSoKIcumaz+mkobVKozSc6NZtAqUywr6/55ND+SnjxofElUbVTvljCH33zRbw4FsefvXo7Xr+3G2UC3PbFX+JHh6fxvhvUBUUCfI3wZDyLP7tFfXV12OPAUiVgPa6htUJtWxl9kNCadKOwKeKpa8oBgM88NISxWBrf+x8HZeuL7zg4iONTy/jXp86BtVkwHstgZjmLj9yyDddtXXvAeXmcr+K+clB9C1FPRQ05s5zDlnYv/uPpETAM8L9fv1vxa6vJY6WAWr7G3jh575aIBxGvAy+MxvF7Vw8Y9n3VgiuWMZ+sb3ShEJSEEvLqQonfXNtllENaAqknYnzziZHkphowDIP/+Vu7MJ/I4V+eOIdXbIsIlsafHJnGo6fm8Zev3bku0u6I14EHPvIK3V9/3dYIvvO+g2BtlpY/z8wIWt/+rms3afo6n9OOLr8T52vIoaHZBPZrWKsawV/cugNX9AcRcNtl19vfv2YAX/nFeUSTedxSIcPWA/f/ib77drDNgw/fpC0f0azY0+MHwwA3bG9HuYp8eOc1+tb3iNchtJXNLGfx0PFZ/IGKLD5H5WBNCJEkpU7OJHCFRjWTGlCF1UQ8g+sN/+7qMBnPoE9i6BHx8lXliVxRNGNUla1MZQtyNRpVDgHKlrj1BCX/askhnsSSD/0ulIhsIDUAOO3q8iDPVvamRuW+WS0MBts8GF1c3+ZjMdCBb6/Be/oLDebTkm5AOO189fOsaZRDaUlbDm/hcNTJU+Npjg8GvV45GJRVcTih9b+t3kxfu7UNbtaKB47OriGHPvvQEHxOO/7hrfskpZgMw6A/7G5IQk4Jnngqj2gyJ2Q+qUFYwlZ2fIq/tmqsaY2iJ+hCb9CFHx2ZwYFNYYQ8rLCo5gol3HnPYTw/GscXf/fyNS1ul/UH8f2X+HY3NdO9cpng848Ooy/kwhsUqtar0eZhUSgRTC9lUSarsnEl0NwcpbYySvgaSWAAfGj2z0/NY3YlK9hSnx+J4dvPTeCPrt+Mg1vaFL4D/l979x0eV3nm///9TB/VUe/NluXeGxhjg+lgAoQaSJYQIFlSIYVf2GzK7i/JJiE9kMKGJCSBEJYSSEIPBmyKjbGNuyxX9V5G0qjNzPn+MXPGqlOsUb9f15UraKSRjmSNzjn3cz+fm299aCG1zh5+/MoREu1mYixG/u3hHfzx9jUDCkS7ylvIcdgjuoDSi2F651B1WzeFKbFh7e239Cseh4ohqWnrjmoLvlKKtUXJbD/eNOz7nd19PL6jHJvZyM1r8iOarhSOmrYuNG340E4YuM10OHq3lTmMqSOhVrHBF245ePLJeFFK8V9XLWJ3RSsf//17FKbGsCzPwd92V7Mi38EnIygcT7RwJiDOVBaTgePfvfyMttsVp8dxtF8mYFtXH1WtXWHdrEfL+fNCdwLZzEa+ceUCXtxfG5jiKcZHQUosb3z5fPKS7YFOyJKMuDO+LkuNswY6h/787ik04Pb1oa977f2mPQ3X1dbQ3jNmv7u+jh01oZ1DJxo7A12Cg+lF/ob27mGLQ2GNso9gyqlOX+QezbTTUJPWxpNeKB+u0zcpxHGGCqQGiDGb6OwNPTjp6BhM5ixMiZ3Q7f66qpauQIbnTDb+V4QzVEaCbVJ0Drl6fVOxCoNsI8hMtA0Yqw7Q4uoLZNyEok/LCVbl31PRismgJnxChs1s5IZVefxtT1XgD1Ov28s7x5v40NLsiCesRCo1zoLNbGBXeSt9Hi2i4N3TmUMDbyT3VraRFm8lY5zS9u+9dC4fVLSy+RfbuOHX77C1rIFfvn6Uy3++lZcO1PHNKxcMKAwB3LgqjyN1HYEiYSgPbT3O/ionX7yoJPD7FQ49kLus3rfSEe6/p35i6A7ROaRffER7soFe/HnnmK+I8cTOCj768HZyk+x86eLwOqdiLCYevnUVj3xiDe/edwEv3bOB3CQ79z29jy2H62n0T8Xadaol4pX4zEQbSvlyBsB30xbu1EFLmJlkmqZR3dpF1ihW/YazoiCJ6rbuIX/jAB7eeoLvPn+Ybzx7gP97vzKqXxf6rUqNUBwKBDOOUBzSf2bBLvICv7thbisb7y1l/SXazfz1k2ezPN+BUSn+/G45SbFmfnnLyqgX5sTEOdMcpuL0OI7VdwS2o+jbl+dnTb4CzOYl2Txw84qItzKJ0ctPiUEpRVFqLPdft4TH7jzrjD9Xarw1MMr+neNNrMgPL0PKFmLC6Qv7a4DTGVzRZDQocpNiJqw41NbVR2NH74g5YHp+y3Dh6Zqm0dnrDi+QOsywZF1tWzfxVtOotvGlxFonzbay98tbmJMeN+zgm1BFrB538FH2ALFWI5094XQOdZAaZ4nqwJtZabGcbHKFHGQ01qpau6KaITpVydXXOMlKtEWcObSrvOWMRjcGE2hLDBL0l5VoH9I51NLZG3ZxyBJG5tAHFa3Mz0qYFNXZz5xfjMVo4LOP7aKi2cX+6ja6+7xhjTwfLaUU+ckxvFnWAEQWshlvM2FQQ8Nr91a1sTQ3cdwuUj+0NJt/3zibj56VT317Nx97eAc/eLGUGIuR33989bDdZlcuzcJuNvLX9ypCfv7n99Xw/RcPc8WSLK5ZHlk4rb6NTF/pSAlzYk5gWlmIrTl1zm6SYy0RFazCsSArgUS7mbePNVHn7Oa/njvAyoIknv3MORGFh5qNBjaWpGG3GEmwmfnuNYupbOnitj+8x+rvvMrVv3ybmrZu1heH7kQa/Hkz4m2BzqE2VwTFIWN407SaO3vpcXvJinJ771L/dsu9lQOn7Lk9Xp7YWcGGkjSW5zv42atlEU18C0dVkIkuMHCb6XD0bWXBsgMimbQ33OST8ZaZaONPt6/l2c+u5/FPnsVTd60b1UqvmD5mp8fR2esJXI/oxaFwp1WKmef6VXmBqWNnIi3OSmN7Dz1uDweqnIGt86HYQ3RsPrunmnmZ8YEpeNGWlxxDRZDiUKurl9+/dQJXGJ0hkTrpX1gdsTjkX+Cpbx9aHOpxe/FqhMwcOqPOobZuMkZ5LpksnUMer8b7p1pGnCibHGMJOq2sz+PFEmQ7OkCsNbzOobL69qhPiyxKjaXX7aW6bWJzhypbXDM+bwhkW9m4yUiw8cEIXRIVzS6MBsVj28t5dPsp/ufDS7CaDNz2h/e4cVUe379uSdSO45S/7TZY51BGgo0tpfUD9k63uPrCrhKHyhzyeDX2VrZFfKM/VtLirTxw83Lu+ese7vzjzsD403DHeo9WfnIsR+p8xYtIikMGg8Ix6ITQ0ePmWEMHVy6JbITraOj5IeCboNLc2cvGkrTAlrnhxNvMXLEki79/UM03r1w4Ykvx1rIGPv+X3azMT+L+64YPYA5G7xTSf76Rdg6Fyhyqc3aPyVQDg0GxaV46z+6p4kC1kz6vxg+uXUrKKC56AdYVp7L13vOpbOni1UN1PPL2SW47p5DrV+aFfvIgOUn208Whrr6wR4FbzeFN0zoRuOCMbmfLguwEDMo39e2iBafb4F8vbaCmrZtvXrkQR4yZmx56l2//8yCrC5PZvCQ7KqHYlS2uESe6AMRYjJgMKmQgdbDOIbNRYTSokL+7bV2+ySfBzgXjLZztkmLmKE47PbEs22Hn/VMtZCRYzyjfT4hwpMZb6Oz1sPNkC70eL8vDLQ4FmXBa0ezi/VMt3Hvp3Kgea3/5yXY+qGgdNvOox+3hzj/u5L2TLbx0oJZsh52bVueH3A7b3efh4W0n2DAnjcVBMiz1c/WstJGKQ/7OofahC+T6ecoecgqyEY9Xw+PVwj4X1zpHn1mYFGuh1dWH2xM6I3EsHalrp73bzerC4X8fk2ItNJ8KEUgdqnPIYhq2o7o/TdMoq+sYshtgtPR7nxONneOegajzejWqW7sDkyBnMikOjZPsRBtNnb109rgHrPw/tr2c/3hmX+DttHgrn398N7lJdgwK/rqzggvmp3NxlH5ZT/nH2BcEWS3OSrTh6vUEwuM0TaPV1UtSmDd/oTqHjjV00NHjnvC8of4umJ/B969dwl2P7qKi+Siz0mLH7QJU39ZhMRkCQb/hcsSYaek8fSO5v6oNTWNcwqiHE8nEqw8vz+HJ9yv51+E6Ng9TzKpu7eKzj+1mdlocv79tdciVpeEkBzqHfNvKUsPOHAovt6XO2TNmXQ7funIhh2qcVDa7+PENS8mP0k18tsNOtsPOmqJkvnLJ3JD70EeSHm8NTBJq7eoNu3Mo1n8R7QpRvDje4L/gjPJEwxiLiZKM+CGdQ3/ZUU56vJUL5qdjNhq4cVUef363nD+/W47dbIzK3+DKlq4RJ7qAr9DqiDEPCZnX6QX3YIHUSqmwJueUT9CkMiHC1X+c/blzUnn3eDPri1Nk65YYM3rX0csHagFYURDedap+zTDcee25D6oBxnTRbnleEn9+t5w3yxrZ2C9TVNM0vvrUPt472cLmJVn8Y28NVpOBp3dV8dgda1k3zAQ+8C0e3PLbd9lf5eSx7eW8fM+GEbuWjzf6BhuMtP0u3mrCZjYMu63M5T9PxVpDZw6B7xwYKp9IV9vWTXF66AmqweiTg7/LAAAgAElEQVTd5y2uvgktSu886ZuwunqEReuUWAstrj68Xm3Ybbx9nnC2lZlCbiurc/bQ3uOmJCO612X61MFj9R0R3UdEU2NHD70er2wrQ7aVjZul/kLITv9kIPBV0f/nhUOsLEji65sX8PI9G3jp7g0szE7geEMnX75kLnPS4/jeC4cDK8ajdbLJRaI9+OSNEn/b6y7/sbb3uHF7tbC7LkJlDuk5M0snUXEI4NJFmXxoaTZ5yTF85rzxm+Sh35wVpcRGnM2QNKhzaJ//hjfYKs9ksXZWCunxVv7uv3Aa7NdvHMPV6+Y3H1s57B7rcCQP2lYWbveb0aCwmAwhc1tqnd1kjNFEpcQYM898+hy2/X+bhi2eRcOZFobAF6be1tVHd5+H7j5v0E6x/vT9/+3dwduXjzV2YDaqMTlRL8lN5O1jjfzb73bQ5uqjurWLLaX13LAqL/Az+fqVC/jKJb6V3vfLW4J9urCVN7tCrool2M04Q3UOhZw6Ero4dKrZV3yb6G1lQowkNc6CI8ZMWX0Hxxo6aOzo4ezZ0l0mxk6avzi0pbSB7ERb2BMT9aLScN0xz+2pZlVB0qiGl4SyeWkWmQk2frnl6IDHH91ezjO7q/jyxSU8cPMK3vvahez6+kVkJFj55evHhnwer1fjF/8q44Zfv0NpbTt3XziHqtYufvPG0I/V6d0eI22vV0qRHm8bdltZl38bkz2MbWUQPMu0P7fHS0NHz6g7h/QhJk0TPLHsvZO+rsmRroeSYi14vBrO7qHXDl6vhturhbzei7MaQ24r0/M7i9Ojuz0yLd5KZoKN98vDyyEdC3rsimwrk+LQuFlZkITJoHhiZwU/e7WMXreX/33zOK5eD/dft4Tb1xdRkhFPcqyFJz51Nn+4bTWfPHcW9146j+ONnfzpnVNROY6jdR0hxw+eNSuZeKuJF/f7Vk5a/Pttw735CzWtbE9FK/E2U6BSPFkopfj5R5bz4t0buHZl7rh9XX0sZSRbynRZiTaO1LUHTphbjzZSkBIzqj3348VoUFy+OIsthxuGbIFp7uzliZ0VXL0sh8JR/J7EWIxYTAY6ez0k2EwRFUNsJkPQ3JY+j5fGjp5R72kPxm4xBi3kTiRHjJk2V1+gkJEQZueQXujr6Bm+AKI73tBJYUrsmLRy37K2gIsXZPLOsUY+9rvtfPTh7RgNihtXn95eF2c18Znzi1mW52D3qdFfsHi9Godr20NmTiTazUG2lYXOHALf732oMPVT0jkkJjmlFMVpvlDqN440ArL1UIwt/dqpvNnF7AhyVfSbdj1XTldW105pXTsfWja2W/2tJiOfWF/I9hPNHK71ZXNVNLu4/6VSzp6VwmfO9y14psVbibWa+Pi6IrYdbRwSd/HKoTp+9MoR3F4vP79pOXdfWMIF89J5/L2KwLTMwQ7VOEPeV6THW4cUznrd3sDQjZgQ28oC9xWe8HIAGzt68Xi1UY2xh9OT1obrehpPO082s6owecSuSb3Dabh8JD2rKVTnUIzVRGdPiOKQP6JhTpQ7h5RSrClKZseJpsAAgvG2r8q3uL4ga/Ivro81KQ6Nk1iriaV5Dv65t4afvHqErz2zj8d3VHD54ixmpQ18kZmNBs6bm47JaODC+emcNzeN+18qpbS2fVTHoGkapXXtgc6gkVhNRs6fl86rh+rweLXAH5vk2DAzRUJU+D+oaGVZnuOMJ5hMNwX+cPCiEfZrB3PdylwaO3r5xrP7eXDLUbaVNYxr3tBobShJpdfjHTK17Lk9VXT3ebn93NAjZINRSgVWAiPN67FbjEFzW3zTvnxjZGcih91Mr8cbCIt1hF0c8q0QOkN0Dh1v6Bgxw2C0luY5ePCWFfzw+qU0tvv+Hf/4ibXDruwuz3ewt6p11N2b5c0uOnrcISc0OuxmWruGzw7Qj8EU4m9nONvKTjV1khpnjSjgXIjxtignkffLW/jBi4dZmucILKYIMRb6bx2KpHCeFmfFYjQEJnjqtpTWA4w45j2arluZh8Vo4C/by/n1G8fY9KPX6XF7+O+rFg4pKtxyVj5p8Va++vS+wLW6pmk88NpRClJieOnuDVy2OAuAG1bnUd/ew+ulDUO+prO7j2MNHSFjItITrEM6h/6yo5yvP3sAIOS0MmuYgyx0+gCg0XYO6dd3kQ4Uiqaq1i6q27pZHWSqrN4lP9xktUBxKGTnkIk+jxY0D7KsvoOkGHOgGBVNa4qSqXP2TNjUvQ8qWslIsMpADKQ4NK7W+duh1xQm83/vV9Le4+aO9cFvfpVSfOeaxdgtRq58YBtvH2s8469f5+yhrauPuRmh2wEvWZhJU2cvO08209ShF4fCu7kOljnU1evhcG07S3Mn15ayiZSfHMNNq/O4wn8ijsSGOWnMSovl8fcquP+lUrwaXLNicgR9h2NlfjJKwXv+/dS6Vw/VMzstlnmZo59Kc/liX1ZM+zDttsHYzcag08pq/UWRjCiPsZ8q9ADqk/4cs3Azh/TiUEeQ4pDb46W82TWkcB5tVy3L4e37LmDLl88bcbvKivwkuvu8HK4ZXXF+f7VvVWpRTvBVqWCdQ73hbiuzGENmOp2a4DH2QoTjnotKuGpZNguyE3j41lWSNyTGVEq/XMLCIFN9BzMYFNkOG5WDOoe2HG5gXmY82VGeujmc5FgLlyzK5JF3TvG9Fw5z4fwMXv3iRuYMc82fYDPznasXcajGySf+8B5tXX2U1Xewr6qNO9YXDejY3TQvnbR4K4+8c3LI59lf6cu5DBUTkR5vo2FQ901Hvy6VUDlCgW1lYS7S1PqnXo26c0gP057A4pCeNxRsSI5e0Bg8aRpOh6SH7BzS8yCD5A6V1bUzJyN+TP4OnzXL9/1tO+q7z9U0jbv+/D7X/uptvvjEHs7/4ev8198PRP3r6j6obJtUWbgTSZYMx9Ed62exPN/B+XPT2V/lxGRUzA9jJGuOw86Ld5/L5T/bymPby1k3O5XKFhdp8daIRmiX1vlubkrCKA6dNzcNi8nASwfqAvsv88Lchxmsc2h/dRseryYvwH6MBsX3rj2ziXQGg+KBj6ygvNnFwRonjR09zB7jG+poSowxMzcjfkBxyNndx7vHm0bdNaT75IbZ/O/WExGfzGzm4J1DenFopq4yJNp9F9F6sHG408piw8gcqmjpos+jTYqtpyv8q3W7yltGleV1oNqJyaBCtmM7YiwjBlL3ucNbAbSbDWF0DrlYVyxbdMTklmg38+Mblk30YYgZwmw0BIYCRFIcAl9WSf9tZe3dfbx3sjlq1zLhuOfCOWTEW1lRkMRlizKDXvdcvDCTH1y3hK89s48vPfFBYIFk06AuJ7PRwG3nFPKDF0vZV9k24Dy4p9LX9R1qCEpmoo32HjdtXX2BhaT+C8ihOlgjzRyK1vWZzWwk0W6mbgK3lR2odmIxGZgXZNeH3iFV0zp0FPw/99YAsDA7+L+R/m/Q0eMeNp9T0zTK6jvYvCTyhexwzE6LY35WAr96/RjXrshld3krL+yvZW5GPNvKGrGYDPz+rZNcujCTtVHeXtzq6uVEYyfXrxq/SJHJTDqHxlFijJlN8zJQSrE4NzGswpAuPd7GBfMyeONIA62uXi75yZvc99S+0E/s54h/W1qozAvw/ZE4tziVlw7UUt7USbzVFHYgdbDMoQ8maRj1VLYgO4FLF2XyxYtK+O41iyf6cCK2ujCZXada6HV78Xg1fvhSKW6vxkVRasNOi7fy2J1r+fPtayN6ns1spDvIhcgpf+vrWIZMTmanO4d8P4dwO4fMRgN2szFo5tDxBt++9rHuHAqHL5TUyq5RhlIfqHYyJyM+ZEE/JdZCe7d72MKknjkUKjvLbjYGzcvq7vNQ6+wOOrVSCCFmIj13qDA1snN7jsNOVb+b89cO1+P2alwwb+y3lOlmpcXxn5sXcPnirLAWxG5YlcdXL5vPq4fq+NmrRyhKjSVnmC6nj55VQLzVxG+3HR/w+O7yVopSY0NmkuqFtpP+sfcAzq4+zEbFz25aFjKzKFRcxWA1zm4sRgPJYWalBpOZYAs54n0sVbV2kZ1oC5q/GG8zE281Dekc6vN4eejN46wpTGZlkG1pcHpYyEih1A0dvt0nof6tzpRSiq9fMZ/Kli5+8VoZj7x9EkeMmWc/ew47vnYhr9yzkbxkO/c9sy/o1rcz8d5J3/WdNC74SHFoCrlwQQbt3W6+98JhOns9PL27ih0nmkM/0a+0rp20eGvYRZ5LFmZS1drFq4fqyU+JCbvzQr/5GW5b2e6KVnIc9gkdCSkml03z0+ns9fC/W49zxc+38sd3TnHbOYUhT2SRWDc7NayiaH82syFoqG95s4ukGDMJZzhJbarTi0Pl/qlXDnv4F2FxNlPQziF9jP3sMcocioRSihX5SewexRQNj1djd3kLy/JCdx7lJvuDTYdZAdQnpiTYg6+yhsrLqvAXNiO9+RFCiOkuLc6KCjKafSQ5jhga2nsChfm/f1BDZoKNVVG8lhkLnzinkAvnZ+DsdrN+hNH2CTYzVy/P4cX9tYFtzy2dvbxxpIENc0KPi9cHrujb0MFXHMpIsHHVspyQ9xeRbiura+smPcEalWzT9ARrxMWhHrcnasHKNa1dYW1LzHLYqB503fBBRSs1bd3cuq4w5PP1bWUjjbM/Ggijju6ksv7WFadyw6pcHtxyjBcP1HLzmnxs/rByu8XIt69ezPGGTn79+vEQnykyL+6vJcFmYlXByFv3ZhIpDk0h64tTSbSbefy9ClLjrOQ47Nz2+x28eWRoSNxwjtS1h5U3pNNbTKtauyLKprAGyRzaJ3s6xSAb5qSRnWjj/pdKqW/v4cGbV/DNK4cGKI63UKG+Fc0u8iNsO59O9GLQySYXSp3OEgpHvM1Ee5CpGMcaOkiOtYQ9IXGsrShwUN7s4ievHMEVYtTrcEpr22nvdrOmKPSFhz7qvrJlaCjjwWonjhhzyBD0UKPs9W4vCfcVQoiB8pLtFKXERhTbAKdHYFe3dtHm6uPNIw1cvjhr0g9fUUrxw+uXcOH8DK4LMqn3hlV59Li9PPdBNQBP7aqk1+3l5rUFIb9GQUoMSvnG3uuc3X1hL67pW6nD7hxq6x51GLUuI8EW9rYyTdP47vOHWPKtl/n2Pw9F5ev7vpcwikOJ9iHB2XpHjJ7nE0ygc2iEa7Oy+rGZVDbYf1+1iKuXZfO1y+fzpYvnDnjfxpI0PrQ0mwe3HOWYv8N8tHrdXl45WMtFCzJD5jLNFPJTmELsFiPf92fTXLYok6fuWkd+Siyf/NPOIdOeBvN4NY7UtYeVN6TLTbIHbkIKIrgJHumPeHt3H+XNLhaEmNYjZhajQXHz2nyUgp/euIwrxmg/c6TsluBbc041uWb0zbXeOdTQ3kOCzRzRBXC8zRyyc2gy5A3p1hT5CuU/+1cZf3zn1LAf09jRw8nGzmFXC3ec8I3rXR0kUFKnj0QeHGwKcLDGyYKshJCF01Dbyk75V28j+bsuhBAzwX2XzeeRT6yJ+Hl6Jsz2E8185/mDuL3eoMWWycQRY+G3t64KGvmwKCeBOelxvLDPl2HzzO4qluc7wurKtpmNZCfaB2wr658/FEokmUOapnGsoYP8KG2bzkiw0tDRg8cbuhPor+9V8NCbxylIieHhbSd4+UDtqL622+OlztlNjiN0oSsr0UZ168Di0M6TzcxKiw1rWm9siOLQkbp2Eu3mwATgsWIzG/npTcu5c8MsjMNcV3598wJsZgNfeHw3zn6DZlo6e4ftuA5lx4lmnN1uLluUOarjnk6kODTFXLookz/fvpZ7LiohM9HGn25fQ7zNzAOvlQV9XkWzi+4+b9BAs8GUUqz2r3QXRHATbDAoYi1GmgeNVDzszzxaEEHWkpgZPn1eMVvvPZ8NJWkTfSgBNtPI3Rduj9fXUTeDi0M2szHQJZgUZhi1Lt5qoiPI9LjjjWM3xv5MLMtz8NRd61iSm8gzu6qGFIBKa9tZ//3XOO+Hr/PglqNDnr/jZDM5DnugKyiYjHgbZqMaUhzq83g5XNvOwjCK6/YQYerlzS7ibaaI/92EEGK6S4q1nFGW4MLsBIrT4/jRy0d4Ymcl/75x9rRaDFVKcd7cNHaebKGmrYuDNU7On5se9vMLU2MGdg51uUNukdYFyzIdrM7ZQ2NHL4tzovOzz0yw4fFqA7bEDcfV6+a7zx9ibVEyf//ceuZlxvPtfx4Ku9tpOHXtPXg1yApnW1mincaOnsDPyOvVeL+8hdVhbpWKteiZQ8P/jA9UO5mXOTaTyiKRFm/lpzcto7S2nU//eRea5mt+uOSnb3L1g29F/PPefqIJo0GNOLF2JpLi0BS0fk5qIDcoNc7KxQsyeOdYE31B9uIGJpVFmLuyutC3Vzo/wpHHKwqSePd404DHDlY7AabVyVJEh8GgwrpxHk+2IJ1D1a3deLzajO4cgtMh1EtyI9sqGh8kc6itq4/Gjt5JEUbd38qCJK5flUdpXTsHqp20dfXxP88fYvMvtvKR/32XOKuJs2Yl8/C2E0N+b3aXt4adoWUwKHIc9iHbyo43dNLr9ob199Nu8RU2R8o8OOkfYz/RF3lCCDFdKKW4fmUujR09rC5M4u4LSyb6kKLu3Dlp9Hq8PPDaUTQNzopgalRRaiwn+nXXtnWFv60sWFzFYPuq2gBGNV20Pz0+YPPPt1HqX+QezrayRpzdbj63aQ5Wk5GvXjaP8mYXv3nj2Bl/bT1DKNzMIYC6Nt8WuMqWLlpdfSzPD+/6LNaqZw4NvTbrdXs5WO2cNMOENs3L4BtXLmTb0UYe21HOpx/dRUePm4b2Hl4+GFm31nsnm1mYnRByYt5MIsWhaeDcOWl09nqCBqbqk8oiTZm/amkOn99UHHFI1/riVMrqOwIhbqeaOnlxfy3JsRbSJYxaTAG+rTnDX4iU+wN9Iy2aTjctLl93YCQXiODb294xQuvy0foz+1s1Hq5ckkWc1cR//+Mgl/70TX677QSJdjMr8h08ePMKPnv+HFpcffxtd1XgOU0dPdS0dbM4J/wL1dykmCGdQweqfRe8ocbRgq845NVGvpAub+qUSWVCCBFlH1mbz+c2FfPLW1ZOy/ySNUXJWEwGHt1eDsDSMIYs6ApTYnF2u2lx+bqGnd3hbyvT85/C6QrZX9WGQRHRROhgNsxJ5S93nkWfx8vTuytH/Lh/Haon3moKZAtuLElj85IsfvTKEZ73b8Ubicer8a3nDvC5v+zG49U43tDBywdqTxeHwshPyvUXkPQOp2b/9Vl6Qnj3XP1H2Q9WWttOr8fLkigV3KLhljX5rClK5mvP7OdofQc/uXEZOQ47D287MeT3pNftDQziGPz47vJWCaIeRMpk08DZs1MwKHjjSP2IgaeHap3kJdsjrowmxpj54qBAsHCsn5MKL8BbRxv58IpcPvrwdiqau1hblCyr1WJKsJkNge6Lwb+zJxp9QXiFMzyzRR+tHmk7brDMoUM1vuJQpNPlxoMjxsJd583m/pdKSY618Myn1w3omvJ6NZbmOfjGswfIdtjZUJLGAX/HZDjbwXS5SXZePVQ/4LGD1U6sJkNYWUx2/3SP7j5PYNKHzu3xUtnSxeWLJ0e2lxBCTBcJNvOQEN3pxGY2cue5RTy45RjnFKdEFNqtTyw70dhBvM2Bq9dDQqSZQ2FMK9tf1cbstDhiLNG5xVXKt+XonOJU/rm3hq9eOm/INaHXq/FaaT0b5qYFjlUpxY9uWMqRunZ+88axYc+5T7xXgVfT2FvVxmP+gpvNZGBLaT2NHaejOcLZVrY0z4HZqHjraCMbStJw+qfKRdKdZTSoYYdufFDpaz5YGmGX+FgyGBQP37qKrz2zH5NBcfGCDJxdfXzlyb188k87+fVHVwaufx7YcpRfv36MLV85j4x4K40dvaTGWfjjOyfpcXtZUzS5JwqONykOTQOJdjPnFKfy5PuVfOGCkiGrFZqmseNEM+fOGb88l/mZCcTbTOwub2XzkmwqmruItRi599J543YMQoxGcqwVj1ej1dVHUuzAqVnHGjqJtRjJCHNFZrqymQ1093kpjLCDKs7m6xzyerUhQdalte3EW03khHExNBFuX19Eq6uXa5bnDtniZTAoHrltNTc99C6ff3w3z3/+XPZH0PGjK0qNpbGjh3pnN+n+oQD6fn+TMfRqtF4c6urzMPhSrrq1G7dXi2gCpRBCCAHwlUvmcdWynLCLDrrTxSFXYGEt3M6h02PWg08L9Xo1dle0smle+FlI4bpiSRb3PrmXd443sW526oD3vVHWQEN7D5cuHBhqbDUZuW5lLt99/jAnGzsp7Le48/KBWu59am/g7U9tmEWrq4+/7qwgNc7CpzbM4vn9NeQlxQQmiQUTazWxujCZ10sbuO/y+YGw5nALcEr58mKHG2W/t7KVpBhzYGDGZBFvM/PzjywPvH39qjz6PBpf+9s+7nhkZyBY/v92VtDr8fKNv+3nWEMHJ5tcJMdaaO7sZWVB0rjeH08F06/ncYa6fX0Rdc4e/rG3esj7yuo7aOzo5ewIt36MhsGgKEiJoaLFRW2bb2vZNz+0MOzcDSEmmj4dYrjpB8cbOylKi53xXXCv3LORF75wbsQ/hwT/2PuOYVaoSmvbmTsJQg9HYjMb+doVC0bM/nHEWPjVR1fS5/by1af3caDK17WZGEH48znFvgvPN8saAV+B/2CNkwVhFpjs/gvp4UKpTzX7Ws6jNclFCCHEzFKSEU9mhKPi85JjMBoUJxs7adO7WsIMpI6zmjAaFK2ukQdZgG+XRHNnL+vGIFz4yiXZZCfa+PY/Dg25LvzDWydJj7dyycKhE682L8kG4G97fNvN91W2sbWsga88uZcluYksy3OwICuBL15cwveuXcyur1/E1ns3cd/l89l67yYeu/OssI/xvLlplNa1U93aFejOjqSIF2s1DVuAO1DtZFFO4qS9Luvv5rX5/M81i9l2tJHfvHmMt481UtPWTWqclX8drsdgUHz2/GKW5zl46GMrefLfz5a8oUHkpzFNbCxJoyQjjofePM41y3MGvID1YOjxTmLPdcRQVt8eCFadbBVnIYLJSvT9vta0dbNoUF7MsfoOKXTCGU10AQKrYB3d7gEXLpqmcbjWyZVLs6NyfBOlKDWWL108l//+x0FMBsUVSyLbwrUwO4G0eCuvl9Zz3cpcqlq7aOvqCzvM39avc2iwU02+v8eFqdI5JIQQYnyYjQZyk+ycaOrEGWHhQimFw26mtSt4cejto777ncGdPdFgtxj5z80L+PSjuzj3+6/xm4+t4qIFGfzrUB1vHGngSxcN3bkBvjDp8+em8fu3TmI3G/nBS6V4vBpWk4Gf3riMgpRYPF4t8NzkQZ3qkdC/7/dPtQS2lcXbwr/VT7SbA1mSul63lyN17XxifdEZH9d4u3F1Hm+WNfCTV45QmBJLapyFR+9Yy3MfVPHvG2cTH2HX20wjnUPThFKKO9bP4nBtO28dPT0lzO3x8uyeav8Y5fEtzuQl26ls6aLCXxzKm2TTqIQIRp8OUdM2cIWou89DdVvXpBq1PtXoJ+bBuUO1zm6c3W7mTcK8oUh97OwCVhUkce6cVL6xeUFEz1VKsWFOGlvLGvF6tcCkx3Bzi/pnDg12qqkTi8lARnxkq75CCCHEaBSlxnKi4XTnULjbygAcMWbaQnQOvXWskVlpsRF3NYXr8sVZ/PPz6ylKjeW7zx/iU3/ayacf3cWinATuOHfWiM/78iVzfRNOXzjMxpI0vnrZPH7xkeXMSovDaFBRCy8vTvd9viN17Ti7+zAaVGBLXjgKUmI42TQwuPlofQd9Hi2irfETTSnFd65ejCPGQll9B/ddNp+5mfF85ZJ5UhgKg3QOTSNXLc/m/pdLeXDLUc4pTkEpxfdeOMz7p1r44fVLx70dMC85hh63lz0VrRgUY/bHWoixkBJrwWI0DGkf9o1iZdKNWp9KUuN8K2P17d0Dgqc/qPDn80Qw2WuyMhsNPHnXujN+/tK8RJ7aVUlTZ29gcllRmAHop7eVDQ3vPNXkoiA5ZkjWkxBCCDGWClNi2XGiud+2skiKQ5YhXS39aZrGnorWIbk/0bYwO5EvXzyXux7dhbOrj2tX5nL3BXMC592RnvOdaxZhMxn58IqcMbsfs5mNFKbEUFrbTkaCjQSbKaKvVZQax2uH6/F4NYz+a4TTk1KjM/1tvCTFWnjoYyvZWtbIh1fkTPThTClSHJpGrCYjnzlvNt/6+0HeLGukprWL3247wa1nF3DdytxxPx69U+nd481kJtgwhxGkKsRkYTAoMhNt1LR2D3i8rN43qSycqVFieHpXVvWgwtueilbMRsWCKI2gncrS/Z09dc5uWl29KBX+Kqs9yLay8maXhFELIYQYd0Wpsbh6PRyu8XXDOiLI4kuKMVM96Hqsv4b2HlpdfeMy6fTSRZk88amzWZidEHZezS1rC8b4qHzmZsZzsNqJ3WKMqPgGvuvaPo9GZYuLAv9i1MEaJ3azcUpO512en8TyfImAiJTcrU8zN68tID85hi/+dQ//+bf9bCxJ4+sRbmmIFn0b2YnGTnJlS5mYgrIdtiHbynaebCbGYpyUo9anisxEGwYFVYMu9PZUtLAgK2HI+PWZSO+0rHN20+LqI9FuDrvbR//5DR5J6/Z4OdHYOSUv8oQQQkxt+rSuLaUNxFiMpMWFP/E10W6hNUjn0JE638Ld3IyxvzZTSrGmKHlSBhmXZMRzqtlFvbMn4olyelzC8cbOwGMHqp3Mz4oPdBKJ6U+KQ9OMxWTgdx9fhdVkoDg9jl/cvDys0cdjoX9B6EyDa4WYSNmJ9iErVduPN7OyIEk64UbBbDSQkWCjquV04c3j1dhb2cayvMHD12emjATfRXOds4fWrj6SYsIPqdTb2wdnDh1v7KTH7Q072FoIIYSIFr3j+lCNk6LUyCa+JsUED6Q+UtcOwJxxKA5NZnMz4tE0+FcuqaMAAA4eSURBVKCyNaIwavB1dgEcb/AVhzRN41C1U64ZZpjJV/IUo1acHs9rXz4PYEJX4O0WIwuzE+hxe/n8BcUTdhxCnKlsh51aZzdujxeT0UBzZy+lde18aNnUnqY1GWQ77AO2lR2t78DV62FZvhSHAFLjrCjlC+ludfVGFNyZFGNGKd+kvf707IDB0/eEEEKIsZbtsGMxGuj1eAOFiHA5Ysy4ej30uD1YTUPvbcrq20mKMQcyDWeqEn9Xu6vXE3HnUHKshUS7mRONvi6siuYu2nvcUyqMWoyeFIemqcmyLeMfn1s/7kHYQkRLYapvxGh5s4tZaXHsONEMwNqi5Ak+sqkv22Fnb2Vr4G191W9epqxQga+7KjXOSr2zmxZXb0Tt9zEWE7NSYzngn3Km21/lxGoySF6WEEKIcWc0KPKS7Rxr6Iz4POTwd8+2ufpITxh6j1Na205JRvyMv+coSI7BYjLQ6/aSYI/sNl8pRUlGHPurnHi8WmBBSXIgZxbZFyHG1Ez/Iy2mtjnpvolk+l727SeasJkNLMmV7pbRynHYqWntxuvVACira8egiHg1cTrLSLD6O4ci21YGvu6gA1VtAx7bX9XG/KyECdtqLIQQYmYrSvVdVxWlRd45BAy7tczt8XK4tp35UsTAZDRQ7J+mG2nnEMDaohT2VbVx6+92cNejuwAkY3OGkStEIYQYQbG/OHS03tfVsv14Myvyk7CY5E/naOU4bPR6vDR29AC+KXCFKbGTputxMshMsPkyh1x9JEYw1QVgUXYi1W3dNPl/vl6vxsFqJ4ty5OJZCCHExChKjfH/f1xEz9MXSFo6h4ZSl9a14+r1sFy2pQMwz1/MiT+D4tDZs1PweDW2HW0EwGxUcl02w4S8w1FK5SmltiilDiqlDiilvjDMx1yllNqrlNqjlNqplFrf730/8D/vkFLq50paSYQQU0Ss1USOw86Rug7aXH0cqnWytihlog9rWtAD6081uwBfcUgvxgmf9AQblS0uOnrcZ9Q5BLDfv7WsosUl2QFCCCEm1JqiFFLjrBGf7/XcveE6h3aV+7aor5Cx5cDp3KFIt5UBrCxIwmI0YDIoHrx5BY/deVa0D09McuH81riBL2matkspFQ+8r5R6RdO0g/0+5l/Ac5qmaUqpJcATwDyl1DrgHGCJ/+O2ARuB16P2HQghxBiakxFHWX0H755oQtPgrFmSNxQNevFiT3krS3MdnGzs5JKFGRN8VJNLRryN9m7fOHpHhJ1D+nSR/VVtbCxJY3+Vr0i0SIpDQgghJshFCzK4aEHk5/qkWN8CyXDj7HefaiE1zkJukn3UxzcdzPVPbDuTbWU2s5HLF2dit5i4YklWtA9NTAEhi0OaptUANf7/bldKHQJygIP9Pqaj31NiAU1/F2ADLIACzEBdVI5cCCHGQUlGPG8fa+I3bxwjPd4q07SiJC3eSl6ynWd2V/HL14/i9mqUzPARtIPNyzr983BE2DmUaDdTkBITCJQ8UN2GyaAoyZTuLCGEEFNLSqxl2CmcALvKW1ienyQ5p34rCpI4pziFlQVn1kn105uWR/mIxFQSUXCGUqoQWA5sH+Z91yilDgP/BD4BoGnaO8AWfMWlGuAlTdMOje6QhRBi/Fy+2Ldysqu8lU+fN3vYEarizKzIT+JgjZOuPg+f31TMBfOlc6i/1YWnu9SSIuwcAl+XkN4xtL/ayZyMePn9FUIIMeXYzEYKU2I5XNM+4PGq1i5ONrlkimw/iXYzj95xFoUy4EOcgbCLQ0qpOOAp4G5N05yD369p2jOaps0Drgb+f/9zioH5QC6+bqNNSqlzh/ncn/RnFe1saGg4s+9ECCHGwLI8B7/9t1VcvzKXm9bkT/ThTCt6PsCHV+TyxYvnEmeNfH/8dJYce7pbyGGPrHMIYGFOAuXNLqpbu9hX2cqibAmjFkIIMTXNz4rnUO3AW9BtZb77xnPnpE3EIQkx7YRVHFJKmfEVhh7VNO3pYB+radqbwCylVCpwDfCupmkd/q1nLwBnD/OchzRNW6Vp2qq0NHlxCyEmlw0ladx//VKZ2BBlm+alszgnkTvPnTXRhzJpWfxj5/Uwzkjo+ULrvvcazm431yzPieqxCSGEEONlXmYCp5p8Qxp0W8saSYu3UpIhW6aFiIZwppUp4GHgkKZpPx7hY4r1KWRKqRWAFWgCyoGNSimTv8C0EZBtZUIIIchLjuHvn1tPkbQ+j+ixO9dywbx0shy2iJ+rh34D/ODaJawrTo3moQkhhBDjZn6Wr/u11N895PZ4eetoI+uLUyVvSIgoCaeH/xzgY8A+pdQe/2P/AeQDaJr2a+Ba4N+UUn1AF3Cjf3LZk8AmYB++cOoXNU37e5S/ByGEEGJaWlWYzMMfP7MsheRYC0/ddTY5jhgyEyMvLgkhhBCTxXz/kIaDNe2sLEhmx8lmWlx9XCh5hUJETTjTyrbhmzQW7GO+D3x/mMc9wKfO+OiEEEIIccZWFkhIpxBCiKkvx2EnNc7KzpPNfOysAl7cX4vVZOC8uRJJIkS0RDStTAghhBBCCCGEGE9KKc6encLbx5ro7vPwwv5aNpakESvDLISIGikOCSGEEEIIIYSY1NbNTqGhvYf/eGYfDe09fHxd4UQfkhDTihSHhBBCCCGEEEJMautmpwDw9K4qLpyfIYMWhIgy6cMTQgghhBBCCDGp5SfH8IUL5mA1G7hlbcFEH44Q044Uh4QQQgghhBBCTGpKKe65qGSiD0OIaUu2lQkhhBBCCCGEEELMYFIcEkIIIYQQQgghhJjBpDgkhBBCCCGEEEIIMYNJcUgIIYQQQgghhBBiBpPikBBCCCGEEEIIIcQMJsUhIYQQQgghhBBCiBlMikNCCCGEEEIIIYQQM5gUh4QQQgghhBBCCCFmMKVp2kQfwwBKqQbg1EQfR5SkAo0TfRBCTCHymhEicvK6ESIy8poRIjLymhEiMpP5NVOgaVracO+YdMWh6UQptVPTtFUTfRxCTBXymhEicvK6ESIy8poRIjLymhEiMlP1NSPbyoQQQgghhBBCCCFmMCkOCSGEEEIIIYQQQsxgUhwaWw9N9AEIMcXIa0aIyMnrRojIyGtGiMjIa0aIyEzJ14xkDgkhhBBCCCGEEELMYNI5JIQQQgghhBBCCDGDSXFojCilLlVKlSqljiqlvjrRxyPEZKCUylNKbVFKHVRKHVBKfcH/eLJS6hWlVJn//5P8jyul1M/9r6O9SqkVE/sdCDExlFJGpdRupdQ//G8XKaW2+18bf1VKWfyPW/1vH/W/v3Aij1uIiaCUciilnlRKHVZKHVJKnS3nGSFGppS6x39dtl8p9RellE3OM0IMpJT6nVKqXim1v99jEZ9blFK3+j++TCl160R8LyOR4tAYUEoZgQeBy4AFwEeUUgsm9qiEmBTcwJc0TVsAnAV8xv/a+CrwL03T5gD/8r8NvtfQHP//Pgn8avwPWYhJ4QvAoX5vfx/4iaZpxUALcLv/8duBFv/jP/F/nBAzzc+AFzVNmwcsxffakfOMEMNQSuUAnwdWaZq2CDACNyHnGSEG+wNw6aDHIjq3KKWSgW8Ca4E1wDf1gtJkIMWhsbEGOKpp2nFN03qBx4GrJviYhJhwmqbVaJq2y//f7fgu2HPwvT4e8X/YI8DV/v++Cvij5vMu4FBKZY3zYQsxoZRSucAVwG/9bytgE/Ck/0MGv2b019KTwAX+jxdiRlBKJQIbgIcBNE3r1TStFTnPCBGMCbArpUxADFCDnGeEGEDTtDeB5kEPR3puuQR4RdO0Zk3TWoBXGFpwmjBSHBobOUBFv7cr/Y8JIfz8bcjLge1AhqZpNf531QIZ/v+W15IQ8FPgXsDrfzsFaNU0ze1/u//rIvCa8b+/zf/xQswURUAD8Hv/VszfKqVikfOMEMPSNK0K+CFQjq8o1Aa8j5xnhAhHpOeWSX3OkeKQEGLcKaXigKeAuzVNc/Z/n+YboShjFIUAlFKbgXpN096f6GMRYoowASuAX2mathzo5HSbPyDnGSH6829puQpfYTUbiGUSdTIIMVVMh3OLFIfGRhWQ1+/tXP9jQsx4SikzvsLQo5qmPe1/uE5v4/f/f73/cXktiZnuHOBDSqmT+LYob8KXp+Lwt//DwNdF4DXjf38i0DSeByzEBKsEKjVN2+5/+0l8xSI5zwgxvAuBE5qmNWia1gc8je/cI+cZIUKL9Nwyqc85UhwaG+8Bc/wp/xZ8oW7PTfAxCTHh/HvSHwYOaZr2437veg7Q0/pvBZ7t9/i/+RP/zwLa+rVuCjHtaZp2n6ZpuZqmFeI7l7ymadotwBbgOv+HDX7N6K+l6/wfP6VXsYSIhKZptUCFUmqu/6ELgIPIeUaIkZQDZymlYvzXafprRs4zQoQW6bnlJeBipVSSv2vvYv9jk4KS1/LYUEpdji8nwgj8TtO070zwIQkx4ZRS64GtwD5O56f8B77coSeAfOAUcIOmac3+i5QH8LU3u4DbNE3bOe4HLsQkoJQ6D/iypmmblVKz8HUSJQO7gY9qmtajlLIBf8KX59UM3KRp2vGJOmYhJoJSahm+AHcLcBy4Dd+CqJxnhBiGUuq/gBvxTZXdDdyBLwdFzjNC+Cml/gKcB6QCdfimjv2NCM8tSqlP4Lv/AfiOpmm/H8/vIxgpDgkhhBBCCCGEEELMYLKtTAghhBBCCCGEEGIGk+KQEEIIIYQQQgghxAwmxSEhhBBCCCGEEEKIGUyKQ0IIIYQQQgghhBAzmBSHhBBCCCGEEEIIIWYwKQ4JIYQQQgghhBBCzGBSHBJCCCGEEEIIIYSYwaQ4JIQQQgghhBBCCDGD/T9z3ISyOyEG/gAAAABJRU5ErkJggg==\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "model.summary()" + ], + "metadata": { + "id": "tvxhRKAF54kU", + "outputId": "021c15b8-31c3-43cd-d1dc-1bb2743da054", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "tvxhRKAF54kU", + "execution_count": 70, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"model_2\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_14 (InputLayer) [(None, 1000, 1)] 0 [] \n", + " \n", + " max_pooling1d_12 (MaxPooling1D (None, 998, 1) 0 ['input_14[0][0]'] \n", + " ) \n", + " \n", + " conv2 (Conv1D) (None, 960, 3) 123 ['input_14[0][0]'] \n", + " \n", + " conv3 (Conv1D) (None, 980, 3) 63 ['input_14[0][0]'] \n", + " \n", + " conv4 (Conv1D) (None, 990, 3) 33 ['input_14[0][0]'] \n", + " \n", + " conv5 (Conv1D) (None, 998, 3) 3 ['max_pooling1d_12[0][0]'] \n", + " \n", + " zero_padding1d_35 (ZeroPadding (None, 1000, 3) 0 ['conv2[0][0]'] \n", + " 1D) \n", + " \n", + " zero_padding1d_36 (ZeroPadding (None, 1000, 3) 0 ['conv3[0][0]'] \n", + " 1D) \n", + " \n", + " zero_padding1d_37 (ZeroPadding (None, 1000, 3) 0 ['conv4[0][0]'] \n", + " 1D) \n", + " \n", + " zero_padding1d_38 (ZeroPadding (None, 1000, 3) 0 ['conv5[0][0]'] \n", + " 1D) \n", + " \n", + " concatenate_12 (Concatenate) (None, 1000, 12) 0 ['zero_padding1d_35[0][0]', \n", + " 'zero_padding1d_36[0][0]', \n", + " 'zero_padding1d_37[0][0]', \n", + " 'zero_padding1d_38[0][0]'] \n", + " \n", + " batch_normalization_2 (BatchNo (None, 1000, 12) 48 ['concatenate_12[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_2 (Activation) (None, 1000, 12) 0 ['batch_normalization_2[0][0]'] \n", + " \n", + " global_average_pooling1d_2 (Gl (None, 12) 0 ['activation_2[0][0]'] \n", + " obalAveragePooling1D) \n", + " \n", + " dense_2 (Dense) (None, 1) 13 ['global_average_pooling1d_2[0][0\n", + " ]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 283\n", + "Trainable params: 259\n", + "Non-trainable params: 24\n", + "__________________________________________________________________________________________________\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "a4FNE_gF90jd" + }, + "id": "a4FNE_gF90jd", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model.get_layer(\"conv5\").weights[0][:,:,:].shape[0]" + ], + "metadata": { + "id": "SgSG4hEr79Rb", + "outputId": "d9fb4718-6ef2-4232-d654-f79a7c5b3f66", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "SgSG4hEr79Rb", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "1" + ] + }, + "metadata": {}, + "execution_count": 158 + } + ] + }, + { + "cell_type": "code", + "source": [ + "ecg_plot = X_test[0,25:125,0]" + ], + "metadata": { + "id": "5mGSpUU8-oMx" + }, + "id": "5mGSpUU8-oMx", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "for layer_name in [\"conv2\", \"conv3\", \"conv4\"]:\n", + " for h in range(3):\n", + " for i in range(len(ecg_plot)-model.get_layer(layer_name).weights[0][:,:,:].shape[0]):\n", + " clear_output(wait=True)\n", + " fig,ax = plt.subplots(figsize=(20,2))\n", + " ax.plot(ecg_plot)\n", + " ax2=ax.twinx()\n", + " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,h], \"r\")\n", + " plt.show()" + ], + "metadata": { + "id": "txIQ2HBc7Cru", + "outputId": "131cd2c9-4aad-4783-f621-f797d5c34058", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + } + }, + "id": "txIQ2HBc7Cru", + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtwinx\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m 270\u001b[0m \"\"\"\n\u001b[1;32m 271\u001b[0m \u001b[0;32mglobal\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 273\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m 41\u001b[0m display(\n\u001b[1;32m 42\u001b[0m \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 44\u001b[0m )\n\u001b[1;32m 45\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 314\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 181\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 225\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 340\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 342\u001b[0m \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m 242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 245\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 246\u001b[0m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 2101\u001b[0m \u001b[0mbbox_artists\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"bbox_extra_artists\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2102\u001b[0m bbox_inches = self.figure.get_tightbbox(renderer,\n\u001b[0;32m-> 2103\u001b[0;31m bbox_extra_artists=bbox_artists)\n\u001b[0m\u001b[1;32m 2104\u001b[0m \u001b[0mpad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"pad_inches\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2105\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mpad\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer, bbox_extra_artists)\u001b[0m\n\u001b[1;32m 2383\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2384\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2385\u001b[0;31m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2386\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwidth\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mheight\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2387\u001b[0m \u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer, call_axes_locator, bbox_extra_artists)\u001b[0m\n\u001b[1;32m 4321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4322\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxison\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4323\u001b[0;31m \u001b[0mbb_xaxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4324\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbb_xaxis\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4325\u001b[0m \u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb_xaxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1188\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_label_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1189\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[0;31m# go back to just this axis's tick labels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_update_label_position\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 2030\u001b[0m \u001b[0;31m# use axes if spine doesn't exist\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2031\u001b[0m \u001b[0mspinebbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2032\u001b[0;31m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmtransforms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mBbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbboxes\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mspinebbox\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2033\u001b[0m \u001b[0mbottom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2034\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36munion\u001b[0;34m(bboxes)\u001b[0m\n\u001b[1;32m 702\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvalid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 703\u001b[0m \u001b[0mx0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 704\u001b[0;31m \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 705\u001b[0m \u001b[0my0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 706\u001b[0m \u001b[0my1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 702\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvalid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 703\u001b[0m \u001b[0mx0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 704\u001b[0;31m \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 705\u001b[0m \u001b[0my0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 706\u001b[0m \u001b[0my1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mxmax\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 357\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mxmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 358\u001b[0m \u001b[0;34m\"\"\"The right edge of the bounding box.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 359\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_points\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 360\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mamax\u001b[0;34m(*args, **kwargs)\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36mamax\u001b[0;34m(a, axis, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 2753\u001b[0m \"\"\"\n\u001b[1;32m 2754\u001b[0m return _wrapreduction(a, np.maximum, 'max', axis, None, out,\n\u001b[0;32m-> 2755\u001b[0;31m keepdims=keepdims, initial=initial, where=where)\n\u001b[0m\u001b[1;32m 2756\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2757\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapreduction\u001b[0;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mreduction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 86\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 87\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "np.arange(40)" + ], + "metadata": { + "id": "ajaT6gM78Y5I", + "outputId": "6096c0d5-fa0b-434b-a7aa-c8b14bbe16e1", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "ajaT6gM78Y5I", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", + " 34, 35, 36, 37, 38, 39])" + ] + }, + "metadata": {}, + "execution_count": 144 + } + ] + }, + { + "cell_type": "code", + "source": [ + "fig,ax = plt.subplots(figsize=(30,4))\n", + "ax.plot(X_test[0,:,0])\n", + "ax2=ax.twinx()\n", + "ax2.plot(np.arange(40),model.get_layer(\"conv2\").weights[0][:,:,2], \"r\")" + ], + "metadata": { + "id": "uveifoEV8OUU", + "outputId": "08b39943-99fa-4055-d306-b92f784c62d7", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 260 + } + }, + "id": "uveifoEV8OUU", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 146 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "model.get_layer(\"conv2\").weights[0][:,:,0].shape" + ], + "metadata": { + "id": "a2lKpEYu1LjZ", + "outputId": "228b1416-b9f3-4eea-a557-70bc72714bf1", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "a2lKpEYu1LjZ", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "TensorShape([40, 1])" + ] + }, + "metadata": {}, + "execution_count": 126 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "gl5foXzj5_EU" + }, + "id": "gl5foXzj5_EU", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model.get_layer(\"conv2\").weights[0]" + ], + "metadata": { + "id": "qMRXBlrt5xPT", + "outputId": "243bf6e3-1385-469f-cbcc-1f9288b65410", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "qMRXBlrt5xPT", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "TensorShape([40, 1, 3])" + ] + }, + "metadata": {}, + "execution_count": 130 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.plot(model.get_layer(\"conv2\").weights[0][:,:,2])" + ], + "metadata": { + "id": "XgROt0J-3SgG", + "outputId": "fb48329b-e791-4039-bc71-a8e0e8ccabde", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 283 + } + }, + "id": "XgROt0J-3SgG", + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 132 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b5e5e9c-1bd5-426c-a829-7b5d2ca2bb8a", + "metadata": { + "id": "9b5e5e9c-1bd5-426c-a829-7b5d2ca2bb8a" + }, + "outputs": [], + "source": [ + "y_hat = model.predict(X_test)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d25ddad0-d812-4fbb-a893-4da48f323a0c", + "metadata": { + "id": "d25ddad0-d812-4fbb-a893-4da48f323a0c" + }, + "outputs": [], + "source": [ + "from sklearn.metrics import roc_curve\n", + "from sklearn.metrics import roc_auc_score" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "83b111ad-5e34-484b-91b2-6aa390ead690", + "metadata": { + "id": "83b111ad-5e34-484b-91b2-6aa390ead690" + }, + "outputs": [], + "source": [ + "cm = confusion_matrix(y_test,(y_hat>0.5)*1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40b249b1-2016-4e8a-8d46-86704394428f", + "metadata": { + "id": "40b249b1-2016-4e8a-8d46-86704394428f" + }, + "outputs": [], + "source": [ + "cmn = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "508b4903-ea75-4fff-bdf2-00b4e0a402e8", + "metadata": { + "id": "508b4903-ea75-4fff-bdf2-00b4e0a402e8" + }, + "outputs": [], + "source": [ + "df_cm = pd.DataFrame(cm)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c78bd277-df44-4542-8de2-931961c9d312", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c78bd277-df44-4542-8de2-931961c9d312", + "outputId": "a31f9539-db25-487b-d3b5-ed11bc9f8e7b" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9135903743926352" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "roc_auc_score(y_test,y_hat)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eead1308-33f7-4bff-9126-11594c7a4e7b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 295 + }, + "id": "eead1308-33f7-4bff-9126-11594c7a4e7b", + "outputId": "8e6e30a6-c4c7-47ea-a282-facb0913dd8f" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "roc_score = roc_auc_score(y_test,y_hat)\n", + "fpr, tpr, thresholds = roc_curve(y_test,y_hat)\n", + "plt.title(\"MI/Normal ROC={}\".format(round(roc_score,2)))\n", + "plt.plot(fpr,tpr)\n", + "plt.ylabel('True Positive Rate')\n", + "plt.xlabel('False Positive Rate')\n", + "plt.savefig(\"ROC_mi_vs_all.png\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19c3f7a0-19f0-4f65-babb-f30ec45c298b", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 497 + }, + "id": "19c3f7a0-19f0-4f65-babb-f30ec45c298b", + "outputId": "5f591ad6-7658-47fd-8578-cb65e6a04c6b" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,8))\n", + "sns.heatmap(df_cm, annot=True, cmap=\"Blues\",fmt='.0f',xticklabels=[\"Normal\",\"MI\"], yticklabels=[\"Normal\",\"MI\"])\n", + "plt.ylabel('Actual')\n", + "plt.xlabel('Predicted')\n", + "plt.savefig(\"conf_matrix_mi_vs_all.png\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bb1bf812-2daf-4033-825f-81b002f14ca0", + "metadata": { + "id": "bb1bf812-2daf-4033-825f-81b002f14ca0" + }, + "outputs": [], + "source": [ + "y_predicted_bin = ((y_hat>0.5)*1).ravel()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70284675-f2f5-4b99-a371-c823e21e5dbc", + "metadata": { + "id": "70284675-f2f5-4b99-a371-c823e21e5dbc" + }, + "outputs": [], + "source": [ + "tp = []\n", + "fp = []\n", + "tn = []\n", + "fn = []\n", + "for i, j in enumerate(zip(y_predicted_bin, y_test.astype(int))):\n", + " true = j[1]\n", + " predicted = j[0]\n", + " if (predicted == 1) and (true == 1):\n", + " tp.append(i)\n", + " elif (predicted == 0) and (true == 0):\n", + " tn.append(i)\n", + " elif (predicted == 1) and (true == 0):\n", + " fp.append(i)\n", + " elif (predicted == 0) and (true == 1):\n", + " fn.append(i)\n", + " else:\n", + " print(\"something went wrong\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f9aebfd8-30f6-41cd-a589-7a2e47c7c5fd", + "metadata": { + "id": "f9aebfd8-30f6-41cd-a589-7a2e47c7c5fd" + }, + "outputs": [], + "source": [ + "tp_diag = np.zeros(len(df.iloc[:,0]))\n", + "\n", + "for j in idx_test[tp]:\n", + " for k in labels.scp_codes[j]:\n", + " for l , m in enumerate(df.iloc[:,0]):\n", + " if k == m:\n", + " tp_diag[l] += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56adb106-aaa6-402c-9d6b-5a9e3a876688", + "metadata": { + "id": "56adb106-aaa6-402c-9d6b-5a9e3a876688" + }, + "outputs": [], + "source": [ + "tn_diag = np.zeros(len(df.iloc[:,0]))\n", + "\n", + "for j in idx_test[tn]:\n", + " for k in labels.scp_codes[j]:\n", + " for l , m in enumerate(df.iloc[:,0]):\n", + " if k == m:\n", + " tn_diag[l] += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb776b46-3bad-4bb5-a9d9-cbbfd461f57e", + "metadata": { + "id": "eb776b46-3bad-4bb5-a9d9-cbbfd461f57e" + }, + "outputs": [], + "source": [ + "fn_diag = np.zeros(len(df.iloc[:,0]))\n", + "\n", + "for j in idx_test[fn]:\n", + " for k in labels.scp_codes[j]:\n", + " for l , m in enumerate(df.iloc[:,0]):\n", + " if k == m:\n", + " fn_diag[l] += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76a591da-405b-48bc-ba66-27a352a0f60a", + "metadata": { + "id": "76a591da-405b-48bc-ba66-27a352a0f60a" + }, + "outputs": [], + "source": [ + "fp_diag = np.zeros(len(df.iloc[:,0]))\n", + "\n", + "for j in idx_test[fp]:\n", + " for k in labels.scp_codes[j]:\n", + " for l , m in enumerate(df.iloc[:,0]):\n", + " if k == m:\n", + " fp_diag[l] += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "433b2055-b988-419a-9754-85371eddbb8d", + "metadata": { + "id": "433b2055-b988-419a-9754-85371eddbb8d" + }, + "outputs": [], + "source": [ + "results = pd.DataFrame({\"Diagnose\":df.description, \"tp\":tp_diag.astype(int), \"tn\":tn_diag.astype(int), \"fp\":fp_diag.astype(int), \"fn\":fn_diag.astype(int)})" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a49bce11-2d7d-4f80-a87b-b0e479c4af00", + "metadata": { + "id": "a49bce11-2d7d-4f80-a87b-b0e479c4af00" + }, + "outputs": [], + "source": [ + "results[\"Sensitivity\"] = results[\"tp\"]/(results[\"tp\"]+results[\"fn\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39766202-4eb1-4337-aa7b-531ecba7b43f", + "metadata": { + "id": "39766202-4eb1-4337-aa7b-531ecba7b43f" + }, + "outputs": [], + "source": [ + "results[\"Specifisity\"] = results[\"tn\"]/(results[\"tn\"]+results[\"fp\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb47a59a-3e64-4756-a5d7-aef5339c18e2", + "metadata": { + "id": "eb47a59a-3e64-4756-a5d7-aef5339c18e2" + }, + "outputs": [], + "source": [ + "results[\"Precision (PPV)\"] = results[\"tp\"]/(results[\"tp\"]+results[\"fp\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0af17f88-9d3f-4e05-b3e1-aea3ddb1356c", + "metadata": { + "id": "0af17f88-9d3f-4e05-b3e1-aea3ddb1356c" + }, + "outputs": [], + "source": [ + "results.to_csv(\"subdiag.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "SlX6WKtojmgk", + "metadata": { + "id": "SlX6WKtojmgk" + }, + "outputs": [], + "source": [ + "infarction_list = [\"inferior myocardial infarction\",\"anteroseptal myocardial infarction\", \"anterior myocardial infarction\",\n", + " \"lateral myocardial infarction\",\"anterolateral myocardial infarction\",\"inferolateral myocardial infarction\",\n", + " \"inferoposterolateral myocardial infarction\",\"posterior myocardial infarction\"]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "WlOqoR3Ti4GA", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WlOqoR3Ti4GA", + "outputId": "bf49ed94-04d4-43f7-cbdf-4a9c8d5738dc" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Diagnose inferior myocardial infarction\n", + "tp 614\n", + "tn 0\n", + "fp 0\n", + "fn 262\n", + "Sensitivity 0.700913\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 5, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose anteroseptal myocardial infarction\n", + "tp 605\n", + "tn 0\n", + "fp 0\n", + "fn 170\n", + "Sensitivity 0.780645\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 6, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose anterior myocardial infarction\n", + "tp 56\n", + "tn 0\n", + "fp 0\n", + "fn 63\n", + "Sensitivity 0.470588\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 18, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose lateral myocardial infarction\n", + "tp 31\n", + "tn 0\n", + "fp 0\n", + "fn 36\n", + "Sensitivity 0.462687\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 22, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose anterolateral myocardial infarction\n", + "tp 73\n", + "tn 0\n", + "fp 0\n", + "fn 24\n", + "Sensitivity 0.752577\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 19, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose inferolateral myocardial infarction\n", + "tp 124\n", + "tn 0\n", + "fp 0\n", + "fn 20\n", + "Sensitivity 0.861111\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 16, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose inferoposterolateral myocardial infarction\n", + "tp 8\n", + "tn 0\n", + "fp 0\n", + "fn 7\n", + "Sensitivity 0.533333\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 34, dtype: object\n", + "-----------------------\n", + "-----------------------\n", + "Diagnose posterior myocardial infarction\n", + "tp 2\n", + "tn 0\n", + "fp 0\n", + "fn 2\n", + "Sensitivity 0.5\n", + "Specifisity NaN\n", + "Precision (PPV) 1.0\n", + "Name: 40, dtype: object\n", + "-----------------------\n", + "-----------------------\n" + ] + } + ], + "source": [ + "for mi_type in infarction_list:\n", + " print(results.iloc[np.where(results[\"Diagnose\"]==mi_type)[0][0]])\n", + " print(\"-----------------------\")\n", + " print(\"-----------------------\")" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "machine_shape": "hm", + "name": "MI_detection_PTB-XL.ipynb", + "provenance": [] + }, + "environment": { + "kernel": "python3", + "name": "tf2-gpu.2-8.m93", + "type": "gcloud", + "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-8:m93" + }, + "gpuClass": "standard", + "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.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/run_experiments_in_colab.ipynb b/run_experiments_in_colab.ipynb new file mode 100644 index 0000000..396550d --- /dev/null +++ b/run_experiments_in_colab.ipynb @@ -0,0 +1,3490 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "GRmi1FbhCDW0", + "outputId": "558dcb43-c029-4188-a28d-df1c660fd35a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting GitPython\n", + " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", + "\u001b[K |████████████████████████████████| 181 kB 5.1 MB/s \n", + "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", + "Collecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", + "\u001b[K |████████████████████████████████| 63 kB 1.8 MB/s \n", + "\u001b[?25hCollecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Installing collected packages: smmap, gitdb, GitPython\n", + "Successfully installed GitPython-3.1.27 gitdb-4.0.9 smmap-5.0.0\n" + ] + } + ], + "source": [ + "!pip install GitPython\n", + "from git import Repo" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "SdNtLojfCO2W" + }, + "outputs": [], + "source": [ + "access_token = \"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\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "BQL6lPD0CVgh" + }, + "outputs": [], + "source": [ + "HTTPS_REMOTE_URL = 'https://' + access_token + ':x-oauth-basic@github.com/Bsingstad/Heart-murmur-detection-2022-private'\n", + "DEST_NAME = 'heart_murmurs'\n", + "cloned_repo = Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FBMgQeTjCkuf", + "outputId": "8bcd7a5d-3ccc-4d3d-8d18-10582d400ce4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting wget\n", + " Downloading wget-3.2.zip (10 kB)\n", + "Building wheels for collected packages: wget\n", + " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=edc1e747f83f30e3437bfd478b4f4acdfd92ff3786219f60cb63f01b300cd2a3\n", + " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", + "Successfully built wget\n", + "Installing collected packages: wget\n", + "Successfully installed wget-3.2\n" + ] + } + ], + "source": [ + "!pip install wget" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bQuh1VhrC39v", + "outputId": "7fd17e03-5de0-4ed3-fc92-aabea959c7b8" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "kaggle.json\n", + "/bin/bash: -c: line 0: unexpected EOF while looking for matching `''\n", + "/bin/bash: -c: line 1: syntax error: unexpected end of file\n" + ] + } + ], + "source": [ + "!mkdir -p ~/.kaggle\n", + "!cp kaggle.json ~/.kaggle/\n", + "!ls ~/.kaggle\n", + "!chmod 600 /root/.kaggle/kaggle.json'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sW10TQKSC1MW", + "outputId": "c8396f9f-98d6-43e6-af61-0be5bf078d5f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /root/.kaggle/kaggle.json'\n", + "Downloading the-circor-digiscope-phonocardiogram-dataset-v2.zip to /content\n", + " 98% 441M/449M [00:04<00:00, 84.2MB/s]\n", + "100% 449M/449M [00:05<00:00, 93.6MB/s]\n" + ] + } + ], + "source": [ + "!kaggle datasets download -d bjoernjostein/the-circor-digiscope-phonocardiogram-dataset-v2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "uiitcpLxDBWm" + }, + "outputs": [], + "source": [ + "import os, zipfile\n", + "try:\n", + " os.mkdir(\"/content/data/\")\n", + "except:\n", + " print(\"data folder allready exists\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "nKKUjHdSQqym" + }, + "outputs": [], + "source": [ + "import os, zipfile\n", + "\n", + "dir_name = \"/content/\"\n", + "target_dir = \"/content/data/\"\n", + "extension = \".zip\"\n", + " \n", + "os.chdir(dir_name) # change directory from working dir to dir with files\n", + "\n", + "for item in os.listdir(dir_name): # loop through items in dir\n", + " if item.endswith(extension): # check for \".zip\" extension\n", + " file_name = os.path.abspath(item) # get full path of files\n", + " zip_ref = zipfile.ZipFile(file_name) # create zipfile object\n", + " zip_ref.extractall(target_dir) # extract file to dir\n", + " zip_ref.close() # close file\n", + " os.remove(file_name) # delete zipped file" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "CWiDsltwE-rg" + }, + "outputs": [], + "source": [ + "os.mknod(\"/content/heart_murmurs/__init__.py\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "H4vxg6fhmoLP" + }, + "outputs": [], + "source": [ + "def replace_line(file_name, line_num, text):\n", + " lines = open(file_name, 'r').readlines()\n", + " lines[line_num] = text\n", + " out = open(file_name, 'w')\n", + " out.writelines(lines)\n", + " out.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "5QunscIlmr3y" + }, + "outputs": [], + "source": [ + "replace_line('/content/heart_murmurs/run_model.py',12,\"from .helper_code import * \\n\")\n", + "replace_line('/content/heart_murmurs/run_model.py',13,\"from .team_code import load_challenge_model, run_challenge_model \\n\")\n", + "replace_line('/content/heart_murmurs/cross_validate.py',15,\"from .helper_code import * \\n\")\n", + "replace_line('/content/heart_murmurs/evaluate_model.py',16,\"from .helper_code import load_patient_data, get_murmur, get_outcome, load_challenge_outputs, compare_strings \\n\")\n", + "replace_line('/content/heart_murmurs/cross_validate.py',16,\"from .team_code import base_model, load_challenge_model, build_murmur_model, build_clinical_model, scheduler, scheduler_2, get_murmur_locations, pad_array, calculating_class_weights \\n\")\n", + "replace_line('/content/heart_murmurs/team_code.py',11,\"from .helper_code import * \\n\")\n", + "replace_line('/content/heart_murmurs/train_model.py',11,\"from .helper_code import is_integer \\n\")\n", + "replace_line('/content/heart_murmurs/train_model.py',12,\"from .team_code import train_challenge_model \\n\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "1o9J_FbaGCxu" + }, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload\n", + "%reload_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "eVbI2ZbZDyWA" + }, + "outputs": [], + "source": [ + "from heart_murmurs.helper_code import *\n", + "\n", + "# have to add a \".\" in from of the module imports (in the scrips:train_model, run_model and team_code )\n", + "from heart_murmurs.train_model import *\n", + "from heart_murmurs.run_model import *\n", + "from heart_murmurs.team_code import *\n", + "from heart_murmurs.evaluate_model import *\n", + "from heart_murmurs.cross_validate import *" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "dST5oXOMKdtX" + }, + "outputs": [], + "source": [ + "try:\n", + " os.mkdir(\"/content/models/\")\n", + "except:\n", + " print(\"model folder allreadu exists\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "AxvEca5vsn53" + }, + "outputs": [], + "source": [ + "try:\n", + " os.mkdir(\"/content/results/\")\n", + "except:\n", + " print(\"results folder allreadu exists\")" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": { + "id": "Q50bbXJ6jory" + }, + "outputs": [], + "source": [ + "FOLDS = 5" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3r7SoYdFslCZ", + "outputId": "365354a9-147a-4a82-c8a4-c969f91b5374" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 942/942 [00:00<00:00, 3230.05it/s]\n", + "100%|██████████| 628/628 [00:12<00:00, 51.97it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of signals in training data = 2156\n", + "Murmurs prevalence:\n", + "Present = 387, Unknown = 117, Absent = 1652\n", + "Outcomes prevalence:\n", + "Abnormal = 1039, Normal = 1117\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 314/314 [00:07<00:00, 39.59it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of signals in validation data = 1007\n", + "Murmurs prevalence:\n", + "Present = 229, Unknown = 39, Absent = 739\n", + "Outcomes prevalence:\n", + "Abnormal = 492, Normal = 515\n", + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train murmur model..\n", + "Epoch 1/25\n", + " 6/108 [>.............................] - ETA: 36s - loss: 1.4830 - categorical_accuracy: 0.7417 - auc_7: 0.8171WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1604s vs `on_train_batch_end` time: 0.1611s). Check your callbacks.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1604s vs `on_train_batch_end` time: 0.1611s). Check your callbacks.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "108/108 [==============================] - 51s 403ms/step - loss: 1.6262 - categorical_accuracy: 0.3660 - auc_7: 0.5727 - val_loss: 2.9565 - val_categorical_accuracy: 0.0497 - val_auc_7: 0.2538 - lr: 0.0010\n", + "Epoch 2/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.5068 - categorical_accuracy: 0.3590 - auc_7: 0.5908 - val_loss: 2.8850 - val_categorical_accuracy: 0.2284 - val_auc_7: 0.5457 - lr: 0.0010\n", + "Epoch 3/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.4657 - categorical_accuracy: 0.3738 - auc_7: 0.6130 - val_loss: 1.5429 - val_categorical_accuracy: 0.2105 - val_auc_7: 0.4581 - lr: 0.0010\n", + "Epoch 4/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.4445 - categorical_accuracy: 0.3465 - auc_7: 0.6043 - val_loss: 2.1160 - val_categorical_accuracy: 0.2175 - val_auc_7: 0.4308 - lr: 0.0010\n", + "Epoch 5/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.4504 - categorical_accuracy: 0.3724 - auc_7: 0.6230 - val_loss: 1.5270 - val_categorical_accuracy: 0.2254 - val_auc_7: 0.5707 - lr: 0.0010\n", + "Epoch 6/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.4461 - categorical_accuracy: 0.3780 - auc_7: 0.6280 - val_loss: 1.0965 - val_categorical_accuracy: 0.3644 - val_auc_7: 0.5888 - lr: 0.0010\n", + "Epoch 7/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.3835 - categorical_accuracy: 0.3970 - auc_7: 0.6477 - val_loss: 1.0574 - val_categorical_accuracy: 0.3307 - val_auc_7: 0.6113 - lr: 0.0010\n", + "Epoch 8/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.4098 - categorical_accuracy: 0.3975 - auc_7: 0.6342 - val_loss: 0.8962 - val_categorical_accuracy: 0.5770 - val_auc_7: 0.7556 - lr: 0.0010\n", + "Epoch 9/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 1.4223 - categorical_accuracy: 0.3641 - auc_7: 0.6296 - val_loss: 1.4460 - val_categorical_accuracy: 0.3555 - val_auc_7: 0.5726 - lr: 0.0010\n", + "Epoch 10/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 1.4148 - categorical_accuracy: 0.4003 - auc_7: 0.6378 - val_loss: 0.6591 - val_categorical_accuracy: 0.7219 - val_auc_7: 0.8664 - lr: 0.0010\n", + "Epoch 11/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.3702 - categorical_accuracy: 0.3966 - auc_7: 0.6429 - val_loss: 1.0389 - val_categorical_accuracy: 0.4826 - val_auc_7: 0.6712 - lr: 1.0000e-04\n", + "Epoch 12/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.3053 - categorical_accuracy: 0.4365 - auc_7: 0.6774 - val_loss: 1.0658 - val_categorical_accuracy: 0.4359 - val_auc_7: 0.6399 - lr: 1.0000e-04\n", + "Epoch 13/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.3054 - categorical_accuracy: 0.4332 - auc_7: 0.6760 - val_loss: 0.8949 - val_categorical_accuracy: 0.5720 - val_auc_7: 0.7495 - lr: 1.0000e-04\n", + "Epoch 14/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 1.2929 - categorical_accuracy: 0.4559 - auc_7: 0.6893 - val_loss: 0.9381 - val_categorical_accuracy: 0.5571 - val_auc_7: 0.7288 - lr: 1.0000e-04\n", + "Epoch 15/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 1.2780 - categorical_accuracy: 0.4494 - auc_7: 0.6880 - val_loss: 0.9859 - val_categorical_accuracy: 0.5084 - val_auc_7: 0.7010 - lr: 1.0000e-04\n", + "Epoch 16/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.2644 - categorical_accuracy: 0.4754 - auc_7: 0.7023 - val_loss: 0.9688 - val_categorical_accuracy: 0.5333 - val_auc_7: 0.7155 - lr: 1.0000e-05\n", + "Epoch 17/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.2584 - categorical_accuracy: 0.4842 - auc_7: 0.7121 - val_loss: 0.9519 - val_categorical_accuracy: 0.5472 - val_auc_7: 0.7266 - lr: 1.0000e-05\n", + "Epoch 18/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.2561 - categorical_accuracy: 0.4814 - auc_7: 0.7059 - val_loss: 0.9621 - val_categorical_accuracy: 0.5402 - val_auc_7: 0.7181 - lr: 1.0000e-05\n", + "Epoch 19/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.2434 - categorical_accuracy: 0.4745 - auc_7: 0.7107 - val_loss: 0.9222 - val_categorical_accuracy: 0.5591 - val_auc_7: 0.7424 - lr: 1.0000e-05\n", + "Epoch 20/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.2422 - categorical_accuracy: 0.4638 - auc_7: 0.7061 - val_loss: 0.9263 - val_categorical_accuracy: 0.5571 - val_auc_7: 0.7394 - lr: 1.0000e-05\n", + "Epoch 21/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 1.2430 - categorical_accuracy: 0.4754 - auc_7: 0.7060 - val_loss: 0.9270 - val_categorical_accuracy: 0.5571 - val_auc_7: 0.7392 - lr: 1.0000e-06\n", + "Epoch 22/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 1.2540 - categorical_accuracy: 0.4722 - auc_7: 0.7085 - val_loss: 0.9381 - val_categorical_accuracy: 0.5531 - val_auc_7: 0.7342 - lr: 1.0000e-06\n", + "Epoch 23/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 1.2484 - categorical_accuracy: 0.4754 - auc_7: 0.7080 - val_loss: 0.9323 - val_categorical_accuracy: 0.5541 - val_auc_7: 0.7374 - lr: 1.0000e-06\n", + "Epoch 24/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 1.2555 - categorical_accuracy: 0.4680 - auc_7: 0.7057 - val_loss: 0.9325 - val_categorical_accuracy: 0.5551 - val_auc_7: 0.7372 - lr: 1.0000e-06\n", + "Epoch 25/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 1.2460 - categorical_accuracy: 0.4685 - auc_7: 0.7069 - val_loss: 0.9290 - val_categorical_accuracy: 0.5531 - val_auc_7: 0.7378 - lr: 1.0000e-06\n", + "Train clinical model..\n", + "Epoch 1/25\n", + "108/108 [==============================] - 52s 408ms/step - loss: 0.6729 - binary_accuracy: 0.5297 - auc_6: 0.5388 - val_loss: 0.7240 - val_binary_accuracy: 0.4836 - val_auc_6: 0.5877 - lr: 0.0010\n", + "Epoch 2/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6669 - binary_accuracy: 0.5306 - auc_6: 0.5298 - val_loss: 0.6951 - val_binary_accuracy: 0.5382 - val_auc_6: 0.5979 - lr: 0.0010\n", + "Epoch 3/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6659 - binary_accuracy: 0.5325 - auc_6: 0.5443 - val_loss: 0.7135 - val_binary_accuracy: 0.5055 - val_auc_6: 0.3981 - lr: 0.0010\n", + "Epoch 4/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6634 - binary_accuracy: 0.5529 - auc_6: 0.5556 - val_loss: 0.7236 - val_binary_accuracy: 0.5313 - val_auc_6: 0.5772 - lr: 0.0010\n", + "Epoch 5/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6636 - binary_accuracy: 0.5413 - auc_6: 0.5512 - val_loss: 0.6917 - val_binary_accuracy: 0.5571 - val_auc_6: 0.5819 - lr: 0.0010\n", + "Epoch 6/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6668 - binary_accuracy: 0.5278 - auc_6: 0.5337 - val_loss: 0.9372 - val_binary_accuracy: 0.4886 - val_auc_6: 0.5862 - lr: 0.0010\n", + "Epoch 7/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6634 - binary_accuracy: 0.5422 - auc_6: 0.5481 - val_loss: 1.1713 - val_binary_accuracy: 0.5015 - val_auc_6: 0.4050 - lr: 0.0010\n", + "Epoch 8/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6605 - binary_accuracy: 0.5501 - auc_6: 0.5692 - val_loss: 0.7502 - val_binary_accuracy: 0.5074 - val_auc_6: 0.5920 - lr: 0.0010\n", + "Epoch 9/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6550 - binary_accuracy: 0.5659 - auc_6: 0.5885 - val_loss: 2.6182 - val_binary_accuracy: 0.5114 - val_auc_6: 0.4207 - lr: 0.0010\n", + "Epoch 10/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6519 - binary_accuracy: 0.5622 - auc_6: 0.5917 - val_loss: 0.7772 - val_binary_accuracy: 0.4846 - val_auc_6: 0.5799 - lr: 0.0010\n", + "Epoch 11/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 0.6389 - binary_accuracy: 0.6076 - auc_6: 0.6387 - val_loss: 0.7256 - val_binary_accuracy: 0.5065 - val_auc_6: 0.5516 - lr: 1.0000e-04\n", + "Epoch 12/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6359 - binary_accuracy: 0.6048 - auc_6: 0.6450 - val_loss: 0.7171 - val_binary_accuracy: 0.5174 - val_auc_6: 0.5591 - lr: 1.0000e-04\n", + "Epoch 13/25\n", + "108/108 [==============================] - 42s 390ms/step - loss: 0.6296 - binary_accuracy: 0.6160 - auc_6: 0.6552 - val_loss: 0.7183 - val_binary_accuracy: 0.5104 - val_auc_6: 0.5391 - lr: 1.0000e-04\n", + "Epoch 14/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6275 - binary_accuracy: 0.6224 - auc_6: 0.6595 - val_loss: 0.7256 - val_binary_accuracy: 0.5184 - val_auc_6: 0.5392 - lr: 1.0000e-04\n", + "Epoch 15/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6237 - binary_accuracy: 0.6252 - auc_6: 0.6666 - val_loss: 0.7595 - val_binary_accuracy: 0.5065 - val_auc_6: 0.5189 - lr: 1.0000e-04\n", + "Epoch 16/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6177 - binary_accuracy: 0.6248 - auc_6: 0.6785 - val_loss: 0.7494 - val_binary_accuracy: 0.5055 - val_auc_6: 0.5400 - lr: 1.0000e-05\n", + "Epoch 17/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6132 - binary_accuracy: 0.6405 - auc_6: 0.6854 - val_loss: 0.7500 - val_binary_accuracy: 0.5104 - val_auc_6: 0.5397 - lr: 1.0000e-05\n", + "Epoch 18/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6083 - binary_accuracy: 0.6322 - auc_6: 0.6921 - val_loss: 0.7560 - val_binary_accuracy: 0.5164 - val_auc_6: 0.5460 - lr: 1.0000e-05\n", + "Epoch 19/25\n", + "108/108 [==============================] - 42s 391ms/step - loss: 0.6124 - binary_accuracy: 0.6224 - auc_6: 0.6852 - val_loss: 0.7566 - val_binary_accuracy: 0.5124 - val_auc_6: 0.5442 - lr: 1.0000e-05\n", + "Epoch 20/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 0.6075 - binary_accuracy: 0.6331 - auc_6: 0.6944 - val_loss: 0.7579 - val_binary_accuracy: 0.5114 - val_auc_6: 0.5481 - lr: 1.0000e-05\n", + "Epoch 21/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 0.6095 - binary_accuracy: 0.6327 - auc_6: 0.6898 - val_loss: 0.7595 - val_binary_accuracy: 0.5124 - val_auc_6: 0.5475 - lr: 1.0000e-06\n", + "Epoch 22/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 0.6117 - binary_accuracy: 0.6266 - auc_6: 0.6853 - val_loss: 0.7594 - val_binary_accuracy: 0.5084 - val_auc_6: 0.5462 - lr: 1.0000e-06\n", + "Epoch 23/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 0.6100 - binary_accuracy: 0.6359 - auc_6: 0.6900 - val_loss: 0.7595 - val_binary_accuracy: 0.5074 - val_auc_6: 0.5459 - lr: 1.0000e-06\n", + "Epoch 24/25\n", + "108/108 [==============================] - 42s 392ms/step - loss: 0.6088 - binary_accuracy: 0.6410 - auc_6: 0.6932 - val_loss: 0.7603 - val_binary_accuracy: 0.5074 - val_auc_6: 0.5453 - lr: 1.0000e-06\n", + "Epoch 25/25\n", + "108/108 [==============================] - 42s 393ms/step - loss: 0.6085 - binary_accuracy: 0.6401 - auc_6: 0.6903 - val_loss: 0.7612 - val_binary_accuracy: 0.5094 - val_auc_6: 0.5451 - lr: 1.0000e-06\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 628/628 [00:13<00:00, 45.51it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of signals in training data = 2071\n", + "Murmurs prevalence:\n", + "Present = 445, Unknown = 96, Absent = 1530\n", + "Outcomes prevalence:\n", + "Abnormal = 999, Normal = 1072\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 314/314 [00:06<00:00, 46.08it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of signals in validation data = 1092\n", + "Murmurs prevalence:\n", + "Present = 171, Unknown = 60, Absent = 861\n", + "Outcomes prevalence:\n", + "Abnormal = 532, Normal = 560\n", + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train murmur model..\n", + "Epoch 1/25\n", + "104/104 [==============================] - 52s 416ms/step - loss: 1.6239 - categorical_accuracy: 0.3240 - auc_9: 0.5723 - val_loss: 2.0363 - val_categorical_accuracy: 0.1355 - val_auc_9: 0.2385 - lr: 0.0010\n", + "Epoch 2/25\n", + "104/104 [==============================] - 41s 397ms/step - loss: 1.5970 - categorical_accuracy: 0.3404 - auc_9: 0.5831 - val_loss: 1.0049 - val_categorical_accuracy: 0.2436 - val_auc_9: 0.5647 - lr: 0.0010\n", + "Epoch 3/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.5708 - categorical_accuracy: 0.3187 - auc_9: 0.5628 - val_loss: 1.1902 - val_categorical_accuracy: 0.3233 - val_auc_9: 0.4790 - lr: 0.0010\n", + "Epoch 4/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.5508 - categorical_accuracy: 0.4211 - auc_9: 0.6165 - val_loss: 1.5939 - val_categorical_accuracy: 0.1566 - val_auc_9: 0.5500 - lr: 0.0010\n", + "Epoch 5/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.5428 - categorical_accuracy: 0.3713 - auc_9: 0.5905 - val_loss: 0.7431 - val_categorical_accuracy: 0.6896 - val_auc_9: 0.8513 - lr: 0.0010\n", + "Epoch 6/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.5171 - categorical_accuracy: 0.3742 - auc_9: 0.5970 - val_loss: 2.0348 - val_categorical_accuracy: 0.1218 - val_auc_9: 0.1880 - lr: 0.0010\n", + "Epoch 7/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.5334 - categorical_accuracy: 0.3950 - auc_9: 0.6084 - val_loss: 0.6989 - val_categorical_accuracy: 0.7005 - val_auc_9: 0.8601 - lr: 0.0010\n", + "Epoch 8/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.5307 - categorical_accuracy: 0.3901 - auc_9: 0.6193 - val_loss: 0.9616 - val_categorical_accuracy: 0.4176 - val_auc_9: 0.6744 - lr: 0.0010\n", + "Epoch 9/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.5025 - categorical_accuracy: 0.3844 - auc_9: 0.6112 - val_loss: 1.1782 - val_categorical_accuracy: 0.1877 - val_auc_9: 0.5523 - lr: 0.0010\n", + "Epoch 10/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.4727 - categorical_accuracy: 0.4428 - auc_9: 0.6611 - val_loss: 1.1140 - val_categorical_accuracy: 0.3489 - val_auc_9: 0.6072 - lr: 0.0010\n", + "Epoch 11/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 1.4036 - categorical_accuracy: 0.4182 - auc_9: 0.6168 - val_loss: 0.8558 - val_categorical_accuracy: 0.5788 - val_auc_9: 0.7910 - lr: 1.0000e-04\n", + "Epoch 12/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.3689 - categorical_accuracy: 0.4906 - auc_9: 0.6943 - val_loss: 0.9171 - val_categorical_accuracy: 0.5110 - val_auc_9: 0.7215 - lr: 1.0000e-04\n", + "Epoch 13/25\n", + "104/104 [==============================] - 41s 397ms/step - loss: 1.3776 - categorical_accuracy: 0.4853 - auc_9: 0.6875 - val_loss: 0.9968 - val_categorical_accuracy: 0.4386 - val_auc_9: 0.6396 - lr: 1.0000e-04\n", + "Epoch 14/25\n", + "104/104 [==============================] - 41s 398ms/step - loss: 1.3549 - categorical_accuracy: 0.4766 - auc_9: 0.6846 - val_loss: 0.9546 - val_categorical_accuracy: 0.4753 - val_auc_9: 0.6817 - lr: 1.0000e-04\n", + "Epoch 15/25\n", + "104/104 [==============================] - 41s 398ms/step - loss: 1.3206 - categorical_accuracy: 0.4737 - auc_9: 0.6983 - val_loss: 0.9162 - val_categorical_accuracy: 0.4954 - val_auc_9: 0.7215 - lr: 1.0000e-04\n", + "Epoch 16/25\n", + "104/104 [==============================] - 41s 397ms/step - loss: 1.3220 - categorical_accuracy: 0.4631 - auc_9: 0.6802 - val_loss: 0.9933 - val_categorical_accuracy: 0.4451 - val_auc_9: 0.6454 - lr: 1.0000e-05\n", + "Epoch 17/25\n", + "104/104 [==============================] - 41s 398ms/step - loss: 1.3061 - categorical_accuracy: 0.4848 - auc_9: 0.6881 - val_loss: 0.9765 - val_categorical_accuracy: 0.4515 - val_auc_9: 0.6595 - lr: 1.0000e-05\n", + "Epoch 18/25\n", + "104/104 [==============================] - 41s 397ms/step - loss: 1.3168 - categorical_accuracy: 0.4698 - auc_9: 0.6891 - val_loss: 0.9848 - val_categorical_accuracy: 0.4505 - val_auc_9: 0.6492 - lr: 1.0000e-05\n", + "Epoch 19/25\n", + "104/104 [==============================] - 41s 397ms/step - loss: 1.3140 - categorical_accuracy: 0.4713 - auc_9: 0.6869 - val_loss: 0.9805 - val_categorical_accuracy: 0.4542 - val_auc_9: 0.6538 - lr: 1.0000e-05\n", + "Epoch 20/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.3247 - categorical_accuracy: 0.4843 - auc_9: 0.6969 - val_loss: 0.9690 - val_categorical_accuracy: 0.4707 - val_auc_9: 0.6685 - lr: 1.0000e-05\n", + "Epoch 21/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.3122 - categorical_accuracy: 0.4795 - auc_9: 0.6959 - val_loss: 0.9709 - val_categorical_accuracy: 0.4716 - val_auc_9: 0.6665 - lr: 1.0000e-06\n", + "Epoch 22/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.3132 - categorical_accuracy: 0.4761 - auc_9: 0.6986 - val_loss: 0.9604 - val_categorical_accuracy: 0.4707 - val_auc_9: 0.6746 - lr: 1.0000e-06\n", + "Epoch 23/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.3090 - categorical_accuracy: 0.4848 - auc_9: 0.6982 - val_loss: 0.9573 - val_categorical_accuracy: 0.4753 - val_auc_9: 0.6766 - lr: 1.0000e-06\n", + "Epoch 24/25\n", + "104/104 [==============================] - 41s 397ms/step - loss: 1.3064 - categorical_accuracy: 0.4848 - auc_9: 0.7000 - val_loss: 0.9575 - val_categorical_accuracy: 0.4762 - val_auc_9: 0.6756 - lr: 1.0000e-06\n", + "Epoch 25/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 1.3243 - categorical_accuracy: 0.4785 - auc_9: 0.6969 - val_loss: 0.9570 - val_categorical_accuracy: 0.4762 - val_auc_9: 0.6766 - lr: 1.0000e-06\n", + "Train clinical model..\n", + "Epoch 1/25\n", + " 6/104 [>.............................] - ETA: 34s - loss: 0.6821 - binary_accuracy: 0.5250 - auc_8: 0.5121WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1810s vs `on_train_batch_end` time: 0.1835s). Check your callbacks.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1810s vs `on_train_batch_end` time: 0.1835s). Check your callbacks.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "104/104 [==============================] - 50s 415ms/step - loss: 0.6684 - binary_accuracy: 0.5505 - auc_8: 0.5541 - val_loss: 1.2279 - val_binary_accuracy: 0.4872 - val_auc_8: 0.5403 - lr: 0.0010\n", + "Epoch 2/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 0.6620 - binary_accuracy: 0.5563 - auc_8: 0.5678 - val_loss: 0.9139 - val_binary_accuracy: 0.4725 - val_auc_8: 0.5194 - lr: 0.0010\n", + "Epoch 3/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6579 - binary_accuracy: 0.5577 - auc_8: 0.5850 - val_loss: 0.7536 - val_binary_accuracy: 0.4716 - val_auc_8: 0.4302 - lr: 0.0010\n", + "Epoch 4/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6544 - binary_accuracy: 0.5678 - auc_8: 0.5939 - val_loss: 0.7220 - val_binary_accuracy: 0.4753 - val_auc_8: 0.5015 - lr: 0.0010\n", + "Epoch 5/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6548 - binary_accuracy: 0.5606 - auc_8: 0.5905 - val_loss: 0.7249 - val_binary_accuracy: 0.5174 - val_auc_8: 0.4376 - lr: 0.0010\n", + "Epoch 6/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6527 - binary_accuracy: 0.5722 - auc_8: 0.6045 - val_loss: 0.9739 - val_binary_accuracy: 0.4844 - val_auc_8: 0.5369 - lr: 0.0010\n", + "Epoch 7/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6480 - binary_accuracy: 0.5847 - auc_8: 0.6178 - val_loss: 0.7457 - val_binary_accuracy: 0.4414 - val_auc_8: 0.4239 - lr: 0.0010\n", + "Epoch 8/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 0.6458 - binary_accuracy: 0.5939 - auc_8: 0.6219 - val_loss: 0.7250 - val_binary_accuracy: 0.4899 - val_auc_8: 0.5172 - lr: 0.0010\n", + "Epoch 9/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 0.6441 - binary_accuracy: 0.5958 - auc_8: 0.6239 - val_loss: 0.7319 - val_binary_accuracy: 0.5467 - val_auc_8: 0.5443 - lr: 0.0010\n", + "Epoch 10/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 0.6342 - binary_accuracy: 0.6026 - auc_8: 0.6472 - val_loss: 0.7365 - val_binary_accuracy: 0.5485 - val_auc_8: 0.5232 - lr: 0.0010\n", + "Epoch 11/25\n", + "104/104 [==============================] - 41s 396ms/step - loss: 0.6235 - binary_accuracy: 0.6142 - auc_8: 0.6633 - val_loss: 0.7103 - val_binary_accuracy: 0.5485 - val_auc_8: 0.5175 - lr: 1.0000e-04\n", + "Epoch 12/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6176 - binary_accuracy: 0.6205 - auc_8: 0.6683 - val_loss: 0.7142 - val_binary_accuracy: 0.5101 - val_auc_8: 0.5183 - lr: 1.0000e-04\n", + "Epoch 13/25\n", + "104/104 [==============================] - 41s 394ms/step - loss: 0.6123 - binary_accuracy: 0.6185 - auc_8: 0.6805 - val_loss: 0.7446 - val_binary_accuracy: 0.5211 - val_auc_8: 0.4713 - lr: 1.0000e-04\n", + "Epoch 14/25\n", + "104/104 [==============================] - 41s 394ms/step - loss: 0.6108 - binary_accuracy: 0.6205 - auc_8: 0.6793 - val_loss: 0.7322 - val_binary_accuracy: 0.4927 - val_auc_8: 0.4860 - lr: 1.0000e-04\n", + "Epoch 15/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6091 - binary_accuracy: 0.6475 - auc_8: 0.6934 - val_loss: 0.7267 - val_binary_accuracy: 0.5000 - val_auc_8: 0.5182 - lr: 1.0000e-04\n", + "Epoch 16/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6070 - binary_accuracy: 0.6282 - auc_8: 0.6868 - val_loss: 0.7297 - val_binary_accuracy: 0.4954 - val_auc_8: 0.5140 - lr: 1.0000e-05\n", + "Epoch 17/25\n", + "104/104 [==============================] - 41s 394ms/step - loss: 0.6035 - binary_accuracy: 0.6354 - auc_8: 0.6936 - val_loss: 0.7329 - val_binary_accuracy: 0.5000 - val_auc_8: 0.5099 - lr: 1.0000e-05\n", + "Epoch 18/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6008 - binary_accuracy: 0.6379 - auc_8: 0.6976 - val_loss: 0.7339 - val_binary_accuracy: 0.4963 - val_auc_8: 0.5134 - lr: 1.0000e-05\n", + "Epoch 19/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6014 - binary_accuracy: 0.6379 - auc_8: 0.6972 - val_loss: 0.7344 - val_binary_accuracy: 0.4954 - val_auc_8: 0.5130 - lr: 1.0000e-05\n", + "Epoch 20/25\n", + "104/104 [==============================] - 41s 394ms/step - loss: 0.6047 - binary_accuracy: 0.6345 - auc_8: 0.6933 - val_loss: 0.7351 - val_binary_accuracy: 0.4973 - val_auc_8: 0.5103 - lr: 1.0000e-05\n", + "Epoch 21/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.5993 - binary_accuracy: 0.6441 - auc_8: 0.6963 - val_loss: 0.7357 - val_binary_accuracy: 0.4927 - val_auc_8: 0.5130 - lr: 1.0000e-06\n", + "Epoch 22/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.5953 - binary_accuracy: 0.6383 - auc_8: 0.7075 - val_loss: 0.7364 - val_binary_accuracy: 0.4936 - val_auc_8: 0.5144 - lr: 1.0000e-06\n", + "Epoch 23/25\n", + "104/104 [==============================] - 41s 394ms/step - loss: 0.5985 - binary_accuracy: 0.6403 - auc_8: 0.7032 - val_loss: 0.7367 - val_binary_accuracy: 0.4936 - val_auc_8: 0.5153 - lr: 1.0000e-06\n", + "Epoch 24/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6015 - binary_accuracy: 0.6364 - auc_8: 0.6960 - val_loss: 0.7372 - val_binary_accuracy: 0.4927 - val_auc_8: 0.5148 - lr: 1.0000e-06\n", + "Epoch 25/25\n", + "104/104 [==============================] - 41s 395ms/step - loss: 0.6004 - binary_accuracy: 0.6345 - auc_8: 0.7007 - val_loss: 0.7378 - val_binary_accuracy: 0.4936 - val_auc_8: 0.5158 - lr: 1.0000e-06\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 628/628 [00:14<00:00, 44.24it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of signals in training data = 2099\n", + "Murmurs prevalence:\n", + "Present = 400, Unknown = 99, Absent = 1600\n", + "Outcomes prevalence:\n", + "Abnormal = 1024, Normal = 1075\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 314/314 [00:05<00:00, 58.96it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of signals in validation data = 1064\n", + "Murmurs prevalence:\n", + "Present = 216, Unknown = 57, Absent = 791\n", + "Outcomes prevalence:\n", + "Abnormal = 507, Normal = 557\n", + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train murmur model..\n", + "Epoch 1/25\n", + "105/105 [==============================] - 52s 414ms/step - loss: 1.5981 - categorical_accuracy: 0.2868 - auc_11: 0.5379 - val_loss: 4.5277 - val_categorical_accuracy: 0.2030 - val_auc_11: 0.4515 - lr: 0.0010\n", + "Epoch 2/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 1.5531 - categorical_accuracy: 0.3497 - auc_11: 0.5882 - val_loss: 1.1515 - val_categorical_accuracy: 0.4370 - val_auc_11: 0.6274 - lr: 0.0010\n", + "Epoch 3/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 1.5174 - categorical_accuracy: 0.3830 - auc_11: 0.6183 - val_loss: 0.9403 - val_categorical_accuracy: 0.4408 - val_auc_11: 0.6853 - lr: 0.0010\n", + "Epoch 4/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 1.4992 - categorical_accuracy: 0.3516 - auc_11: 0.5977 - val_loss: 0.9956 - val_categorical_accuracy: 0.4192 - val_auc_11: 0.6410 - lr: 0.0010\n", + "Epoch 5/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.5212 - categorical_accuracy: 0.4021 - auc_11: 0.6134 - val_loss: 0.7423 - val_categorical_accuracy: 0.7171 - val_auc_11: 0.8661 - lr: 0.0010\n", + "Epoch 6/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.4868 - categorical_accuracy: 0.3973 - auc_11: 0.6100 - val_loss: 1.6311 - val_categorical_accuracy: 0.2030 - val_auc_11: 0.3977 - lr: 0.0010\n", + "Epoch 7/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.4703 - categorical_accuracy: 0.4035 - auc_11: 0.6276 - val_loss: 0.8243 - val_categorical_accuracy: 0.5658 - val_auc_11: 0.7791 - lr: 0.0010\n", + "Epoch 8/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.4549 - categorical_accuracy: 0.4283 - auc_11: 0.6340 - val_loss: 1.3670 - val_categorical_accuracy: 0.1955 - val_auc_11: 0.3281 - lr: 0.0010\n", + "Epoch 9/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.4594 - categorical_accuracy: 0.4397 - auc_11: 0.6428 - val_loss: 1.1310 - val_categorical_accuracy: 0.2594 - val_auc_11: 0.5038 - lr: 0.0010\n", + "Epoch 10/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.4303 - categorical_accuracy: 0.4440 - auc_11: 0.6547 - val_loss: 1.2338 - val_categorical_accuracy: 0.3017 - val_auc_11: 0.5414 - lr: 0.0010\n", + "Epoch 11/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.4038 - categorical_accuracy: 0.4421 - auc_11: 0.6640 - val_loss: 1.0267 - val_categorical_accuracy: 0.3581 - val_auc_11: 0.5829 - lr: 1.0000e-04\n", + "Epoch 12/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.3647 - categorical_accuracy: 0.4555 - auc_11: 0.6787 - val_loss: 1.0040 - val_categorical_accuracy: 0.4041 - val_auc_11: 0.6243 - lr: 1.0000e-04\n", + "Epoch 13/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.3585 - categorical_accuracy: 0.4831 - auc_11: 0.6959 - val_loss: 1.1098 - val_categorical_accuracy: 0.2942 - val_auc_11: 0.5121 - lr: 1.0000e-04\n", + "Epoch 14/25\n", + "105/105 [==============================] - 42s 399ms/step - loss: 1.3221 - categorical_accuracy: 0.4697 - auc_11: 0.6911 - val_loss: 1.0959 - val_categorical_accuracy: 0.3083 - val_auc_11: 0.5334 - lr: 1.0000e-04\n", + "Epoch 15/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.3035 - categorical_accuracy: 0.4697 - auc_11: 0.6977 - val_loss: 1.0014 - val_categorical_accuracy: 0.4126 - val_auc_11: 0.6331 - lr: 1.0000e-04\n", + "Epoch 16/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 1.3085 - categorical_accuracy: 0.4864 - auc_11: 0.6990 - val_loss: 1.0763 - val_categorical_accuracy: 0.3365 - val_auc_11: 0.5620 - lr: 1.0000e-05\n", + "Epoch 17/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.2881 - categorical_accuracy: 0.4840 - auc_11: 0.7008 - val_loss: 1.0906 - val_categorical_accuracy: 0.3195 - val_auc_11: 0.5500 - lr: 1.0000e-05\n", + "Epoch 18/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 1.3003 - categorical_accuracy: 0.4931 - auc_11: 0.7030 - val_loss: 1.0964 - val_categorical_accuracy: 0.3083 - val_auc_11: 0.5442 - lr: 1.0000e-05\n", + "Epoch 19/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.2887 - categorical_accuracy: 0.4931 - auc_11: 0.7088 - val_loss: 1.0794 - val_categorical_accuracy: 0.3242 - val_auc_11: 0.5582 - lr: 1.0000e-05\n", + "Epoch 20/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 1.2946 - categorical_accuracy: 0.4802 - auc_11: 0.7036 - val_loss: 1.0894 - val_categorical_accuracy: 0.3177 - val_auc_11: 0.5496 - lr: 1.0000e-05\n", + "Epoch 21/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 1.3203 - categorical_accuracy: 0.4855 - auc_11: 0.7036 - val_loss: 1.0868 - val_categorical_accuracy: 0.3195 - val_auc_11: 0.5523 - lr: 1.0000e-06\n", + "Epoch 22/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.2649 - categorical_accuracy: 0.5021 - auc_11: 0.7121 - val_loss: 1.0910 - val_categorical_accuracy: 0.3177 - val_auc_11: 0.5486 - lr: 1.0000e-06\n", + "Epoch 23/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 1.2818 - categorical_accuracy: 0.4855 - auc_11: 0.7051 - val_loss: 1.0860 - val_categorical_accuracy: 0.3224 - val_auc_11: 0.5525 - lr: 1.0000e-06\n", + "Epoch 24/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 1.2849 - categorical_accuracy: 0.4836 - auc_11: 0.7044 - val_loss: 1.0844 - val_categorical_accuracy: 0.3224 - val_auc_11: 0.5534 - lr: 1.0000e-06\n", + "Epoch 25/25\n", + "105/105 [==============================] - 41s 396ms/step - loss: 1.2809 - categorical_accuracy: 0.4945 - auc_11: 0.7080 - val_loss: 1.0886 - val_categorical_accuracy: 0.3186 - val_auc_11: 0.5500 - lr: 1.0000e-06\n", + "Train clinical model..\n", + "Epoch 1/25\n", + " 6/105 [>.............................] - ETA: 35s - loss: 0.7209 - binary_accuracy: 0.5667 - auc_10: 0.6085WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1134s vs `on_train_batch_end` time: 0.2422s). Check your callbacks.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1134s vs `on_train_batch_end` time: 0.2422s). Check your callbacks.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "105/105 [==============================] - 52s 415ms/step - loss: 0.6777 - binary_accuracy: 0.5331 - auc_10: 0.5455 - val_loss: 0.8218 - val_binary_accuracy: 0.4793 - val_auc_10: 0.5143 - lr: 0.0010\n", + "Epoch 2/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6652 - binary_accuracy: 0.5536 - auc_10: 0.5721 - val_loss: 0.7275 - val_binary_accuracy: 0.5235 - val_auc_10: 0.4612 - lr: 0.0010\n", + "Epoch 3/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6626 - binary_accuracy: 0.5665 - auc_10: 0.5709 - val_loss: 0.7038 - val_binary_accuracy: 0.5273 - val_auc_10: 0.5408 - lr: 0.0010\n", + "Epoch 4/25\n", + "105/105 [==============================] - 42s 398ms/step - loss: 0.6671 - binary_accuracy: 0.5598 - auc_10: 0.5650 - val_loss: 0.7770 - val_binary_accuracy: 0.5254 - val_auc_10: 0.5363 - lr: 0.0010\n", + "Epoch 5/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6595 - binary_accuracy: 0.5703 - auc_10: 0.5966 - val_loss: 0.9834 - val_binary_accuracy: 0.4765 - val_auc_10: 0.5259 - lr: 0.0010\n", + "Epoch 6/25\n", + "105/105 [==============================] - 41s 394ms/step - loss: 0.6695 - binary_accuracy: 0.5426 - auc_10: 0.5605 - val_loss: 0.7601 - val_binary_accuracy: 0.4878 - val_auc_10: 0.5445 - lr: 0.0010\n", + "Epoch 7/25\n", + "105/105 [==============================] - 41s 394ms/step - loss: 0.6670 - binary_accuracy: 0.5574 - auc_10: 0.5801 - val_loss: 0.6990 - val_binary_accuracy: 0.5244 - val_auc_10: 0.4958 - lr: 0.0010\n", + "Epoch 8/25\n", + "105/105 [==============================] - 41s 394ms/step - loss: 0.6607 - binary_accuracy: 0.5722 - auc_10: 0.5850 - val_loss: 0.7105 - val_binary_accuracy: 0.5282 - val_auc_10: 0.5130 - lr: 0.0010\n", + "Epoch 9/25\n", + "105/105 [==============================] - 41s 394ms/step - loss: 0.6618 - binary_accuracy: 0.5598 - auc_10: 0.5810 - val_loss: 0.7216 - val_binary_accuracy: 0.5122 - val_auc_10: 0.5323 - lr: 0.0010\n", + "Epoch 10/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6551 - binary_accuracy: 0.5717 - auc_10: 0.6010 - val_loss: 0.6912 - val_binary_accuracy: 0.5442 - val_auc_10: 0.5369 - lr: 0.0010\n", + "Epoch 11/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6506 - binary_accuracy: 0.5841 - auc_10: 0.6166 - val_loss: 0.6840 - val_binary_accuracy: 0.5432 - val_auc_10: 0.5540 - lr: 1.0000e-04\n", + "Epoch 12/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6461 - binary_accuracy: 0.5998 - auc_10: 0.6309 - val_loss: 0.6928 - val_binary_accuracy: 0.5414 - val_auc_10: 0.5468 - lr: 1.0000e-04\n", + "Epoch 13/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6420 - binary_accuracy: 0.5927 - auc_10: 0.6335 - val_loss: 0.6976 - val_binary_accuracy: 0.5282 - val_auc_10: 0.5488 - lr: 1.0000e-04\n", + "Epoch 14/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6437 - binary_accuracy: 0.6017 - auc_10: 0.6265 - val_loss: 0.6947 - val_binary_accuracy: 0.5338 - val_auc_10: 0.5519 - lr: 1.0000e-04\n", + "Epoch 15/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6367 - binary_accuracy: 0.6012 - auc_10: 0.6371 - val_loss: 0.6957 - val_binary_accuracy: 0.5470 - val_auc_10: 0.5509 - lr: 1.0000e-04\n", + "Epoch 16/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6360 - binary_accuracy: 0.5979 - auc_10: 0.6367 - val_loss: 0.6909 - val_binary_accuracy: 0.5517 - val_auc_10: 0.5559 - lr: 1.0000e-05\n", + "Epoch 17/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6345 - binary_accuracy: 0.6112 - auc_10: 0.6455 - val_loss: 0.6912 - val_binary_accuracy: 0.5508 - val_auc_10: 0.5580 - lr: 1.0000e-05\n", + "Epoch 18/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6358 - binary_accuracy: 0.5979 - auc_10: 0.6417 - val_loss: 0.6905 - val_binary_accuracy: 0.5564 - val_auc_10: 0.5574 - lr: 1.0000e-05\n", + "Epoch 19/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6361 - binary_accuracy: 0.6074 - auc_10: 0.6366 - val_loss: 0.6912 - val_binary_accuracy: 0.5517 - val_auc_10: 0.5572 - lr: 1.0000e-05\n", + "Epoch 20/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 0.6359 - binary_accuracy: 0.6031 - auc_10: 0.6436 - val_loss: 0.6921 - val_binary_accuracy: 0.5517 - val_auc_10: 0.5569 - lr: 1.0000e-05\n", + "Epoch 21/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6350 - binary_accuracy: 0.6041 - auc_10: 0.6441 - val_loss: 0.6932 - val_binary_accuracy: 0.5451 - val_auc_10: 0.5568 - lr: 1.0000e-06\n", + "Epoch 22/25\n", + "105/105 [==============================] - 42s 397ms/step - loss: 0.6308 - binary_accuracy: 0.6155 - auc_10: 0.6519 - val_loss: 0.6940 - val_binary_accuracy: 0.5442 - val_auc_10: 0.5565 - lr: 1.0000e-06\n", + "Epoch 23/25\n", + "105/105 [==============================] - 42s 396ms/step - loss: 0.6329 - binary_accuracy: 0.6017 - auc_10: 0.6483 - val_loss: 0.6937 - val_binary_accuracy: 0.5432 - val_auc_10: 0.5558 - lr: 1.0000e-06\n", + "Epoch 24/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6352 - binary_accuracy: 0.6060 - auc_10: 0.6465 - val_loss: 0.6939 - val_binary_accuracy: 0.5442 - val_auc_10: 0.5558 - lr: 1.0000e-06\n", + "Epoch 25/25\n", + "105/105 [==============================] - 41s 395ms/step - loss: 0.6334 - binary_accuracy: 0.6084 - auc_10: 0.6482 - val_loss: 0.6943 - val_binary_accuracy: 0.5432 - val_auc_10: 0.5563 - lr: 1.0000e-06\n" + ] + } + ], + "source": [ + "murmur_model, clinical_model, murmur_probas, outcome_probas, murmur_trues, outcome_trues, murmur_history, clinical_history, val_data, val_patient_labels, val_murmur_patient_clf_cv, val_outcome_patient_clf_cv = cv_challenge_model(data_folder=\"/content/data/training_data/training_data/\", result_folder=\"/content/results/\", n_epochs_1=25,n_epochs_2=25, n_folds=FOLDS, pre_train=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pFbjdVFpQgeY" + }, + "source": [ + "## Training curves\n" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "hWmccCPkLb66", + "outputId": "515d8e90-abb6-46c8-8700-2aaf8340aeeb" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "for key_idx in range(len(murmur_history[0].history.keys())):\n", + " plt.figure()\n", + " for cv_idx in range(len(murmur_history)):\n", + " plt.title(list(murmur_history[cv_idx].history.keys())[key_idx])\n", + " plt.plot(murmur_history[cv_idx].history[list(murmur_history[cv_idx].history.keys())[key_idx]], label=\"fold {}\".format(cv_idx))\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "GzMoaudkNwTu", + "outputId": "80c23f43-c736-4d01-cc3a-18c998583e74" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for key_idx in range(len(clinical_history[0].history.keys())):\n", + " plt.figure()\n", + " for cv_idx in range(len(murmur_history)):\n", + " plt.title(list(clinical_history[cv_idx].history.keys())[key_idx])\n", + " plt.plot(clinical_history[cv_idx].history[list(clinical_history[cv_idx].history.keys())[key_idx]], label=\"fold {}\".format(cv_idx))\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lWlv-eAmUAQ2" + }, + "source": [ + "# Patientwise metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hEykrVIYUAQ2" + }, + "source": [ + "## murmurs" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": { + "id": "Reg07vZEcSK3" + }, + "outputs": [], + "source": [ + "murmur_classes = ['Present', 'Unknown', 'Absent']\n", + "outcome_classes = ['Abnormal', 'Normal']" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6WzYfeWwUAQ3", + "outputId": "38621976-906d-46e8-87a9-ddb3e32bc2da" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################\n", + "Murmur weighted accuracy:\n", + "0.5129449838187702\n", + "Challenge metric based on murmur:\n", + "13179.103838577634\n", + "Murmur Accuracy:\n", + "(0.5254777070063694, array([0.49253731, 0.55555556, 0.53275109]))\n", + "Murmur F measure:\n", + "(0.4314855581057991, array([0.46153846, 0.19417476, 0.63874346]))\n", + "#################################\n", + "#################################\n", + "Murmur weighted accuracy:\n", + "0.5144927536231884\n", + "Challenge metric based on murmur:\n", + "11865.365449015253\n", + "Murmur Accuracy:\n", + "(0.445859872611465, array([0.59574468, 0.64 , 0.39669421]))\n", + "Murmur F measure:\n", + "(0.3908123965948043, array([0.34782609, 0.28070175, 0.54390935]))\n", + "#################################\n", + "#################################\n", + "Murmur weighted accuracy:\n", + "0.41025641025641024\n", + "Challenge metric based on murmur:\n", + "12768.313136263561\n", + "Murmur Accuracy:\n", + "(0.27388535031847133, array([0.47692308, 0.92 , 0.14285714]))\n", + "Murmur F measure:\n", + "(0.2791994923343165, array([0.35028249, 0.24210526, 0.24521073]))\n", + "#################################\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "for fold in range(FOLDS):\n", + " murmur_pred = np.zeros((len(np.unique(val_patient_labels[fold])),3), dtype=np.int_)\n", + " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", + " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", + " for pat_num in np.unique(val_patient_labels[fold]):\n", + " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", + " binary_pred = np.argmax(murmur_probas[fold][pat_indx],axis=1)\n", + " murmur_indx = np.bincount(binary_pred).argmax()\n", + " murmur_pred[pat_num,murmur_indx] = 1\n", + "\n", + " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", + "\n", + "\n", + " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", + "\n", + " print(\"#################################\")\n", + " print(\"Murmur weighted accuracy:\")\n", + " print(compute_weighted_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred, murmur_classes))\n", + " print(\"Challenge metric based on murmur:\")\n", + " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, murmur_pred, outcome_classes, murmur_classes))\n", + " print(\"Murmur Accuracy:\")\n", + " print(compute_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", + " print(\"Murmur F measure:\")\n", + " print(compute_f_measure(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", + " print(\"#################################\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kp0R1k68jw34", + "outputId": "f896b4d3-cc6d-482a-db98-3c311668c9c6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################\n", + "Murmur weighted accuracy:\n", + "0.5728155339805825\n", + "Challenge metric based on murmur:\n", + "13066.93035453682\n", + "Murmur Accuracy:\n", + "(0.5477707006369427, array([0.64179104, 0.27777778, 0.54148472]))\n", + "Murmur F measure:\n", + "(0.4261196277668356, array([0.45502646, 0.17241379, 0.65091864]))\n", + "#################################\n", + "#################################\n", + "Murmur weighted accuracy:\n", + "0.5597826086956522\n", + "Challenge metric based on murmur:\n", + "12851.670243385208\n", + "Murmur Accuracy:\n", + "(0.44904458598726116, array([0.74468085, 0.56 , 0.38016529]))\n", + "Murmur F measure:\n", + "(0.44220223535438813, array([0.32407407, 0.48275862, 0.51977401]))\n", + "#################################\n", + "#################################\n", + "Murmur weighted accuracy:\n", + "0.4951923076923077\n", + "Challenge metric based on murmur:\n", + "12016.599733733156\n", + "Murmur Accuracy:\n", + "(0.3471337579617834, array([0.64615385, 0.64 , 0.22767857]))\n", + "Murmur F measure:\n", + "(0.33688749815130503, array([0.36681223, 0.29090909, 0.35294118]))\n", + "#################################\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "for fold in range(FOLDS):\n", + " murmur_pred = np.zeros((len(np.unique(val_patient_labels[fold])),3), dtype=np.int_)\n", + " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", + " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", + " for pat_num in np.unique(val_patient_labels[fold]):\n", + " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", + " binary_pred = np.argmax(murmur_probas[fold][pat_indx],axis=1)\n", + " if 0 in binary_pred:\n", + " murmur_pred[pat_num,0] = 1\n", + " elif 2 in binary_pred:\n", + " murmur_pred[pat_num,2] = 1\n", + " elif 1 in binary_pred:\n", + " murmur_pred[pat_num,1] = 1\n", + "\n", + " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", + "\n", + "\n", + " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", + "\n", + " print(\"#################################\")\n", + " print(\"Murmur weighted accuracy:\")\n", + " print(compute_weighted_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred, murmur_classes))\n", + " print(\"Challenge metric based on murmur:\")\n", + " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, murmur_pred, outcome_classes, murmur_classes))\n", + " print(\"Murmur Accuracy:\")\n", + " print(compute_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", + " print(\"Murmur F measure:\")\n", + " print(compute_f_measure(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", + " print(\"#################################\")\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8LmUhPgDB-jg", + "outputId": "a729609b-5d9b-4a03-e3c4-6bee7da64dc1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################\n", + "Murmur weighted accuracy:\n", + "0.4919093851132686\n", + "Challenge metric based on murmur:\n", + "11959.88484436956\n", + "Murmur Accuracy:\n", + "(0.3503184713375796, array([0.64179104, 0.61111111, 0.24454148]))\n", + "Murmur F measure:\n", + "(0.3289170839895477, array([0.45502646, 0.15714286, 0.37458194]))\n", + "#################################\n", + "#################################\n", + "Murmur weighted accuracy:\n", + "0.483695652173913\n", + "Challenge metric based on murmur:\n", + "12077.58579712274\n", + "Murmur Accuracy:\n", + "(0.2898089171974522, array([0.74468085, 0.72 , 0.15702479]))\n", + "Murmur F measure:\n", + "(0.29229414548113736, array([0.32407407, 0.288 , 0.26480836]))\n", + "#################################\n", + "#################################\n", + "Murmur weighted accuracy:\n", + "0.44711538461538464\n", + "Challenge metric based on murmur:\n", + "14196.640172964111\n", + "Murmur Accuracy:\n", + "(0.2197452229299363, array([0.64615385, 0.84 , 0.02678571]))\n", + "Murmur F measure:\n", + "(0.22250228339229525, array([0.36681223, 0.24852071, 0.05217391]))\n", + "#################################\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "for fold in range(FOLDS):\n", + " murmur_pred = np.zeros((len(np.unique(val_patient_labels[fold])),3), dtype=np.int_)\n", + " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", + " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", + " for pat_num in np.unique(val_patient_labels[fold]):\n", + " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", + " binary_pred = np.argmax(murmur_probas[fold][pat_indx],axis=1)\n", + " if 0 in binary_pred:\n", + " murmur_pred[pat_num,0] = 1\n", + " elif 1 in binary_pred:\n", + " murmur_pred[pat_num,1] = 1\n", + " elif 2 in binary_pred:\n", + " murmur_pred[pat_num,2] = 1\n", + "\n", + " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", + "\n", + "\n", + " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", + "\n", + " print(\"#################################\")\n", + " print(\"Murmur weighted accuracy:\")\n", + " print(compute_weighted_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred, murmur_classes))\n", + " print(\"Challenge metric based on murmur:\")\n", + " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, murmur_pred, outcome_classes, murmur_classes))\n", + " print(\"Murmur Accuracy:\")\n", + " print(compute_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", + " print(\"Murmur F measure:\")\n", + " print(compute_f_measure(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", + " print(\"#################################\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Bzw8x-tXUAQ5" + }, + "source": [ + "# Outcome" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "J4SfUo2YhDhK", + "outputId": "46e4399f-c10d-4b5e-ee58-52f1b0dcd504" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################\n", + "Outcome weighted accuracy:\n", + "0.7364425162689805\n", + "Challenge metric based on outcome:\n", + "13520.439324209101\n", + "Outcome Accuracy:\n", + "(0.4681528662420382, array([0.875 , 0.08641975]))\n", + "Outcome F measure:\n", + "(0.37895422514360155, array([0.61431871, 0.14358974]))\n", + "#################################\n", + "#################################\n", + "Outcome weighted accuracy:\n", + "0.6637744034707158\n", + "Challenge metric based on outcome:\n", + "12973.767506865399\n", + "Outcome Accuracy:\n", + "(0.4713375796178344, array([0.76315789, 0.19753086]))\n", + "Outcome F measure:\n", + "(0.4305877212147695, array([0.58291457, 0.27826087]))\n", + "#################################\n", + "#################################\n", + "Outcome weighted accuracy:\n", + "0.7223427331887202\n", + "Challenge metric based on outcome:\n", + "12375.371060116919\n", + "Outcome Accuracy:\n", + "(0.5031847133757962, array([0.83552632, 0.19135802]))\n", + "Outcome F measure:\n", + "(0.4519579324233609, array([0.6195122 , 0.28440367]))\n", + "#################################\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "for fold in range(FOLDS):\n", + " outcome_pred = np.zeros((len(np.unique(val_patient_labels[fold])),2), dtype=np.int_)\n", + " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", + " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", + " for pat_num in np.unique(val_patient_labels[fold]):\n", + " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", + " binary_pred = (outcome_probas[fold][pat_indx]>0.5) * 1\n", + " if 0 in binary_pred:\n", + " outcome_pred[pat_num, 0] = 1\n", + " else:\n", + " outcome_pred[pat_num, 1] = 1\n", + "\n", + " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", + " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", + " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", + "\n", + "\n", + " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", + " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", + " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", + "\n", + " print(\"#################################\")\n", + " print(\"Outcome weighted accuracy:\")\n", + " print(compute_weighted_accuracy(val_outcome_patient_clf_cv_ohe, outcome_pred, outcome_classes))\n", + " print(\"Challenge metric based on outcome:\")\n", + " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, outcome_pred, outcome_classes, outcome_classes))\n", + " print(\"Outcome Accuracy:\")\n", + " print(compute_accuracy(val_outcome_patient_clf_cv_ohe, outcome_pred))\n", + " print(\"Outcome F measure:\")\n", + " print(compute_f_measure(val_outcome_patient_clf_cv_ohe, outcome_pred))\n", + " print(\"#################################\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "avJ17lXkExiS" + }, + "source": [ + "# XAI stuff" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "U1cXFf3Q49xm" + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "def grad_cam(layer_name, data, model):\n", + " grad_model = tf.keras.models.Model(\n", + " [model.inputs], [model.get_layer(layer_name).output, model.output]\n", + ")\n", + " last_conv_layer_output, preds = grad_model(data)\n", + "\n", + " with tf.GradientTape() as tape:\n", + " last_conv_layer_output, preds = grad_model(data)\n", + " pred_index = tf.argmax(preds[0])\n", + " class_channel = preds[:, pred_index]\n", + " \n", + " grads = tape.gradient(class_channel, last_conv_layer_output)\n", + "\n", + "\n", + " pooled_grads = tf.reduce_mean(grads, axis=(0))\n", + "\n", + " last_conv_layer_output = last_conv_layer_output[0]\n", + "\n", + " heatmap = last_conv_layer_output * pooled_grads\n", + " heatmap = tf.reduce_mean(heatmap, axis=(1))\n", + " heatmap = np.expand_dims(heatmap,0)\n", + " return heatmap" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BNpareHdUnEh" + }, + "source": [ + "## XAI Murmur Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "6A-2lCSyR3GI", + "outputId": "5538d7ac-8afc-4b8e-d205-55c8b0cb06dd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_5\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_6 (InputLayer) [(None, 16128, 1)] 0 [] \n", + " \n", + " max_pooling1d_50 (MaxPooling1D (None, 16128, 1) 0 ['input_6[0][0]'] \n", + " ) \n", + " \n", + " conv1d_260 (Conv1D) (None, 16128, 32) 1280 ['input_6[0][0]'] \n", + " \n", + " conv1d_261 (Conv1D) (None, 16128, 32) 640 ['input_6[0][0]'] \n", + " \n", + " conv1d_262 (Conv1D) (None, 16128, 32) 320 ['input_6[0][0]'] \n", + " \n", + " conv1d_263 (Conv1D) (None, 16128, 32) 32 ['max_pooling1d_50[0][0]'] \n", + " \n", + " concatenate_50 (Concatenate) (None, 16128, 128) 0 ['conv1d_260[0][0]', \n", + " 'conv1d_261[0][0]', \n", + " 'conv1d_262[0][0]', \n", + " 'conv1d_263[0][0]'] \n", + " \n", + " batch_normalization_65 (BatchN (None, 16128, 128) 512 ['concatenate_50[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_65 (Activation) (None, 16128, 128) 0 ['batch_normalization_65[0][0]'] \n", + " \n", + " conv1d_264 (Conv1D) (None, 16128, 32) 4096 ['activation_65[0][0]'] \n", + " \n", + " max_pooling1d_51 (MaxPooling1D (None, 16128, 128) 0 ['activation_65[0][0]'] \n", + " ) \n", + " \n", + " conv1d_265 (Conv1D) (None, 16128, 32) 40960 ['conv1d_264[0][0]'] \n", + " \n", + " conv1d_266 (Conv1D) (None, 16128, 32) 20480 ['conv1d_264[0][0]'] \n", + " \n", + " conv1d_267 (Conv1D) (None, 16128, 32) 10240 ['conv1d_264[0][0]'] \n", + " \n", + " conv1d_268 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_51[0][0]'] \n", + " \n", + " concatenate_51 (Concatenate) (None, 16128, 128) 0 ['conv1d_265[0][0]', \n", + " 'conv1d_266[0][0]', \n", + " 'conv1d_267[0][0]', \n", + " 'conv1d_268[0][0]'] \n", + " \n", + " batch_normalization_66 (BatchN (None, 16128, 128) 512 ['concatenate_51[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_66 (Activation) (None, 16128, 128) 0 ['batch_normalization_66[0][0]'] \n", + " \n", + " conv1d_269 (Conv1D) (None, 16128, 32) 4096 ['activation_66[0][0]'] \n", + " \n", + " max_pooling1d_52 (MaxPooling1D (None, 16128, 128) 0 ['activation_66[0][0]'] \n", + " ) \n", + " \n", + " conv1d_270 (Conv1D) (None, 16128, 32) 40960 ['conv1d_269[0][0]'] \n", + " \n", + " conv1d_271 (Conv1D) (None, 16128, 32) 20480 ['conv1d_269[0][0]'] \n", + " \n", + " conv1d_272 (Conv1D) (None, 16128, 32) 10240 ['conv1d_269[0][0]'] \n", + " \n", + " conv1d_273 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_52[0][0]'] \n", + " \n", + " concatenate_52 (Concatenate) (None, 16128, 128) 0 ['conv1d_270[0][0]', \n", + " 'conv1d_271[0][0]', \n", + " 'conv1d_272[0][0]', \n", + " 'conv1d_273[0][0]'] \n", + " \n", + " conv1d_274 (Conv1D) (None, 16128, 128) 128 ['input_6[0][0]'] \n", + " \n", + " batch_normalization_67 (BatchN (None, 16128, 128) 512 ['concatenate_52[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_68 (BatchN (None, 16128, 128) 512 ['conv1d_274[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_67 (Activation) (None, 16128, 128) 0 ['batch_normalization_67[0][0]'] \n", + " \n", + " add_15 (Add) (None, 16128, 128) 0 ['batch_normalization_68[0][0]', \n", + " 'activation_67[0][0]'] \n", + " \n", + " activation_68 (Activation) (None, 16128, 128) 0 ['add_15[0][0]'] \n", + " \n", + " conv1d_275 (Conv1D) (None, 16128, 32) 4096 ['activation_68[0][0]'] \n", + " \n", + " max_pooling1d_53 (MaxPooling1D (None, 16128, 128) 0 ['activation_68[0][0]'] \n", + " ) \n", + " \n", + " conv1d_276 (Conv1D) (None, 16128, 32) 40960 ['conv1d_275[0][0]'] \n", + " \n", + " conv1d_277 (Conv1D) (None, 16128, 32) 20480 ['conv1d_275[0][0]'] \n", + " \n", + " conv1d_278 (Conv1D) (None, 16128, 32) 10240 ['conv1d_275[0][0]'] \n", + " \n", + " conv1d_279 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_53[0][0]'] \n", + " \n", + " concatenate_53 (Concatenate) (None, 16128, 128) 0 ['conv1d_276[0][0]', \n", + " 'conv1d_277[0][0]', \n", + " 'conv1d_278[0][0]', \n", + " 'conv1d_279[0][0]'] \n", + " \n", + " batch_normalization_69 (BatchN (None, 16128, 128) 512 ['concatenate_53[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_69 (Activation) (None, 16128, 128) 0 ['batch_normalization_69[0][0]'] \n", + " \n", + " conv1d_280 (Conv1D) (None, 16128, 32) 4096 ['activation_69[0][0]'] \n", + " \n", + " max_pooling1d_54 (MaxPooling1D (None, 16128, 128) 0 ['activation_69[0][0]'] \n", + " ) \n", + " \n", + " conv1d_281 (Conv1D) (None, 16128, 32) 40960 ['conv1d_280[0][0]'] \n", + " \n", + " conv1d_282 (Conv1D) (None, 16128, 32) 20480 ['conv1d_280[0][0]'] \n", + " \n", + " conv1d_283 (Conv1D) (None, 16128, 32) 10240 ['conv1d_280[0][0]'] \n", + " \n", + " conv1d_284 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_54[0][0]'] \n", + " \n", + " concatenate_54 (Concatenate) (None, 16128, 128) 0 ['conv1d_281[0][0]', \n", + " 'conv1d_282[0][0]', \n", + " 'conv1d_283[0][0]', \n", + " 'conv1d_284[0][0]'] \n", + " \n", + " batch_normalization_70 (BatchN (None, 16128, 128) 512 ['concatenate_54[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_70 (Activation) (None, 16128, 128) 0 ['batch_normalization_70[0][0]'] \n", + " \n", + " conv1d_285 (Conv1D) (None, 16128, 32) 4096 ['activation_70[0][0]'] \n", + " \n", + " max_pooling1d_55 (MaxPooling1D (None, 16128, 128) 0 ['activation_70[0][0]'] \n", + " ) \n", + " \n", + " conv1d_286 (Conv1D) (None, 16128, 32) 40960 ['conv1d_285[0][0]'] \n", + " \n", + " conv1d_287 (Conv1D) (None, 16128, 32) 20480 ['conv1d_285[0][0]'] \n", + " \n", + " conv1d_288 (Conv1D) (None, 16128, 32) 10240 ['conv1d_285[0][0]'] \n", + " \n", + " conv1d_289 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_55[0][0]'] \n", + " \n", + " concatenate_55 (Concatenate) (None, 16128, 128) 0 ['conv1d_286[0][0]', \n", + " 'conv1d_287[0][0]', \n", + " 'conv1d_288[0][0]', \n", + " 'conv1d_289[0][0]'] \n", + " \n", + " conv1d_290 (Conv1D) (None, 16128, 128) 16384 ['activation_68[0][0]'] \n", + " \n", + " batch_normalization_71 (BatchN (None, 16128, 128) 512 ['concatenate_55[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_72 (BatchN (None, 16128, 128) 512 ['conv1d_290[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_71 (Activation) (None, 16128, 128) 0 ['batch_normalization_71[0][0]'] \n", + " \n", + " add_16 (Add) (None, 16128, 128) 0 ['batch_normalization_72[0][0]', \n", + " 'activation_71[0][0]'] \n", + " \n", + " activation_72 (Activation) (None, 16128, 128) 0 ['add_16[0][0]'] \n", + " \n", + " conv1d_291 (Conv1D) (None, 16128, 32) 4096 ['activation_72[0][0]'] \n", + " \n", + " max_pooling1d_56 (MaxPooling1D (None, 16128, 128) 0 ['activation_72[0][0]'] \n", + " ) \n", + " \n", + " conv1d_292 (Conv1D) (None, 16128, 32) 40960 ['conv1d_291[0][0]'] \n", + " \n", + " conv1d_293 (Conv1D) (None, 16128, 32) 20480 ['conv1d_291[0][0]'] \n", + " \n", + " conv1d_294 (Conv1D) (None, 16128, 32) 10240 ['conv1d_291[0][0]'] \n", + " \n", + " conv1d_295 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_56[0][0]'] \n", + " \n", + " concatenate_56 (Concatenate) (None, 16128, 128) 0 ['conv1d_292[0][0]', \n", + " 'conv1d_293[0][0]', \n", + " 'conv1d_294[0][0]', \n", + " 'conv1d_295[0][0]'] \n", + " \n", + " batch_normalization_73 (BatchN (None, 16128, 128) 512 ['concatenate_56[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_73 (Activation) (None, 16128, 128) 0 ['batch_normalization_73[0][0]'] \n", + " \n", + " conv1d_296 (Conv1D) (None, 16128, 32) 4096 ['activation_73[0][0]'] \n", + " \n", + " max_pooling1d_57 (MaxPooling1D (None, 16128, 128) 0 ['activation_73[0][0]'] \n", + " ) \n", + " \n", + " conv1d_297 (Conv1D) (None, 16128, 32) 40960 ['conv1d_296[0][0]'] \n", + " \n", + " conv1d_298 (Conv1D) (None, 16128, 32) 20480 ['conv1d_296[0][0]'] \n", + " \n", + " conv1d_299 (Conv1D) (None, 16128, 32) 10240 ['conv1d_296[0][0]'] \n", + " \n", + " conv1d_300 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_57[0][0]'] \n", + " \n", + " concatenate_57 (Concatenate) (None, 16128, 128) 0 ['conv1d_297[0][0]', \n", + " 'conv1d_298[0][0]', \n", + " 'conv1d_299[0][0]', \n", + " 'conv1d_300[0][0]'] \n", + " \n", + " batch_normalization_74 (BatchN (None, 16128, 128) 512 ['concatenate_57[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_74 (Activation) (None, 16128, 128) 0 ['batch_normalization_74[0][0]'] \n", + " \n", + " conv1d_301 (Conv1D) (None, 16128, 32) 4096 ['activation_74[0][0]'] \n", + " \n", + " max_pooling1d_58 (MaxPooling1D (None, 16128, 128) 0 ['activation_74[0][0]'] \n", + " ) \n", + " \n", + " conv1d_302 (Conv1D) (None, 16128, 32) 40960 ['conv1d_301[0][0]'] \n", + " \n", + " conv1d_303 (Conv1D) (None, 16128, 32) 20480 ['conv1d_301[0][0]'] \n", + " \n", + " conv1d_304 (Conv1D) (None, 16128, 32) 10240 ['conv1d_301[0][0]'] \n", + " \n", + " conv1d_305 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_58[0][0]'] \n", + " \n", + " concatenate_58 (Concatenate) (None, 16128, 128) 0 ['conv1d_302[0][0]', \n", + " 'conv1d_303[0][0]', \n", + " 'conv1d_304[0][0]', \n", + " 'conv1d_305[0][0]'] \n", + " \n", + " conv1d_306 (Conv1D) (None, 16128, 128) 16384 ['activation_72[0][0]'] \n", + " \n", + " batch_normalization_75 (BatchN (None, 16128, 128) 512 ['concatenate_58[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_76 (BatchN (None, 16128, 128) 512 ['conv1d_306[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_75 (Activation) (None, 16128, 128) 0 ['batch_normalization_75[0][0]'] \n", + " \n", + " add_17 (Add) (None, 16128, 128) 0 ['batch_normalization_76[0][0]', \n", + " 'activation_75[0][0]'] \n", + " \n", + " activation_76 (Activation) (None, 16128, 128) 0 ['add_17[0][0]'] \n", + " \n", + " conv1d_307 (Conv1D) (None, 16128, 32) 4096 ['activation_76[0][0]'] \n", + " \n", + " max_pooling1d_59 (MaxPooling1D (None, 16128, 128) 0 ['activation_76[0][0]'] \n", + " ) \n", + " \n", + " conv1d_308 (Conv1D) (None, 16128, 32) 40960 ['conv1d_307[0][0]'] \n", + " \n", + " conv1d_309 (Conv1D) (None, 16128, 32) 20480 ['conv1d_307[0][0]'] \n", + " \n", + " conv1d_310 (Conv1D) (None, 16128, 32) 10240 ['conv1d_307[0][0]'] \n", + " \n", + " conv1d_311 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_59[0][0]'] \n", + " \n", + " concatenate_59 (Concatenate) (None, 16128, 128) 0 ['conv1d_308[0][0]', \n", + " 'conv1d_309[0][0]', \n", + " 'conv1d_310[0][0]', \n", + " 'conv1d_311[0][0]'] \n", + " \n", + " batch_normalization_77 (BatchN (None, 16128, 128) 512 ['concatenate_59[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_77 (Activation) (None, 16128, 128) 0 ['batch_normalization_77[0][0]'] \n", + " \n", + " global_average_pooling1d_5 (Gl (None, 128) 0 ['activation_77[0][0]'] \n", + " obalAveragePooling1D) \n", + " \n", + " murmur_output (Dense) (None, 3) 387 ['global_average_pooling1d_5[0][0\n", + " ]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 761,059\n", + "Trainable params: 757,731\n", + "Non-trainable params: 3,328\n", + "__________________________________________________________________________________________________\n" + ] + }, + { + "ename": "TypeError", + "evalue": "ignored", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmurmur_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not subscriptable" + ] + } + ], + "source": [ + "murmur_model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "isz0Y0yfWcyb", + "outputId": "bf34af01-c27b-47c2-e7f5-cc82b6b30aab" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "13832\n" + ] + } + ], + "source": [ + "for i,j in enumerate(reversed(val_data[0])):\n", + " if not j == 0:\n", + " print(i)\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "M9vMujbMXASq", + "outputId": "2fa80f8b-f4f2-4d10-a854-7149e3951dc7" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2296" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(val_data[0][:-13832])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "jGmeZ9w649xm", + "outputId": "97213500-d323-4606-b731-77b7fb165bfc" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABNAAAAEDCAYAAAD0oPnDAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3wUZf4H8M+TTi8CCgJyCnpiw47l1EPlbGevd4rn4Q+xndgpCooNFUVRQLBhRVER6b1LLyG0ACFACOmk183ufn9/PDs7u8km2U1mSAKf9+s1r2RnZ595ZuaZZ5555nmeUSICIiIiIiIiIiIiCiysviNARERERERERETUkLECjYiIiIiIiIiIqBqsQCMiIiIiIiIiIqoGK9CIiIiIiIiIiIiqwQo0IiIiIiIiIiKiarACjYiIiIiIiIiIqBqsQCMiIiIiIiIiojpTSn2llMpQSm23KLyuSqkFSqldSqmdSqluVoRbG6xAIyIiIiIiIiIiK0wGcIOF4X0L4H0RORPAJQAyLAw7JKxAIyIiIiIiIiKiOhORFQCyfecppU5TSs1TSm1SSq1USv01mLCUUj0BRIjIQk/YhSJSbH2sg8MKNCIiIiIiIiIissskAE+LyIUAXgAwPsjfnQ4gVyk1TSm1RSn1vlIq3LZY1iCivlZMRERERERERETHLqVUcwCXA/hFKWXMjvZ8dyeAkQF+dlhE/gFdZ/U3AOcDSALwM4D/APjS3lgHxgo0IiIiIiIiIiKyQxiAXBHpVfELEZkGYFo1v00GECsiiQCglJoOoDfqqQKNXTiJiIiIiIiIiMhyIpIPYL9S6h4AUNp5Qf58A4DWSqn2ns99AOy0IZpBYQUaERERERERERHVmVJqCoA1AM5QSiUrpfoD+DeA/kqprQB2ALgtmLBExAU9ZtpipdQ2AArA5/bEvGZKROpr3URERERERERERA0eW6ARERERERERERFV45h9iUCrVu2kZctuiIoCwsIAt1vPd7v157IyIDJSTwCQl6e/i4kBnE7ghBOAQ4f0vIgIvZzTCZSXA0rpv02aAM2a6b9KAc2bAwUFQHi4nhcmLkBEB+DhcukwfeMREWGG6XQCUVFAaSkQHa2Xi4rS30dFuHV4xpsrXC64w/UGhIV5vnK74EI4HA5ze91uoKgIcDj0cmGeatPCQv2bqCgzikaDRCPaxv6JjNTxM37rdJrrFAGaNtXb7XQCLVvqeHgXCg8HlIJbvG/cQFiYDs9Yr9NpbnNZmd5Pxk+bNfNsSHGxnuG7A5UCYmLgRhiU0nEJUwKnSxmrhcMB73fGvmjZUv8fHq7nR7pKgZISc6PCw/VGexKQ72439qORFoyoFBfr/RAW5jlWZWV6Id8DFBFhbpgRf6X0DhDR63Q44I6I8v7U2D9ut163kaYjIvQUDs++jogAwsPhdJrLh4ebx9NYTXm5jqexn40017w5EFbumWkkBCMQpfTBMRKAceA9J5cbYd79a/w0O1uvB9DnVVkZ0KIF9IE2drxnQ4ykYpwHxvEyzhnjOBr73Th3o6OhAy4u1gnF4TA3OjIS7rAIb1hGejM2z1hXebkZndJSvQ3R0eYmGvGIjNTntZEnOJ3mLjJ2jflSGTPsyEi9TFmZmTcoBSiInmkcTA+HM8w728i7fJOl0wnv+R0VZR4/l8tMXlFRPpmNEdHISEh4hHdfREYCYdAZoxth3jzROLyRkUBurg4zKsqzPlVuHiAjLURGwu15FuN0+h8rpfRvjUNdVqbnGdtnnAaA/j88HFDi9qZn47w20qqRDxn72wjPyDONv0rpeEdHuHTgpaVmAIA33zCOnxEfg3Gu+abp4mIdhPHzoiIdhHGMjCzDSBtGHKOi9HKlpTocl0ufB0Z6KC7W30dEABFhbr1gWZmZbxgrjIzUP/AcDOO8UMqzz0RQXBbul+8VFen05nTq5Y38w9jGsDA9zzc79d1G49pjxNHYr+Xl+nNMjGcfO516ISPOvhcaY4WeNOOu8NzO2P9RUTqI8nIzXwoPN9dlXH+M641xvKOj9a4xznPjmBlpo7jYvAY4nWYebWRpvt+Vl1cO0/c6Z1yXSkvN9GucIxVONW9eYCxvMI6P06mPjXHeGJ+N+BjpqG1bz7kaBnMlnpPFKNcYadA4t2OiBeVO5f2+tBR+ZQIji3Q4dLbpdus0aVw3ior0PjAuK8ZfI324XGbcw8L0pTMiwpMfA4iCwzwAxs4OD/ee00bS8L08GnETMfO4pk3NMlBYGPwvCsbFADBX7OGbDozfG/umoED/tHlzM59TLqeZoYSHwx0R5Y1HRIR57I3NKSryP1+Ma2pRkV6+aVPPMSsvM6/7Rn5sJABPWcYdFuHdHOO65Habacb4bKSNZs3MbQt3Obx5g5H2jPzS2A/FxeY5a/zNzze3y0irxjnXpIn+PzzcvFYa22PseiO9+p5HLpeOW0y0mAnJOJmNHWdk+MYPlILTHYaIMDfKXWHeNGFcx8rKzLJ7xeubUkC4cpuRj4jQ+ZjyKax5yiaADsu4hpaVeco7SsyyV0mJWbDw7AgjrfsmO+MaHBVlXudKSsz8vkkTz/XVXaa/ME62imUo3wzLk0YECqWlQJMYQUGh8ubbIvr8FDHzYWPHuBHm3c2+txtGHmicX8Y1weXyXvq8YYaVFJkbaQRg5OFG5uZzMZTIKChnOdzhkd7iQHGx3vaICCDc7SlgGAUqwHv+S1g4iov110Z6N9K/cZyMY2zcHxm7KzISCBefxGf80EhfRqIW0fmMy5M/GInX6fSWCQsLzc01kqQ3IzMyS0+Z2uGO8F6HDEbaMPIY42fGcr7bFx3hMi+sxsXWkykJlLd8BBG43PrexUiORtnHuC40a2YWZaLCXShxhOu82HM+uSSs0q2Hb5IrKzPvc43Lie85FRMDhDlK/c9bI4JGZmGcX54NNBY10puRfxv3KMb6o6PN8rZxrH3L+sb56XvPbqRZY/uLisxohYWZl0MjfRvXKWMdxmfj+mTcIhjXZd97WIdDp+EmUS7zntPp1JlFaal5Q+NTlgmDGw5nGKIi3Oa1zchTIiKQnqH3j1FWLy7W9Q09e3ry9WhPAtq3DxDBgdJSZDmdPncSx68blJKsIJfdBMwXkRtsjVAFx2wFWocO3fDEExvRubNO+/n55gnTtCmwZw/QuTNw0kk67c6frwtWf/0rcOQI8PDDwKBBOrG3bauXy8oC0tJ0HpKaCvTqBVxyiT4RIiKAq64Cli0DWrcGzjwTaO7K85aAXW6F8DBBXr6+QObn63glJADt2unfp6cDmZlAt27Ajh1Ajx46vl276rif0qFEzzBypMJClLQ80VuYdbuByOI85Lhb4fBhs/BUWAisXw+kpJg3PWFhwOrVOnqdOwPt2+vljQywvFzH6+ST9ef27XXcjPVkZen4Gzdf556rtzs7G7juOiCyMEffWTRtqqeoKJS4o73XkGbN9L5s21bHJSsL2LkTOP10IDHR/GnLlsCll3hqNjZu1DMcDvOOLioKOP10FLibISrKkyGFlSEzPxotWwLRUYKDSQoxMfpnhYU6mOuu00E2b673QcfcXUBcnF6pUQvYqRPQuTNcTVvofRumL9aHkhWaNgWSk3UUjIqzzZuBCy7Q805pWwAcPAgcPqw30IjAiSfqXLxtW+9ds0RFQ2VlAm43pMOJUEkHUdD2FGRkmOk5I0PHNzkZ3jTdujXQoQPQCnl6gQ4d4GreCtnZen8WF+tljItkVJReLCNDxzMhQafDrCwd5lVXAU2S9+qZRqmgsNA8SKefDonRd03KWW7e4RQXoySsGRwOHUejfmzKFJ0uPD/FgQN6HWrPbr0BRo11u3bIzFLew5mWZlY4hIfr8zEmBkhK0unv8GGdLk88EejeHVAJe4HYWKB3b72SNm30TjvxRBTEtPemi+Rkvb8KCnQ6j47W53FKit5PDgcQH6/3W7du/jfyYWE6D+jZU8erbVu93wD9+dRTzUoQQ1aWDrtTJ70bExJ0sjr7bM9Neli5ntm8uT7ZPHdrh7KaICFB79pmzXR8W7TQ8WndWh+/pCS9jm7d9Hq6dAFycnQwzZvr46lyc/RGZWbqk7tTJ5Q1PwEOh97HHTsCzcNLAKcTJREtvHkioH/WoQMwY4Y+97t00ceiszqsfxwR4bkDCQM6dECBuxkAXTAID9eHoXlzvZ0nn2wW2hMT9U8PHNDHskULs0zSurWeIksLdAbQrh0KnE0QFaV/l5+vwzp0SB/3Jk10OJGROo+Mj9d/d+7U62rbFjitbY4OfM8eHcBJJ5kl8dNPh0ChsFCHb2yO06nTx6FDZnp2OHQSy842C5tr1+r0YFT8tG6tg2/XTi936ql627p21ek/Pl7vh9xc4Oqr9TrbttX5Uc+e+ncnNC3RC+7Zo+PdtKl549Whg76WdOoCwLwJjokBIh1FgNOJLYmt0Ly5nnfggM73zz1XX1uKivS8bt100Ea+dfCg/q5ZM33sfG8sunbV27d5s96GqCh9eqWn6zh37w70aJejN3jjRrNmIibGPLDduumd6jnBSyJaeK8DgN7XiYk67W3cqJNXYaFOtm3a6HO0Rw893yjkXnSRPs6dO+t4nXSSWUAtLdXblpCg58XF6fCbNNFhGnl0VJSOWkqK3lbjfO3aVR+7k0/WySQmxqxQzc3V+2n3bnNfzJypj31xsc6rwsN13mTcszVrpq/nRkVUmzb6u+xsvQ/DwnS8srN1uSElxXtaITMTeOAB/X+L5qJ3THa2XmHz5ihxhHsrBY38NyMDOKNbGdJzo5Gfr+MQH6/zPyO/at7cPA8vvlgf/+uuM68b69frfZOdrdNoZqbeJk+xA7m5Oh8zkujOnTpKZ5yh53WWQzoNR0frHRAZCbRqBbRrh0JXE2/lm5GHGvvYONeysnQed8EFel6nTp6HdE5PAaWwUM9ISQEAuLqdph8kAXAh3HsDZ9RFn3wyvPnesmV6+y+/XB+Pk04CInMzzQyqbVuUtOvijUe7dvq3+fl6c5o0Adas0XlXeLjOd7OydHlw7Vp9rHr10nFukrJP/7hdOx3noiK9HyIi9MWgtBSF0SegoMC8qTUeAsTHmxXxJSV6fycl6bRv3Nu1yj8EREVBOpyI7GyzsjAx0UyzsbH6GKal6bilpACLF+vj5XKZ505urk6/55xjlk/z8/V15/zz9XJGHn/kiFlGCwvT50t+vi4Pn9m93ExIqal6wchIvXCbNkCzZpBuf4HKzwMiIpBZ3AztYwqQWtgCYWE6fu3b6+1OSDDLmPn5ejuaNzfLxG1iPA89PV8WFIejRZRPrUtxMQrQAhEROjkaFdJ79ujj3yKqTMfV7Qa2b9c7qHNnIC0Ncu55yM/X0TfKUIWFer9lZek4JCXp47Z1K3DaaTpu5/R0ITUjHB1L9+vMx7iwREYCf/mLudOMi41Rk9G6NcoQjb17gbN7lGH52mhkZen1OxxAnz76WPTo4anXKdY1wQXuZsjKgvf4t2un/5aUAHv3msXPiAi9b7Oz9X1OWBhwzTU6rbXYvsas4Gnf3jyxY2Lgatter8tIdA4HyjudgsjsdJS0PNF7T7Rhg073rVsDbYoP6xMgPt6sRGvZEmjXDmVN2yAuTpc/jIci+fnm5SIhQWcZXbqY90dG3dhJJwFtnJ7MMiZGF46MWrumTc1yVGkpSiJaoEl+ul63kXizs1EQdYL3+u106kPetClwWjeXzsjatTMzS0+hJLmsPQ4f1tcaQMenoECfB8btSOvWev+mpOh8sGNHswL+tLY5OvEYmVxMjE5nTifKEI3ycr3NylmOvOJItGypk06nTmbZJzlZh3XJJWZRpkvLPGw90Arnne3SM2NikFPaBAcO6OWNCjfjQYSRxZ1xhr6GG3lc06Z6XVFR+rvmh3bp+BrXc4dD/+3QAYiIgCsi2vvgXqKivffXBw/qoqaRf3uKLN5Kv1NP1dcn477EuEYb55fLpbNH44E7oK9Rubm63B8Roa9NxkPJ5s3Ne1GjzNOhg/6+RQszOUdE6MNqXO9bttTJZvdus4LuvPP0Pjv7bOCcrnl6++Pi9Aouv1xnGsYNjaf8W4ImaIISJB9pgs5tilAozdC8mWcHeDKbMeP1/unUSc/evBmYMweYNk2nm/NOL9H/3H03UFaGi7ZsAWlZADYGuawC2tkZl0CO2Qo0IiIiIiIiIiJqRHy7hlTHaLJ4FLECjYiIiIiIiIiI6pfR9zYYRrfro4gVaERERERERERENsjP3wWRrgCa1XdUGodgW6DVg4YbMyIiIiIiIiKiRkpEsGBBT5SV3VrfUWkcfN8WUdNUD9gCjYiIiIiIiIjIYuJ53ajbvaSeY9KINOAWaKxAIyIiIiIiIiKynHj+qnqNRaPCCjQiIiIiIiIiouOH0QKNgmR04WygWIFGRERERERERGQ5tkALSShv4awHDTdmRERERERERER0/GALNCIiIiIiIiKi4we7cNYCK9CIiIiIiIiIiI4nrEALSQMfA82SmCmlvlJKZSiltvvMe00pdVgpFeuZbvL5bohSKkEptVsp9Q+f+Td45iUopQb7zP+LUmqdZ/7PSqkoK+JNRERERERERGQHswUax0ALWlhYcFN9RM2icCYDuCHA/DEi0sszzQEApVRPAPcDOMvzm/FKqXClVDiAcQBuBNATwAOeZQHgXU9Y3QHkAOhvUbyJiIiIiIiIiGzAFmghMV4iEMxUDyypQBORFQCyg1z8NgA/iUiZiOwHkADgEs+UICKJIuIA8BOA25RSCkAfAL96fv8NgNutiDcRERERERERkR3YAq0WjoMWaFV5SikV5+ni2cYz72QAh3yWSfbMq2r+CQByRcRZYX4lSqkBSqmNSqmNeXmZVm4HEREREREREVEI2AItJMYYaMdhBdoEAKcB6AUgFcAHNq4LACAik0TkIhG5qFWr9navjoiIiIiIiIgoILZAq4UGXIFmW8dREUk3/ldKfQ5glufjYQBdfBbt7JmHKuYfAdBaKRXhaYXmuzwRERERERERETV2x8NbOANRSnX0+XgHAOMNnTMA3K+UilZK/QVADwDrAWwA0MPzxs0o6BcNzBBdZbsUwN2e3z8M4A+74k1EREREREREVHfswhmyY70FmlJqCoBrALRTSiUDGAHgGqVUL+gUcwDAYwAgIjuUUlMB7ATgBPCkiLg84TwFYD6AcABficgOzypeBvCTUupNAFsAfGlFvImIiIiIiIiI7MAunCEy3sLZQFkSMxF5IMDsKiu5ROQtAG8FmD8HwJwA8xOh39JJRERERERERNQIsAVayBpwF86GW7VHRERERERERNRIsQVaiBr4GGisQCMiIiIiIiIishxboIWMFWhERERERERERMcPtkCrBVagEREREREREREdT9gCLSTHw0sEiIiIiIiIiIiIao1joBERERERERERHV/MLpwUNFagEREREREREREdPzgGWi2wAo2IiIiIiIiI6HjCFmghsbALp1IqBsAKANHQdV+/isiIuoTJCjQiIiIiIiIiIouxBVotWNcCrQxAHxEpVEpFAlillJorImtrGyAr0IiIiIiIiIiILMcWaCGx8C2comsvCz0fIz1TnQ5Iw+1cSkRERERERETUSLEFWi2EhQU3Ae2UUht9pgEVg1JKhSulYgFkAFgoIuvqEjW2QCMiIiIiIiIishxboIUktDHQskTkouoWEBEXgF5KqdYAfldKnS0i22sbPbZAIyIiIiIiIiKyGFug1ULwLdCCJiK5AJYCuKFOUavLj4mIiIiIiIiIiOrMaIFmQQWaUqq9p+UZlFJNAFwPIL4u0WMXTiIiIiIiIiIiy7ELZ8isewtnRwDfKKXCoRuPTRWRWXUJkBVoREREREREREQWYxfOEFn7Fs44AOdbEpgHK9CIiIiIiIiIiCzHFmghs64FmuVYgUZEREREREREZDG2QAtRaG/hPOpYgUZEREREREREZDm2QAsZK9CIiIiIiIiIiI4fbIEWIrZAIyIiIiIiIiI63rAFWsgseomAHSyp2lNKfaWUylBKbfeZ11YptVAptdfzt41nvlJKjVVKJSil4pRSF/j85mHP8nuVUg/7zL9QKbXN85uxSilW3xIRERERERERHSuMFmjBTPXAqrVOBnBDhXmDASwWkR4AFns+A8CNAHp4pgEAJgC6wg3ACACXArgEwAij0s2zzP/5/K7iuoiIiIiIiIiIGgyzCycF7VivQBORFQCyK8y+DcA3nv+/AXC7z/xvRVsLoLVSqiOAfwBYKCLZIpIDYCGAGzzftRSRtaJT37c+YRERERERERERNUAcAy0kDbwFmp2dS08UkVTP/2kATvT8fzKAQz7LJXvmVTc/OcD8SpRSA6BbtaF9+651jD4RERERERERUe2wBVotNOCXCByVmHlajtmeckRkkohcJCIXtWrV3u7VERERERERERFVgS3QQtaAW6DZudZ0T/dLeP5meOYfBtDFZ7nOnnnVze8cYD4RERERERERUYPEFmghUkq/hTOYqR7YWYE2A4DxJs2HAfzhM7+f522cvQHkebp6zgfQVynVxvPygL4A5nu+y1dK9fa8fbOfT1hERERERERERA2OWYHGFmhBOR7GQFNKTQFwDYB2Sqlk6LdpjgIwVSnVH8BBAPd6Fp8D4CYACQCKATwCACKSrZR6A8AGz3IjRcR4McET0G/6bAJgrmciIiIiIiIiImqg2AItZA14DDRLKtBE5IEqvro2wLIC4MkqwvkKwFcB5m8EcHZd4khERERERERERA3YsV6BRkREREREREREJo6BFiKjC2cDxQo0IiIiIiIiIiLLcQy0kLECjYiIiIiIiIjo+MGXCITIeAtnA9VwY0ZERERERERE1GixC2fI2AKNiIiIiIiIiOj4wRZoIeIYaERERERERERExxu2QAsZK9CIiIiIiIiIiI4fbIEWIrZAIyIiIiIiIiI63rAFWsj4EgEiIiIiIiIiIqIqsAUaEREREREREdHxxezCSUFjBRoRERERERER0fGEY6CFhC3QiIiIiIiIiIiOL2yBVgsNuAKt4caMiIiIiIiIiKjRYgu0kIWFBTfVQCnVRSm1VCm1Uym1Qyn1TF2jxhZoREREREREREQWYwu0ECll5Vs4nQCeF5HNSqkWADYppRaKyM7aBsgKNCIiIiIiIiIiy+kKNKXYAi0oFo6BJiKpAFI9/xcopXYBOBkAK9CIiIiIiIiIiBoKtkCrheAr0NoppTb6fJ4kIpMCLaiU6gbgfADr6hI1VqAREREREREREVH9C74CLUtELqppIaVUcwC/ARgkIvl1iRor0IiIiIiIiIiILMcWaCGxsAunDk5FQlee/SAi0+oaHivQiIiIiIiIiIgsZnbh5BhoQbOoAk3pgee+BLBLRD60IkxWoBERERERERERWY4t0EJi7Vs4rwDwEIBtSqlYz7yhIjKntgGyAo2IiIiIiIiIyGJsgRYia9/CuQoW73jrOpdWQSl1QCm1TSkVa7whQSnVVim1UCm11/O3jWe+UkqNVUolKKXilFIX+ITzsGf5vUqph+2O98aNK7FsWVc4nQV2r4qIiIiIiIiIjjGsQKuFsLDgpvqI2lFaz99FpJfPGxIGA1gsIj0ALPZ8BoAbAfTwTAMATAB0hRuAEQAuBXAJgBFGpZtdxowZitLSQygqiq15YSIiIiIiIiIiP+zCGTJWoFVyG4BvPP9/A+B2n/nfirYWQGulVEcA/wCwUESyRSQHwEIAN9gZwbCwcACAiNPO1RARERERERHRMYgt0EJkdOFsoBVoR2MMNAGwQCklACaKyCQAJ4pIquf7NAAnev4/GcAhn98me+ZVNd82EZ6B60Rcdq6GiIiIiIiIiIisfYmA5Y5GzK4UkcNKqQ4AFiql4n2/FBHxVK7VmVJqAHTXT7Rv37VOYbEFGhERERERERHVHrtwhqyeWpcFw/aYichhz98MAL9Dj2GW7umaCc/fDM/ihwF08fl5Z8+8quZXXNckEblIRC5q1ap9neJttkBjBdqxxO12o6got76jQURERESNWN++XTF27D31HQ0iauCMLpwih1BSUlzPsWkkGnAXTlvXqpRqppRqYfwPoC+A7QBmADDepPkwgD88/88A0M/zNs7eAPI8XT3nA+irlGrjeXlAX88824SHswvnsWj8+JF4/PE2yMrKqHlhIiIiIqIA0tIOYcOGX+s7GkTU4Jkt0CZOfKce49FINPAx0Oxe64kAVimltgJYD2C2iMwDMArA9UqpvQCu83wGgDkAEgEkAPgcwBMAICLZAN4AsMEzjfTMs014+LHdhdPlKofbXVbf0Tjq5s//BQBYgUZERERExzyXy4lff30VpaX59R0VouOS+RIBoLS0pB5j0og04Ao0W8dAE5FEAOcFmH8EwLUB5guAJ6sI6ysAX1kdx6oYLdCAY7MF2qRJ5yMzcweuueb46pNtZGBK8S0oRERERHRsW7r0J8yY8Says7PRq9e4+o4O0XHIvN/2rUyjKhgt0Bqohhuzenasv0QgM3NHncNYv/47vPCCQn5+as0LNxisQCMiImqIRASbNi3nDQaRhRyOUgBAeXlpPcckOBs2rMKOHavrOxp0HNi9ewlGjx5o+3p8r2kibtvXd0yIiAhuqgesQKuC2YXz2GyBZoU1a74AAGRm7q7nmATPbIHGpE9E1FDMmDEVzz57YaOrOBFxo6Agrb6jccyYO/c3PPbYNViwYFJ9R4Wo3nz00VPYuHGWZeE1trLvPff8Dc88c0V9R4OOA59+ei1mzJh4FNZklm3cblag1eg4HwOt0TJboDX+CrT58ydj4cLhNq6h8bTmMjKtxtQCLTMzDfPmfV/f0aDjTH5+PpKS6t5SlSgYjz9+P/bt29zonsyuWfM23nmnI/Lykuo7KseE5OQDAIDU1L2Wh52fn4eRIy/F4cON56FffXC5HHC5yus7Gse16dPHYdSof1oWnpGvNpYKNDLl5KTXdxTIAv4t0BrXg8J6wwq0xici4th5C+f77z+CpUvfsCHkxpcBNMYx0AYM+CdGjnwIOTmN58UHpaWlyMmx/oYyIWEriopyLQ+XKrv55hsxaNDZ9R2NY96vv76Fbds21nc0gvbnn99j27bfLQ/XyGEF78wAACAASURBVJNdrsY1bMK+fTMBAIWFjWkog4bLSAd23GAsXToHiYnr8fPPIywP22qrV8/CwYO76mXd48Y1x9ixXepl3WSPxvjw2C6rV/+Ja65RyMxMru+o1Gjx4l9w330nYc+elfUdlWPe0azUYgu0ILAFWuN0rI+BZgUjswlrwIP8VdQYK9DS0w8DAJxOa58I5+Udwb59my0N0/D00//CO++cApfL2groRx7phTfe+LulYVJga9bo8Uf4pMxeP/74Cu6552LLw83NzURurvU3CJ999hC++eZOy8M18mS3u3Fdc434hoXVzzgcDYGVlZ5mBdrxfYMxdOg/0b9/z3pZt9tdjqKi+m31snv3TiQkxNVrHI4lja0Lp50mThwPAIiLW17PManZli06jklJsfUck+AUFuajTx+F9et/qe+ohMz+si7HQAsZK9AanwjvoHSNqzB/NJkZgLWVUTk5GVi71voWDkDjzLTMyj5rM/cnn7wUzz9/oaVhGhYs+AOAPfv7wIHGUZA4VvBJWeN0660d8OabjacVSWNsgbZ+/QJkZ+8BcPxWoO3cuRn33ReJ9evnWhSifS3QGlPaOt797W9noV+/8+o7GscMduGsrDE8HDQbKoTXc0yCk5SUAACYNevteo5J6Oy+P/RNbyxXB0EpvkSgMQoPP3a6cNrN6tZcL710A0aNuhPFxQWWhguYGZjVmVdJSTHS0xMtDdNkzw1FSso+S8PzZexft9u684cXnPph5TEkqorZ8qjxpLfnn/8HyssLAQBKNewbnKSkTfjjj2GWh7tli26pum7dbEvCs+uB0W+//YLnnutnaZgpKYm49VaFnTsXo7zcYWnYdhg8+Dx8/PGl9R0NqoEdZR2zAs363hclJSUYPrwP4uO3WR62HRpTDxSz623juF03yovGPXRjYn8DC46BFjK2QGt8zLdw8ollVezKAA4fTvCEb0chQmwJ+8knb8ezz55maZgGo4tsY8xwrSwIsvVA/eB+t09jPKftYuRzVqe3/ftXYuvWD49C19CGfSzfffdizJ//tm0V4lanZavDmz79N9/QLQlz2zZdeThp0r9x6aXRSExcY0m4dklKisOhQ+vrOxr1zuksb9B5r9VDXwD2duH89NO3sX37Uowc+T/Lw7ZaZmYG5szR41ZamQYSE3fhppsU3n33b3jttQcsC9fIrxtLBZpx/W7oD5QCsfJ+ZdbChVAxMSguzvHOYwu0EHEMtMapuhZo2dkLUFq69WhHqQGy54JsZ8HGyLSuvronBg68w7JwV69eCMCeuJtjAzWelhmG9PQDKCkpsiQsq8eAo+A0pnTndrvx44/vobAwv76jEhQWokx2jYE2YcJVWLPmeXz//fmWhlvxJtfK80RELE8bZutr6+K5YsVMvPXW037h15VdLxGw41yLjIwCAOTn6/HCEhIax0DfSUkT4XYfn9fToqJC3HJLFN555/X6jkqVnE4zD1y16itLwjTTv/Wtr8aOfROAf7wbqttv74v8fOvLB1u2rAIA7N27CosX/2RZuMZxs2Os6RUrpuLIkUOWhmlcFxtLl1N/1l1z3ho7FgCQnq5fBLNu3Q/49ttbzDU14Ar8BoUVaI1PdS3Qtm79Bw4c6HW0o9Tg2DUGmhGuPTeXZqa1YMF060O3sQLt3/8+FT/++Lzl4f/yy0u23cg/9thZGDbsBkvCamyDix8NBQW5SE7eY+s67Hgabpf582fhs89exkcfPVffUQkKK9BMxoMYu1o8Hjmy3dLwHI4Sv89WtmqePPlaPPGEPTcgVlagTZnykfd/qyvQrG7R53uuWRXXiIgov8+N5aZxx46B2LXr/fqORr1ITdUVBl9/PbGeY1I134qoyZP7WxLm0RgDrTE8bNu7d7f3fyvL63Zdt+w6bm63G6NG3Yc33rjC4nAbbwWaleWx8nL9gMK4Rnz55YN+3zfG8bjrBSvQGh+OgVZ/jEzMzi6cdrHjhtj3ydO8eR9aHv78+e9j795Nlodr2L59lSXhNOauhIWFBbbs4/79L8OAAWdYHq4vOwrFTme5LRVzDkcZAKCwMNfScEtK8rF06VNwOostDZcVaKbG9hbOsjL/tGBlWWH//qWWhVXR4MFNkZW135Kw/K+n1lxbjetdevp+S1u02HHtN1qgGay6aTwa+UJJSYrt67DCa6/di6ws6+Lat69+s2lDfjBkR0suczB6+277GvI+Ndh1D2BXDwm7xkAz4pudbU8LtON9DDSHpwItLCwy4Pcs+wWBXTgbJ6MgdDyNgSYiSEsLfgwP80Jk9dgnOmOxcxwIu9iTKR6NAU8bfnPixtyF8+mn78HTT1+E0lJrK2AOHIi3NLxA7KhAu+mmKDz++GWWn+PGzYHV5+Hs2aOwdes47N493tJw+RTS1Ngr0BpD6wvDnj3LLQnH93pqdQu0zZvnYOTIQZaECdjbhdNg1U3u0aiIcLlKA87PzNwZclh79qxDRoY9L1FatuwXfP31q5aH25Are+wp+9rXhdPQkPepwa6KC7tboC1ZMg5FRTk1LB08l8ue8rSxHxpjCzQry2NGJXhW1t4q1iWYMeMbbI2Ls2ydxxy+hbNxO5oVaPv378DKlVOO2voqiov7DL//fjkOHJgV1PJGZmP1TaBREL/vvhMtryCwu9a/sd4QN4b++L4FFKvGVfMlInA67XmTWmzsWgBmCymr2ZGujRtZuwrFu3ZtwIUXRmD3buve3GVXBZqRLhr6QOmBpKcfDGk969e/jY8+UrYVsKvS2MZ6rNyFs3HEGwAKC7MsCcf3emd9F05g8eKZloQJ2DW8Qli1n2vraIwl5XYHvhZNmHBWyGENHtwbL71kz0uUAHuOnRX5jH2tmfyPvxWVM3a9RMC3fNAY8m47Ws0C9p2zRlnmwIGN+PrrxywL1/etwenp1rRIBsz0sGPHIuTkpFsWroggNnYqCgrsG7LE0i6cnvTwzTf3BAx38eI/MHz4f9Crd2/L1nlMYgu0+pGRsRspKbU92Yy3NR69m4h+/c7GmDH/OmrrqygrS9eEFxYG16TXuBAdPrwFaWnWZcC+mc2OHessCxewv4LL7i6cdmkMFWi+LdDuvfcvloc/ffoneO65aBw5Yv2TdHNMRXvSX1lZ4NYEdXG0KjSMykUrmDcH9lR0GeFv3z4WcXEKDkdencI9Gs34H3qoG+bN+6jmBT3Wr9cDQlfVQsUudr2F0y6NuQWaVRVodowr5ttCpqzMugcOdlzjKubn1rVAs/8ccLnseZjTWFjxYMiuh0sVK2N+/HFAncO0qyug70PBxvASATtazQL2nbO+15XCwmzLwvV9QPbkk6daFq5vfDdvnl/lcoWFBSGFm5GxE99/fx9Wr7671nELxD89WNiF02FWUB45UrkeoqCgbmXH4wYr0OrHqFF/xaBBtRsfyByH6+h3G1u+fCby8jKOyrr8Mw+j6W3gPttV+eOPp/Gf/1iXAftmYr5Po60Ju/F14bR6HwTSGCrQfLt25eZmWh7+hg1zAQAHD/5pabhZWZnIzdUFH7sKWWVlJTUvFIK9e3d507LdFQNWFlrsaoFmxHHTpheQm7sLO3dOAFC3cYREBD/8cHQGso6PD77LnvF2vkDH3XjbIAAUFxdY2qLSyOdGjjwX8+c33DfkGewcA81uBQXW5J92tObwvd5Zmb7sqOyrWIFiVeWEMQC1ndxu6yvI7apAsaN8YkXll13Xxor7ccOGH+ocpjkYvbXlSd9z1I7yTWmptWWbxleBZs/9kG8LNAAoLi60JFzfc8LhCJzHrFixBKee2hIbNy4OOlyHQ19v8/Ks67EAAKtXf+n938r0UO5zDufk7LMs3OMKx0BrWF5//TK8+upVNS5nnEgVu3AejULys8/eitGjb7Q8XIcjH2Vl/rXevttjPJEICwu2P7E9lS6+mdjIkQ/bFrYd7GhhFOiiuWnTMjzySF8Ln4Dat1+suujb/VQ+MjIagPWF4i+++Nj7v13juO3dux07d1rXWvPqq3t6/7d6f1Q8B62s7DLSml3dygFg+fIHfFrp+q8nL+8QUlN3BBVmfPwWvPnmC1ZFsVphYeFYsGA04uN/q3FZo6LaqEjzNXr0Rd7/7767Je6662IL42gWR+bPf82ycIORmLgR7713IRyO4LuGV+zC2ZhaoJWXW3NTancXzoo3eXVxNLoBWtVa3LcCZdGinyztCmUIpgXaqlUvYteuL2tczvD++0cnP6st3/1qTQWaTS3KHf7p3or1GOk/L++wpeeVb0sbO1rk9e7dFCtWzLYsPN99OXr0fy0L166y3eLFU73/W1mBVjG+VVV2hR6ueY6VlwfOY9av1w+pN25cEnS4do2NeujQFu//VpYbfR+ClJdbO/bxcYUVaA3Hvn1rsWvXyhqXMyvQ/DMZl6vYZxn/ky0zMxOffPKkJU9NMzJ0jfU11ygMHVr75tsFBebb6CZNaoVPPmldYQnf8Quqf2tIRXZUFpWW2tttyKpCtIggJeVgpfmrVlXdZLm2KhbK16+fh2HD7seffy5EZmbtWiouWuQ/zp2dFYtWvY2n4sXY4bCuEOh2u7F9+wrP//pCnZq6G4891hxr1nxfp7ALCvK9/9tVyPrvf6/BwIG9kZgYj3vuuRqFhdY8TQSAP/+0bhwioHJ3UyvTnt0t0AAgJ2crnM6iSvMB4JNPuuLdd88OMsyj1+pTqTBMm/Yipk8PvvtDoAJrbm6y32crx6/LybGue0pVVqy4N+D8b799BsnJm5GeviXg94FUbPVp1cO1uXOfsSSc6oTyMMLhKEVJSeDuNna+RECv264unNbEtWIFmh1dOF9//QE8++yVloTrv47KZS2Hw3+Q8s2bR2PZskerDcd3H6xdG3yLkvrge85a0VrOd9uPHEmrc3iGv557boX1OOtcOWVcqzZs+Ba//vp+ncLy5XuO2vUQYfr0ry0JZ8PmzZXmzZpVt/KdoWLZzor8MD09tcIcKyvQ/MvPZWUl+Prrd5CTU7cXFfimgaoq0KKjY6r9PnC4lc9Xl8uBTZteQFlZ7ePse5y++eZ/lrWi9W2BFsqDOfLBFmj1b8eOVQBC6z9uDpDvnylu23aN9//Y2Jf8vnvllSGYOXM8Fi2ailBVzGx932Dy00+fhxyeYfjw6sdU27DhPGRlbQBQmwo0628Av/9+QqV5Vt4MWxXnCRPG4KabumHPnu1+YQ4adK/l8d23z/9FCoMH34jsbP1EuraZ/YwZ/i+rWLLEmkJEIFZVoD3++Pl+n4cPt25A1d9++xgFBfoibFyoZ89+H2VlRfjyy4fqlG58x3qwsgItUJxuueVMrFu3AosXW3cjM3asdW/CA4DiYv/ChJXny8qV+onmmjXzUFJi3VO/qh4W1OUhQsXKgcOHrX2dvK9gWsa43U5kZcX7fD56wxcsXPhzwPmLF7+JMWOUX1ovKyvEwIFnYeHCN5CdHVoX2qSkXwLON56+R0TEBB1WxRuQ6irQRCToPGTdurHe/7dv/zXo+ARy4MBeLFkyE1lZ/hWfbrcTeXnpeO+9NvjmmyHVhvHYY2dhwICWAb+zuwunVS1aRATz5s2xJCxfgwff6vfZqjfPDRv2P7/PKSkJKC8vt7hLa+Wwtm9/KcCS1fNtzWh3K/GEhK3YuXNTrX/vW4FmxXXHt7Lgn//siD17rO1e5mvKlMpl41D4bu++fbF1jY6XfxdOeyrQMjNrP1SCrzmLFlWaN3ToQ5aEXTHtW7EvKpbvt29fUOcwzbD9r+9DhtyBceOG4uWX6/YAx3e7q2rVFhMTU+33gQSqQPvuu7Owa9cHWLduaIix9GVet9au/RmxsavrEJbJvwUaK9BqzaK3cCqlvlJKZSiltlsVteOiAu3FF/8GEcFrr11T6buyspKAF32jYFjxJqKoyHyCkZDgf0EzMo7aNI8ONJaGbwZX2xv4pKTd1X5fUrIb6elLAZjbqlT9vX440HgHdg4kvHr1cowd+3bI4fz55zIAwKFD+zBz5jd+3516qnX7b+7c6m+gKlZGBKtieps9+7NahROM8PDQxtQLlpWt/fbvN7vdTZ/+OJYu/crve6ez9mmwsNBsgbZunTVxdrvdmDv3kyq/f+KJx2sddkFBaIO7hkJE0Lt3+0rzrFBeXo7x4z/wfraydVRVFWW+N6FpaaGNnVda6l/BN3r0G6FHLEjBtIxZtmwoPvvsTO/nYLtMWHH8tm8P3P14/vxXAfiff4cPb0BS0k7Mnz8cL798Xp3XDZiVAKFc+ypWoOXlVV0Bunz5AIwbV/Mx2LTJP7//+ed7go5PIH37no6BA2/Ff//bxW9+UVEOnn32JJSW5uLXX0dVG0ZqauCXqpSWlvgdt6qWC5UdD+a2b/cvM69d+5strd2VCsPOnSuQmVm31kizZ1fuat2r10m46qrgK3gNxcW5KCsrRmlpvt98l6tyWcvpDH5ga7fbjU2bvsPWrWaldGJiPPbu3RtyHGum08R//9sLDz54UQ3LVq1inltXFSvhcnOteTlHINnZdR230DyvrGwp5luBlpKSZMt5FRUVeroPxK5W3yKCpKQEv3lWPCwNdO8TF7e+zuECqPTit/h4XTFd1/Kf7/10TS3QaluBtnz5Hdi37yfk5up97nT652U5OXuQn1/zA8ny8jKsXOl/77NoUd0eWgHAlm3bUFxixoldOGvJ2hZokwHcYGX0josKNAB45ZXeSEqqfEP1z382xciRd8DpLENp6RHv/GBeIuDbnRMw37RXm6dwFTPbsLBwpKebGcC0ad+FHCYQ3AVjy5aXMWaM8lag+T5Jz8k5hLS0XQCABQvewdtv+75y9+h0QarLBbm0tNSvC13FG+Hbb78Go0YNw33PPRdSuL5dxXbvDr7bT6gOHkyo9vviYv80mJqaiscff7DGijW7nhQGEh4egbS0w9iyZamlXQutKgwNHnwF5szxH+dl4sT+WL7cnGd0YcrLyw25IOub/saM+R/WrFlVh9gCzz13M+6/PxyTJ1f9pDA1NbXW++fRRwN3c7NCoHTpdrswbNj/YdWqpXUK++BB/4cFVrSGSEnZi+Li/Cr3pe84QrNmmd2s9u+veVsq3sxZ2bqkIt+WMTt3Lgy4TFLSMr/PwbZAe+uDD2peqAYVj1XFsV6MAYQ181gUFFR/wxpsAd1YLpRWdxUr0ObOHQgA2Lv3Z6Sn+4+DFx//BQBg0SLdIrygIAX5+ZXfXD1xYt0qzIK1Z8+yGpd57rkrsHJl1eWOrVv9K4zj4lbUuRvuokWzsWjRjIDf7dlT2zeqB77enXpqk1qFVVBQgM8/HxSwskREMHz41bjsso6WdyOvzb6dNm0CXnihDZ5/vifGjevj953DYQ7vUVBwGC5XGdzu4B/+Tpv2b/z8cz9Mneo/jtTadXUbi/PAgd3o2bOV37y0tANITKx7q6navGxn6dK5eOaZwD05Knfhtf+FT7Xlmx6Li617A+CLL/7H+7+IoF+/O+sUnsvlwlNPXe03LyamdudqRVWdk927K+zYEdzYpYH88ssYLFv2h9+80tIS/Pln4GttsAI1KPjmm4+wfv0iOBwOZB05EuBXNUtI2IHhw28L+N2sWdORV4dKtI0bl3n/Ly8PfP2NjNQP1UMp8/hWoB06NB1Llz7g/bxnzzfe8b337ZuKH344A+PGdUVeXlK1YRYVVd5/P/5Y9YNpXw6HAzfe2AcdTjnFb/7vv/+OC669tsKywTV0cDeCl7kddRZVoInICgCWjhNyzFagVcwo9+2rXGsfFzcPALBu3Sx8+mkz/PxzN+93gcZAKyurvrAe4WlG6Ha7kJOTg4NJ1Z+8vl5//Um/z0qF4a67TvN+3rx5TdBh+Qp041dQULFfvWa8RMA3oxo+vCveeqsnliz5EjNnDkVi4jrMnTvKE7b/Pv788xG45Zbad9crL3cEfPvU1q1bkZycHOAXNet92WU45xyzMFbVBXTqvHkhhetbgRYoTOta1VRfoD1wwP/tLkOGvIzffvsBixZN88ZvzZolWLPG7NJXUlKAOXMqP2XJzg4tbykrK8OmTZW7U1Tc9oiISPTu3RnPPtsHvXrVrsVIWlrl4y8iSE1NRWpG7caBc7vdSEk5gPj4mptsG0/vL720Ey6/vENI6/GtQAOA/Pz8KpY047Vq1XTExa1GXl4O3nzzP36vvF69OriuSLl5/oVkl8uFgwfNcfsWLJiLV157rdLvjG6QVvvss3G44op2leaXlBTjl1++wJ139qn26afb7UaXLgpffPFawO/37o3z+2zkJW632288imCJCJ566nQ8+mgr5OcHTmPLll0HAIiN9a/M/O67Ppg0qV+1Y3wMGuRfgLVz/MfVq823uI0d2zdgvCqet1999VfMnWu+DbOqVpg///57neKWlpaKqVP9C61hYRFYsWKE9/OLL56AZcv05+Li4Ft5JCdXboFdXl7qV7Dfv38TMjN1ZZbLVXV+O3HiO9iwwcxHq2phMH/+/fj007MDdttMSNBd58eMORnffmu+uXrOnEGYM6f64RaOpvLyUuzcuRoTJvTzzvv1V/+K0kDXuCeeuBezZ//q9/Q9WL/++iP69bsFS5ZUHjB81qzp6NnzDAwbPrzKdVdn1Kh3As4XESQkmA+pMoK4Bo4bNxozZnyM229vX+m7TZvMrsgTJnyCnLw8NL3gAqgOHTBy7NhKy9fGiBHDsXPnTuzZE1/jsqNHPwEAyMo6iEOH/K/VDofeVrfbhYkTO+Prr2OQmRn8Q4zt238KON9Zx4dzM2Z8XemauXXrcjz33PlV/KKy8vLygGXJ7OzQywqPPHITZs6cgl27tlb6rmLZr6ysFE6nEz/88DlKa9lzoqpKheXLZ+OccxTeemskAH29KC8vR0lJCUQEn38+Evv2VV0J5FteLyrKg9vtxsqVKxAfvzPg8sUlJZXKEIFs3+6frhYtmlvjb3bsWB+wQnjPnu2YMOFpbN26wm++kdd+992XeOCxx5CWWbvWePnVPMCd+kvg7v01+emnjzF+/POV5o8ePQT9+/fFpk21f6t7oAq02bOn4Kmnrkf37tFof9ppQeWFJSVFKCkxK3ESE3dVu/ya2NpXVv/+u9l7o6ryj9E1NZgHXLNnj0P//k2996dVKSw8DLe7HIsX3+edN2XKdSgt1WXKjIz9mDHjCxQUHEHfvgpffz0Sn3/+7yrDyy8owJ4q7jvXb96M6NatsXz5UmRmZqJLF4UBTz2FFi0U7rzrrkrLB9MCLcvhQPjatTUud1wJrQVaO6XURp+p9oPHB+mYrUA7cCCuxmV833Qp4kJ5eSG2bdM3A+vWLfHMN0/arVsrjwWUk5OEFSv0mGe+LdCuvPJ8dKswEGhpaSnyAlyQsrLS8dtv/oNkVhxLo3nzFgCAQ8nJeOTxx4O+2QqUuX78caeAy5aX64vL4sX/RkqK/030pEnmQLK//z4kYNhffjkSbrcLq1aZL2koLS1Fapp/d4bVq1cFrBC76672GDPmtUrz/96nD7qcfjr+WFnzyx/Ky8uRlpaGVauWIjk5GVu3moWeI0cyUVQU2pOVPXv34rPPKo89YVSgibgDNofftmMHLrj3XqTW8ITI6XRixowZfvsydscOJCUdxK5dWzF27GvV/v4//7kXS1esgIjg0muvxfff6xYDkZHRcDrL0atXSzz88LXo3/86jBnzKvLyjiA9vXLLBwDo3PkEZOfmBvzO4Dtw/7Mvv4yLLr4YGzdvxvz5ZqHpoYf6+v3G9w1iiYmJmOdzHAsLCyuN81BcXIQHH7wFr7zyBPr1uwklJcW45hr/LkiATn8nn9wJna70H2B525496NO/P/ILCpCbm4uhQ1+qdL7MmvUTnnzyAdx++1+q3V7DunX6ZsEo0Hz55TgA+vi9884TAQuhmzevR0bGYWzZ4l95X17ugMPhqLLgM378KAwffgcGDLgC3377IebM+QZjxw5DbOyfIY3r9dM0XYlaWFyMgqIiDBo2DGec0c1bUXrXXTfhrffe82udER+/I+DLGVJSDuGLLz4y3+RVUID9h/ybyPtuz+bNy3D48AG/7wcNeirgzUFenlmQPv/8qgfgN8ao++GH97zzdu/e6r2J2bbNv/AxZIhuGdH/6acRdWVog3C7XC6MH28+1Ni0aVrA5dxuB0pK0pCQUPnmePXq7/Dcc2cFfbP/xx9TMWPWLOw7VLux0FJSU7FmzQL8619X1ZhOtm3zf4lISUkW0tI2Vlpu7tzXkJ+fjry8vZg379WAYW3ftQtRZ54Z8LtAnE6nN43t2rUDZ59d+XrkcpXjzz9H+s1bsWIktm79GVOn3uc3v6SkCFdeeQZ69qzc6icpqfKNwjvvnI433jgLgL5ZHTHC7BJWWprjLfSvXr0Qq1YtgNvtRkFBPsaMGYqnn77Ou+ycOeMqhe17rIcMCcPYsRcgKanmMZvWrPkYu3dPqXaZ/Px8pKWbeanT6URCgh3d5YDCwsqVlJMmveB5yOVASko8ArVAX7VqMQYOvAeDfCrmHQEqMoYOHYJZs/zT4IABVd/MLF6sx/55+733sDUuDmHt26PHOedgk0/XzKpeKpOenoqpUwOPSztw4D3o2bMHhr39NnpdcQVO7NMHS/7UN7xbtmxE9+4KrVsrXHPNecjP19fGpKTA108A2LnTfBAXG7sZW3buRInn2jPio48qLe92uzFs2IuIj9fbUVRUhCefrP7NgG+99QZ69ToLl1xyJh5+9tkql/MdOiAQp1OX93wH4HY6A/8mLm42iosLsHp14HzQ146dO+F2uzFryZKQW+G53e6g8st27RRyc/0HDnc4zAewZ/TsiVN79PB+53K5ICKYP7/yORa3cyfyq3lwYzwYv+22XpUqHiqW/V5++X5ExsTgxRcH4MV3AlfaVsfhcGDYsMBvnt+xQ+cjb7wxAqmpqWjSoQOi2rTBiSc2xdat6zFx4gg8/fT1nni5MW3al8jLy8Tdd0fhgQc64scf9TiRbwAAIABJREFUzaFKCgtzMXXqe7j22qtxySVnYVN85crYy++4A2189mEoRASjR4/G4jXmg3+n04mffvsNGRkZeOSRS9G//23ec6q83IHx49/CTTedg1mzKpe3y8sdSEtLxjPPPIqffv8dffv31/urvNybxo5kZ6OoyKwkKisrQ35BAUpKSjBp0iSUl5fj44kTq4xzVWkvKTkZ99xzDSZPfhsvvPCE9yHfrFm/oFcvhQ8/DDxGrDGExHvvvQwAmPj992hz7rkQESxatQobNmzAr9OmITZ2C1atWo50n7y9oKAAv//+JWJjK1+TK3I4yrx533mXXop+/e7yK9PNmvU5/v735rj5Zv3g99tvX8QLL1TfyyAnwEPeCd9/j9khNjSYMeMTTJkyBvPm+Y9xapynZWW68nfduoUBx3OOjV2Nzz57Cg5HCTZs+KLadblcpYiPf81/O3L2YujQlkhOjsWgQadi1Kj/ww8/6PvXr74agd27lwUMK+KEE9DqzDNxxoAByKqQN4gILr2hck/AzydPrjJuhYWBG634irWwd84xJfgKtCwRuchnmmR73IynpA19gu67uhtAAoDBQSwv1U1vvy1VfnfyyZdVmte9+7+qDW/YsCly7733CwB54om3vfOLkpJE3G5xOkX69OkjAOSyy66W337bICkpIu+9NydgeCec0NXvc7NmzeXvV1/t/fz7lCkiaWly5Eix9OlzvYwbN0EWLFgim5Ytk+xskT/+2CXTpm2Xk07qWm28fafWrXt4/2/e/BS5++6Z1e6/E088s8rv//PAA5K4fLlcd9VVAkAKsrLk1VdHys8/zxAAEh4eLiNGfCAPPviw7N6dKC++ODKoOD7fr5+s/uIL+b9bbtH7vX9/kcJCWbduu+zYsVcefri/d9mOHTt6/3/00f/VGPYtF1wgWd9/LzJtmsiiRbJzprn9hw6liTidsm7tWunRo6d3/vvv/yCXX35DteG658+XNx99VJ667Tb55q23ZN0vv4hkZYkUFsqXn30mAGTi6NEiaWny/fc/BH28fKdzzjjD7/N77/0gTz01KuRwLjv/fJGNG+XIwoVy//XXy/pPP5XJr78u88aPl+++/FIAyDvvjBJxOOTcs88WANKmTRsBINddd4O8/vqHQa2nXdu2MvGdd7yfJ06cIrm5LklPz5XPPvst5Hgve+01GTV4sLiXL5cbr7xSAMhJHTrIE08M8oT/tQwf/qlcdVUfef31j2u1jz/8cK3f5wceeEImTJgtAOTaa/8hpaUiDodLfv11mpSVOasM5+OPJ3r/X/DFFzLwwQelR/fusn7pUpHiYunT5ybv92eeeX6t4mpMkpYmbVq29JsXG5sgv/xibst3kyZJcbHIli3uKsOJiWkiAGTFb7/JjA/NY7xt7lzJT02VxYvXSpMmTeSqq/rKwIEveL//v/97WZKSsiU1tbjKsO+88z/+cc7Pl7wdO+T5Z56RNWvipLjYJa+88qnfMomJ+bJ48RoBIC+9NFqSkjIDb392tvf/wj/+EImLk/y1a2XBl1/KZxMmSGRkpCQl5cjzz38o69aly/z5O+TzzwPnyVVNp5xyb7XfX3ppX5k1a7lMn35IVq4UmTlT5MgRR7W/if/wQ3H++KPIjBn6BwsWiMTGyk+ffiq33nqb7N+fJNnZIvn5Ig6HiCs/3+/3c+duqTHe//rXt/LBB9kyZIjIOec8Xqd0BkDyvvpKZOpUKf3jDymZN09k7Vo9paWJJCeLZGVJ/KZN3uX/+GNBndcJQNq1O8n7/7Jl22X/frf88stGGTFirvTocWGVv5s0ySkDB1bOr2JiWsgFF1xf5e8mTpwvJ5/811rHd9CgI97/b7hhmAwatLja5desSZU1a+LMNH3ggCycPt37ee3abbJv3wHJySmVvXszJT5eREpLJS2t6jJOxWn8+GSJizsku3a5ZfNmkaFDNwdc7tNP1wcdpixaJDNH6WvQtmnTRJKSRIqL5Ysvvvcu8+efuyU5uVyuuqpP0OG+PdIsK7Rq0UIO//mnXHzxJQJAvp08WQYOfFzS0nLk0KFcOXzYIU2aNA3p+JzXs6d88MFYufDCSyp9Fx4eHlJYMdHR/vtk2za9H1JSRAoL5dvx4wWAdOnSTaZNWyhDh74VcnoqSkyUxMT9kpnplrQ0l6SkFMknn8yRCy64usbfdu36b7nyyg9CWt+IEWvlvfeqzs8BSP8HHhAAMubpp0VmzpSC33+X2e++K68+9ph89+GH4naLSG6uSGGhZGSISH6+7N1bIJ06dQ46Hn373izuoiIpzsmRO27S18xTTukm7pIS7zLZBw9Kfr4+D/75z4flrLP8j+mqJUsEgFx16aUic+bIgZkzJW/vXpHYWHG7RdLSSqRVqzbe5V999XNJTBSZPHmDxMYeljFjZlcbx93jxoksWiTrx4+X+R98ICUJCbJqzhxJ3b1bX+cOHJCbr79e1s2ZI+WFhSEfeyun/PnzpXDBAvlm1Chx79rlnT9//iJxHDmij1dKisiBA/L777psvGfPoYBhtT/hBO//23/5RWZ99JGMeuGFgMt27XpqjXE777zLpFOnU/zmPXTnnQJA+t1xh8iBA9K0aVPp1q2b5GRkyAN33y0dO3YSAPLMo4+GtB9+HDdO3OvWybR335WunTpV+n748Hfk8ccHBRFnM61N9CkzDRkwoMrfOIqKZP/+I0HHFYB89tlCASB333prpe+6dTu3Vmnh01deEVm/XmTjRpH4eNnjcy9UXlgo3377vRTm5YmUlkpubp706HGGfPjheJk8eUW14e7adUgSEkTeeusjASDdu58rQ4fq8vDddz8lK1eKxMWJxMUVy+LFh0OKc1RUyyq/a9asXa32AwD57rHHxL13r4x88EHZ9+efkrd7d63DqmoqPXxYPu7eXQDIhTExUt/1LQ1luvD880UKC4OaAGwMol6oG4DtltVL1fcOCiqSQDiAfQBOBRAFYCuAnjX8ptoEe+GFj1h+EhhT586nef9/8J575MEHH5Qffpjit8y1194q8fG5tV7HwP79ZVAVGXH//k/Ytm3G1Lfv2yEtf36vXrbHyYpp3MCBsui11+S7wYP95k+fPktm+ty0GNPQoR/VGObPw4ZVmufKyJANK/wvNsMG1XxRPhrT0/fdJw/ffHOV3zdt2lRWLl1q6To7djxZhgx5TQDIo48+Z/k2XXzxpbbvt3PPPU/atav5Qn3xxb2r/O6JAQPk8suDv5msaZK0tErzmjVrVmlecbHIkiXptu+jQNNVV93o9/mBu+/2/n/bbXd5b459p8suu0qGDBnh/fzCC4MDhn26p1ACQDq2bSs/+FTaGtMbb7x3VLazc+fu8vDDr8pLL/0kmzbFV7tsj5NOkqbR0dL/erMi57JzzcLw3/52lcyZs1JuvfVO+fjjTysd07vu6hdUnM477zZ56KFVAihLtvGy00/3+/zU3XfLFZdcIrtXrJANCxfWS/o61qbdnpt+O6aLLrpKFi/OkHPOuaXOYa3/1L/S+90hQwIu16pV6zqt5+4bqn6AdfbZDavccem558oZp50mn7//vqQkJFga9q236nyzSZMm9b6dxtQkOloOT55caf6LL74kL/7vf5KSkCAZGSJPVVOpEOq0dP58v889epgPFyMjo6r83f2eB9Qntm8v08eMkb59+wZc7o47Hgo6LrdcdJG81q/qvPiBu+7y/v/uW6FXnlqafq68Uu6/9loBIP1uu83vu7tuu02uu+YaASBn+eTx110XeB9ZPXXrdka13991o1mGuNtTsWbXdOaZZwe13NlnV/3wpqFPbVq2lG1TpsiEwYOlSUyM33e3/fOf+u+tt8oXEyaEFO5FF10qgwe/L4899kzA7999d5ace25v6dChcsVlfU0tffLT888+Ww6sD/4hUrDTvo0b5dnO+uEBK9DM6cLzzxcpLg5qAivQqtzoywDM9/k8BMCQGn5T7ydeoKl37yvqPQ51mbp2vaDe42Dn9JLNF19jerJ//wZV0OV0bE6jAlTeGlP//gO9/19xxd+kY8fgW6ty4sSJU3XTfZ4bbk6cqpp6dO8unTsfm9edv3TpUu9x4MSpMUytW+sHz1FR0fUaj4pT+1atjtq6unvuB1mBZk4XXnCBSGlpUBNqqEADMAVAKoByAMkA+te5bqq+d1BQkQTuBvCFz+eHAHwaYLkBADYC2NiiRdt6PfH69x8oN15fuRvIrl2HZcyYryxf3/vvfyBhYWG2b1efPk/X+rfnnVe37mjVTSec0E5efHGITJz4da1+f8d111Wa98DNN8sn778v7du3F0B3VVy1cqVceOHltVrH0tGjJfbXX+VWz1O+QNP1118vLZo3t/04hjqd5ikMjhs3Xlq2rNxU+o8/5gUd1puDBokrKUnefPFF2+L7xH331ev+ivbpujN0aHCtNUcMDtyKyqrp6sv9021aWqHEx8ZaFv5ZZ51Tp9+3adNW7rmnfo9bQ5xu791bbr7UbEE5ZEjlStG+114raxYulEWL6qcVYcUp/bffZPmECfLN8OFy6imnyAlt2tR7nI7V6bTTetR7HEKZOnQ4sVa/mzkztK7VDX36//buO76pqv8D+Oeke9HSUtrSAmWXPeVhbxUQEAURcSCPgCg4QQEVEQS3Iir+FBRRHwFBBFGWoLJki2wBa2XJEsuujJLv74+btEmTNEl7b9OUz/v1uq82d5ycJHec+71nRERESO8ePWT//r9kxIhxBU4nrVo1SU1NldA8NUWK6/TU4MHSunVrad60qd11sn//h+WNN6Ya/v4JCY61Wx7773/tXldMSpLyTgJgVavWkUceGSODBr2Q73s8+OBwual1a7t5Hzu5vgcHB3vdLLgophstZYV+t98ud999T77rtm2bfxcmnOynof3y7w6oKO7jCjIdXLNGnhg2zJC0H3vsTQkPj/L5Z8w7NaxSxeWy0S6aJBdmahwRwQCazdS4USOtjxIPJnhQA0332JSvvyCPMulhAM12Kls21bCDKiTE/ZOlF198TfrdcYcAkAdsLs5aNwLXJCAgQEqVipY6dQoWjDGZTPKoTdv+q1fNsm9fRs7rChWqFihd26lly7EyePBCu3kPPvilBAZ6/pTguSeeEADSvFkzWbfOeb8qAGTy5E/dpvXB8OE5/2/58EPpawlQ/rhokRw6dFouXdJqc65ftcrj/CUlJctXX/0k2Tt35sx7+Z575OJ334ns2SNy7pzMnTtPhg17VP69cEHEbJaDBx37iipVyrEZyrGffpL06dMlMixMurdoIbJihcjOnXJktWM/AfvWr5e/d++Wy5eviBw4ID179vb4M7iahgx50ettKqXY90GSvWyZrP7oI5Ft20SyssRsFrly5ar8deCAxNs0Vzx9+pJkZl6TuLj4fNN/4oknxfzbb1qfSIcOuVyvfv0mXjVlbFe7trz+7LMycdAgufTLL/LZS7lBqwcf1Jo0Dx48Sg4ePCMLFqyTd9+dW+jvF4Bs2nRW6tSxb2KYmJgo589nyRtvTJUtW67Jxo0Zdsvr1Wsgmzdvl2M2n/+uPn3kwrFjOa/bt9cCSZUru+5n0Jtp3eefS/rmzTmv//e/lXL+vIhkZcnHU6Z4nM6/6ekSHBQkoSEhsuTjj8VkMskrlj6J7rijn0ydqvVfFxubIJMnfyMAJCEhUVat2irff79SBg50HSQ8fPiSXL5sltDQUOnaoUPOzdXvvx+SN9/80m7dvn3vl9at28natf/Ijh2XZebMr+TTTze4THv3rFmy9KWX5Movv8iYBx8UAPLuO+/IY49pzabr1v2PzJnzsy7fte3UtOntopSS4GDXTYfyTnd36SKVypaVV/v1k8Vjx+b0gTZ1zBjZ+9NPkp0t8s0338nYsbl9HB7Zv1/kzBnZulXk0UcLfjOux7R/2jSRH3+06wPNfPiwXDh4UA7t2SOZmf/KuXNmGTpUvybrb701XSZMmGTo5/ryS9f7l6upUaP+Mm7cAbt5nTt/6FUaa9cekWPHXPeP9Ntvh+XnnzfI8uWrZenSddK1652yfNEimTLlf/Lyy54/rHvvvRny9NNvCACpWrW1y/Xq13fdP5x1+myS429xZtcuOX/ypPz9979y9Kh3gd6QkBDJzhbpf4/jzfyfK1fKN998JyeOHpXTp07J7bf3slveurXjwzHbqVat2lK5YkWXy48evSjVqhWsz7vxjz8uH77wgkx68UX56OWXJX3xYrmpTRv5/N13xXz+vJj//lvOn9e6lkpMTCrQe+xft07MZq1b1Zkz8++Ty9nUr992t+tUrtxc7r3Xu247fvj8c/lx8mRpU7u2bHv/ffl74UL5fdEikYyMnD7Qzh8/LjNmzJfuXbrIkSPXvOq3L78pOjpazmZmypczZsimTbvl0Ue1biFMJpMkJiY7rP/LokViMpnkiwkT5NrRozl9oOVdb+tWkYwMkW+/dV12mTd3rhw9KpL5q30/lBeXL5fxI0bI0rlzxXz6tGz44Qc5e+CAHNu5U/Y4KRN6O5Uta/+5JkyYke/6gYFB8tVXC2TbtnRZ92HuOcn822+S/r3WP+X4kSPl/Pks+WnRInnq0Udl5pQpcmjdOrl06ZpsXrpUWrduK0uW7HSa/q9bnZf3+/a9W1atuiBjx06SkBDvgr7r1u2Wz23KKydWrpTN8+fn5PXoX3+J+fJlXfYhAFItNVW6dOwokyd/LqVKFaxSRsWKVaVurdx+k2XvXtmxdKmYr16VZTZ9i02f/omcPnlSTp266vV7VLEEehrZdJVTo4brrkLcTdk7d0qG5XsFIFmbNolkZMjePL/pzl9+kbFjX5AdOw7I9u1/OKTz5Zf/SLt29q16bGuZJSdr+X7++U8kLU1r8tq792Dp0KG7fPyxcV0VeDJ9O2OGLBo3Tno2dt4U9+3XX9f9PduXKsUAms3UuHFjkexsjyYwgOYikwVowpmQUMmwA8s2gHbjjc/JF18clcmTf5b163NvUD/99EuZZLmJX7VypQwb9oiMHzdOzpzR+lRev/6EHDx4RVavFhk92nmn5tZqrdYpKChIvp01S+s5+sIFkePHZfTo52XGjNmSnS1y7pzWeeqIEWNk506RRx6ZKNWq1Zdhw951SDs21j7A1qWLfef1TZu+IaNGibz7rsjjj6/Jmf/MMxulb9938v1+unXrISMfe0zObt8uy+fMEQDSrk0b2bNHCyS0bNkmZ92IiAjZtm23zJnjuiPlunXrysZVq0RWr5ZzP/8sf8yfL7JypZz/8Uf5ddYskQsX5Nw5yQmgWapzCgA5fOiQpKXVk+HDx0rDho79YNWt21COHhWRPXty5u177z0t2GUJoGVna0Fuyc4WMZvl0CGxS6NChWry+uv/s5v3y+rVWofBS5dqHYCvXp0TQJP9+2XejBlyYM8e2b55s6xcuUrk5EntRtMsIgcOyLlzIqVLx+X7PQOQKVM+EfPp0/KqpTbXXXf1ky5dekq/fkNl06ZrsmLFfgEg48ZNtesM19mUlSVydc8eubJhg/y5YIFsmj5dy/PWrXYBNLNZtC/kwgVp1KhRzrZnzoj89Ve2vPmm62DohAkTRfbudQigbdr0hyxblrufzZ27Qv780yxTp86TBx8cm2++F37wgcicOVrnzJbv/aNxuUGE8+evyPLlq2X37ity5ozI4cMi6eki77//Zb7p5p2UUtK5s31hYM8ekU2brsrJk5flppu0J7E7d+6R7GztON+6VWTz5gM568fFJebsq3Lliph375a9lsED5Nw56dWzpwCQb789Kxs2aLvLunUi8+fvkmXLPOtUddSoV2TFih/kvddek4Z168ozgwaJ7Nghf1s6Py1VqpTs3y85ATQ5d04GD35YnnrqbYmL084506Z95ZBuzZr1RI4ckbMrV8rZtWu1LzEjQ8znz8trr70jhw6dlt9+0zqzHzLkJdmxQ+S99+bL3r2H5cwZ7TPv2SNO89yr1wA5edKyWx07JlczMiR91y5ZunS1XLoksnz5n3brnzhhlvPnte9n717tY2zdap92YmKKrF28WM4cOKAFcr7/XmTHDrn666/y/ccfi5jNcvr0GXn88adl3brzkp4usnfvZVmw4FdJTq4kXbq475cnJqa+VKjQy2F+XFx1mT79msyZI/L113/KH3/8I5Uq1ZaKFWvKtGkZ0rHjzTJ27EdSu3Zugbdz5x5yc6dO8u/69WKeNUtk9myHQQTk0KGcMsOpU9ckKamc3Hff/dr1wBJA279fZMiQp13m+YknfpQHHpglffpMk/LlG8gNNzwujzxilpQUx+4FTKZAqVzZcVCdvNOcd96Rg++9J1dmzhRZvNghgGYdREDOnZOsLG3fO39e5OTJLElNdd2JdOfOnt20Hz2qJX/8uMiLL2o3WOPHL5dZs45L166vCgBJS7tHEhLay403PpdvWtHR5eTuu5+X5csPy44dlyQj45r88YdZ9u51vu+6Pg4PyiuviEyefM1u/siRVyUurrpHabRsOVzS07VLvpjNcjw9XeTAAQkMDBQA1sNXsrO1YyAzU+wGEVizxv05o2PH++XVV7fLqVMiY8dqndp36/aCvPvuFunZM7e2Y/PmPWTSpDUyd+4ll2mlplaV/v2Hihw6JMfnzpVPn31WOzCtnednZcn587nl3sqVtdpzr7/+nmRmiixcuM5puocPn5HsbJE/9+b2HTj2mWekaf36Iunpkp0tOYlevWqWV155IycAn5FxRWbMcH1Nysw8r11/8wzEUbp0rNx66z1y5ozIsWPZ8tBDz+Qs69HDs+Cv+ffftZPeyZNa5CXPIAJy6lROAO299z7xav8CIK1uuEGuHD6cE0A7dixbhg59Ur76ao+88socKVPGfV9CDz10Ue6+e4OEhrruv3Ps2J2ycKHIyJHag6fbbpssYWH5BxROb90qOaOmLF2ac222DaDZDiJw9Kh2/I4ZMy3fdG0DRbGxsbJxzRo5tnOn/LZrV878IwcPiqVQLOfOiZw6dVE++GC5fPNNhl0Abcu6dbJl8WKRQ4fk6rffap2mHz+eE0Dbs+eI3XtbA2ibNomkp59zOlDDD99/r5UpMzJkRM+e8mTv3vLTW29p38WRI9pBeuaMduBmZuaU/Xa5CDjZTg0aOD5wnzJFG9xpwoQvZPnyf2TDhqPy++9m2bHDLLfc4nrwLKWUXLmiZcP8s/bwKCwkRDuB7N0rB9evl8tHjmjH1rlzdoMIXLkiIsePS1aW9n04S1/MZjmxZo1s+d//pJUlsHNi3z65dEn7/g4fFtm48ZgkJaVInz4Pya+/npGBA13X6unXb5hkZorIyZO577Fzp1YOOXBA+x61J7yyc8MG2bBhm5iPHRM5elQWL8o/sFypUnV54jGtX64Bd94pP3/0kRz69lvtYnrypBw+LLJs2SlZvHitAJDRo8fJO+98Idu2idsahBs3npR/jx4VANr5au9eLb/Z2fKzTV/CFy5cFLmilVFtt09IcF9h48jBg7J15Ur5NzNTdu48LEuWHJapU/+Q8uUL9gDWUrCVH/7v/2T4gAFaz/4ZGSIXLsiIJ56Q2bPnyOyZM0UuXRKzWds1MjO1wF+rVrn90c2de0Y2bJCcQai2b/9DNm3KHfDp/fe1wPG33x6WadM2SJMmneT77w/L/v3aT1uQvNtOjRoVvD/wbd9/r5VlPvtMjm/YIJUTE6VX164yd6pWS/bHJUsKnb/wcPvWRmtr12YAzWZq3Lix5Nx0upnggwCaNj5z8bcZQDWlVCUAfwHoC6Bf/psohzl163bEzp0/OF176NDzOH36AmbOTHK6PD7+Bvz992bLK8mZX7p0KuLikpCQkITGjQGTyQSz2YzExHK4q2sH9O7WDSl16qBlq7YIMAnOWkYHjosri6Ag7f97730Ua9cuxpo1y+ze8+mnP0BQUBRGj74F2dnZqFK5MrrdfLPdOmPGjIN1xOLQ0FBcOnECFwPjcfQoMGjQM7j77mcwc6bjsNDt2r2Ir7++CwAQFBSNtLR+qFatD955R8tUamrPnHWrVGmFsWNX49NPn0K5crWQmtoU167FYO7c++zSrFChOtq0uRuvvz4UiSEm4MwZBGjDy6JcUhJSUyth0qT30b37bRg5chgCAqLw2WefwGQC4uNr4vnn52L8+Dsc8jpq5Eg0veEGYMsWREVEICo5GcjKQmR4OBrUqOH091q5cgd+/30rUlJSsHTpdoSGAmlpDTBo0G1268XFxef8/1iXLpi8ZAkqlS3rNE1n5szZiCpVbsDKlfbDNDdq0AA4eNDldrd36waEhgKBgZDgEODU3w7rTJo0C/fff5PLNGbOXIOuXVtB4SyeHjQITz/7LK5FRiMzEzh1CsjKAlJTq2H/fkF2NnDXXQ+gTp1wXLlyGQAwatRneOUV+98wMDAQCAxEarlySE1MBNwMrbx2zRpcPp07nHxAQAAuXHAcAttq0KBBwOnMnNfvv/oqRr/0EipWrIQaNSrh2WfHoly52mjduiMuXQK6dLkdTZvejltu6Y2srDJ48ME6OHv2H7s0u3foAGzbZjfvzs6d8fPevRgzcTKCgoLQsmVrHDlin5fu3fugSZM++OWXP/DQQ1Vd5jkxMQ2VKzfFyJHTEBCwCz/+uCjnO7R+Z8HBwOzZ87B27UrUrFnTbvuAgACbdYPtlimlUKNKlZzXM6ZOxeCHxiEoqJTdelWr1sbVq8Bvv13CP/+Y0LZtOK5dcxz2GwDuuWcIatWKRsdGDTH0vvuAv/8GRBAXG4uHHhqGfv3+67DN229Pwf79wIABfXHixDFcupSbdvXqjbBgwWoEBwcCOIVSkZFAYO6lQymFIUMesfwP/PnnJRw9qn3OTp16IjkZsBlV3amrV6/k/B8REQFcvYoqlSujbIXaAIDk5FRs2CBo1kzlvKc7a9ceRpVYy755/HjO/MDAQNzYsiUAIDo6GuPHv4qMDG1ZcHAwatVqgKVLM3DosmlfAAAgAElEQVT4MLBkSf4jYbdtuxSZmStx6NA8BASE4tq1SwCAhIQGMFnPfeVSUbo08MUXu3DtGnDmDDB//lJkZADz5k3JSevjj+egXGkzsHev9kW6YTKZsGfPIUREBABXLtota9myAz744DWHbQYO3IMaNbT9MysL6NBhIA4eBC5eBO69dy3mzr0F6emLc9YfN+4g4uIS8NFH47B164tO87Fw5kx0b9oU2LLFOpy4x8LCwmAyBThdZjIFoUOH0ahR4yns3z8ev//+C06f3o9//knPWefhhz/Drbd2tNvu3nsfRq9eDyM9HQgOBpTS8hQSUgo33vg5GjYULF8+Aa1bD8Svv36FCxfO2G3/8st/oXJlIDERCArSPpLZrC0bPvxdzJnzNg4f/iPfz1Wnzp2Iialg+RwmJCW1xbFjq5Ca2hMmUyDKl2+Ff/7Zb8nvR5g58yFcu3YV/fpNwZ9/ZmD9+jcBAErZfzcJZcsCmZnYs3Ejdv35Z755AIDw8Ai361SoUAsVK9YDAPTs2R+ZmWdRvfrjqFYtFGFh1bBgwUQAQNmyFVG3bitcuAD07PkCFix4AY8++hreeefpnLTWrPld+0cOI6F0adzXuXO+771u3X5s3/4LmjZtBBGgSZPmTteLjo4GAKSmpuLAvn3YvXUrut56K174r+O5TCmFxx8fjh49+mDXrr0ICgrCfffdh+7deyEuLtJu3eDgYERGRgJn/gUANKpZE62bN8fL732MK1e06yigncOHD5+IESPG4tix37F2bSYWLnw738+2evUmj85TVnfd1R8HDx7EqlXLsGnTerfrR0fHYM28eUBQUE6JNCAgABMnvomMDCA1tSZq1GiGPn1q4OrVf12mExgYiqSk/+D223e6LP+GhGj7UcuWvfHmm38gIKAyTKaymDfvLsTGVsKlS/8gK0u77n/+ySfo3bYtQs1m7cTipdtuG4j4+DA8+ug9dvPr178R7777PSIjgfvua4Bdu7bjiWHDtLLhuXNIjI3Fr7/+juysk0hOTrbbNjw8HM2adUK2zSVz7NiX0LhRI+1HNpsRGOB4HipXLhnPPfcmJkwY7rAsMjIKYWGOx1dMTEzO/6/ffz8QGenRebF2rVq4dEkwf/5mDB3aGZmZmQ7rvP/+Yjz4YBskJSVh8ksT8d2yZbj33v+iQ4e7cfFiCMxmoEwZ7XylFPDAA5OxdOn7TssKlsoIALRjZu2UKShXpkzOvArJyUBwMNxcup2ylmnKxsWhbEQEvnv7bWzMyEDZ+HhctlkvPj4R69cfxrlzQHg4MGrU6/joozecplm6dG7elk6bhrJJzvdVAKhTqxb+DYyCOncCEEGXLl3w4ODB+HCq8+v5m2/+Dz1uqY87mjRB844d4VBYBBAdHYfq1VsiM1NgMgHnzwP//AO89dZ3mDz5aWRk7HTYZvbs9YiLi0do6Gn8s2MHwoLty3/NmzXDxImv4q67BiA8PBzIvgoAOHDgIFJTK+KWW27Ho49Ow803xzmkPXXq13hpwuMYO24mkpOTkRwVBYSGIjm5NK5eBa5eBd5/fw+uXDmJzz8fgxMnDqNFi5vwySevIzPzqMvvzlaHG25Ah/btgSu55bPXX34Z1wJDEIBrsD2gAgMDsXOnQASoV89aTtP2+/r1W2Djxh+QmJiE8+fDcrZp0KA1tmwRmM1AXFwKJk1aDsupHgCwYsURfPvtckyePCDffHbqNAsrVmj3szfeOA8rVtwBETPi4+vkrPPEE18jNvYqzp4NwN69K/Dddx/km2ZkeDhwTjunJZQpgz+mTwfq1QNMJsjJk9h31PE7bNq0uUfn7pz3iIxGVlbuPVbLUqXyWfv6dM3s+TW0qPlFAE1EspVSwwAsgzYi53QR2Z3fNs7KLb16jUHLlv9FcLAZ69evxubN09CuXV/Urt0awcGRCA+PdNwIQMWKg3DTTVPwySdxCAgoDcCcsywxsbbdumZLSbts2QQEBQUhpVw5jz6j9URjKzY2AWlprbBv3xVMn/4W7u97s5Mt7YWEhCArzw5ne4OSlNQMd965AEeOrM6Z17v3SUsectcLCMg9yQFAzZqtMXz4BoSGahfnhg3vdQigKWVCv37PIy4OwAXtxrVtixZ4fcIEDBw4EAAwcOBDAIC5c7+yvaeFUgpt2vTGmDFv4sUX7Qsr/fr1Ay5dcvvZbdWqVRfNmtWFbbDTWWGnTJncYNlb996LCfffj6BAzw+LevWaIisLOTfLemrV6kbs3n0JtWuHOizr0KEXmjRp5VV6JpMJK1dewrx5szFnzmhERZUudB7DwsIQJgLb4nnjxi0c1ps9eyUSE9siPh52AbSHBgzAQ089hb9PKSgFjBnzgt1+YVW9eh0cOgRkWwoYVjfeeKPTfEWGh2P65Mk4HxrvdLmtpKQqLpe9/noGoqMrIDAwAEFBQK1ajbBjxyVcvvwXzpyx/83Dw8PRtWtXhzRs943g4JB88xIZGYmaNeshPd358pCQEAQGAomJVfHXX3tdrOO4vwDaMTZp0ru4cgVOv2NAO2+VLZuAX3751S7/4eERcHJ/4TKPXtw3ArAPoOVn9OhXsHLlavcr6uzuuyfjiy8ec5gfFpaI1NQ7ERvbBWvWtEFm5g4A2k2pt4KCggC72wv3Alz8KG3a3ITExIo4fjw3iH/zzSNRpkxNp+tbVazYLieAFhVVHtHR5WAyAU2ajEf16lVx9epZ7N27ELt3r8h9rxYt7ArS3nIVZAgM1I4VkykQ3buPx/HjQFiY4PDhnZg16yacPn0CKSm1EB+f/zU277VVKYW3376I8PAQDB/+BjZt2o6XXmrrUV7vuGMYeva8C0OH3oUdO5a7XK9Zs0fsXt9ww3gsXNgW0dHVAAAdOryEK1dM6NdvDOLiyiM1tS/+/DMdbdrUx+XLs3O2cxVcrFalCqrVr49/3Rw2oaHhHn0uq7CwcAwYMAqbNmmvw8NLoVev4Zg3702Eh0flrNe160ikpkahW7f+dgG0gqhfvzGUAmzu5/NVsWJFVIxzvKHMKyWlPMqUKY/LlkPK2bEyZIh93n+ZNQuIjYWrcFNwcDDS0mrjl1+2uVhDs3//NaSkmICj+QdabSml8NRTY/Hss2Nx6RJQqVIU/v3X9QOsFSs2uE0zIaE8Jk/OwvHjq/D1129h166FTt5XOz7CwxPRsuUK/PxzJ4d1goNz96OyZSvjH5tnWBUqNMX+/UtyXt9z9925T/AKKDAwyGFeVlZuoHvlym0QuYa4cPvzZZUqVREVXN6j96hbt4FH6w0c+KTTABoAhIbmH0AriDp1bsA/R48iPqUyTp2yv0mPiorG5s3bERgIBGSdR1paGs6btWuuq1jlhAkrsWDBq9i48dt837dlvXqFyjcAdOt2Jz74YDrKXLYvYERHRuKmVt6VV/OKjc0ty93curX2APr8eY+3nzx5Mu6//XZsP3ACQ4b0t1uWklIJAQEBaF6/vtf5at68M1JS6qNXL8frUERE7jkzNiZGu3myuZdRSmH48Kdx1b5YiwoVKmD9+otITQ3Brl3OP+PNN/fEoD4dsP1ANJBPmLN06bIYNepDmM3aV7Zt22788MNH3n3IArKWfSdNmof09N8QFhbmzU+GhIRkpKSkuV2vSpU7cf78Xvz553qkpt6GUqUq4+zZdISHa/d30dHlcMMNtyE1FTh6FLjppl7Ys+dnp0FPq5SkpJwAmjOloqIc5n311SL07t0Zm6wXUDdcldVJI5L78LI40v+u3yAislhEqotIFRGZ6H4Lx0J5QEAQWrTohzZt7sFtt03FtGkXMHr0THTv/nC+KdWv/z4CAoLQo8c/aNLkD1iDMk2afIjU1GZOt0lISHSfRdvcOrmJKFs2OWfZoEHDUbWK6xv9/NjewAcEhCAyMiFPsCzYIQ+BgfYBNM84loBNJhNGPPqox4WKQYOexNChkwrw3u6ZzY4XGdsaaCaTCZFhnn3u77/fiE8/XZfz2vYmbdasnwqRS3tBQY4FyYCAQEyc+KWTtT3TunVf/Pzznw61ofRSp04jfPWVfZAjLMy7GzlXbJ+kPvbYeCxatDiftQsvLKyU05vYpKRkxMe7fgJqy/bGLSXFdU03b4wZ8wN69RrjdFlwcOF/V9s8u7qJ94WHHx6JN99cVOTve+ONj7pcppRCUFA0zObcUrDnAbTcc66eQXilFG65ZaDdvIiIMi7WziWSW1rJW/upSZP70LbtIwgIsH/AEBZqTCEwPDzBYZ5SComJ9RAXp10bs7M9Cbxq37FtjYvg4HCYTAGIjIxGWlobvPLKdo/zFRMTh+ef/97psv/+9wz69duNihVb2s0vV64NunX7Dk2bTgAAREYmoEOHaYiNrQClFIKDIxAfr928BQTknvPz/gbecnb9yMv2/Zwv137v0NDcB4zBwaG4554n3T4QKE6cBdD69x9WoLQqV26AgQNdF0P1OJZt99dKlepiw4YMbNggePnlV/HSS6+iWjXnte+dqVWrLerWvc3tenFxzoMcQUGuy0XiaeTTC84CaBcunLZ7HRAQ4FUNv7y8+Y0aNPgPmjRp7TDf2UPZaNsqNIVwLU+17YYNHR9MeqJmzZYYMWKGDjlyb+DAEQgPD0dISMHPC5069Xc6PybG/fUrPyEhIWjWpAnq129oN7979/sQG1u4tF2VpV1VyvBEWFg4AgICnO6nd9wxrMD7fp8+L6B9+1sxbtx8BAcbG8Cx3hdFRUWjXj3n98ruxMQ4lgOsOnb8EO3afQulFJo3fwEtWiyz+17Klq2PQYMWY8wYxyfSn366A926Pec03a2rVrndh5OSkvDUU88AAB5//HksmjcPpUuXxob167Hw8889+WioWrWuR+tdz8xmzyZf8JsAmrecnVzyFhRDQiI8OgmZTIGWv0FQKjCnwBAZ6RjQql27pWWZdydOZyfJMmU8q73mPu3cgmOLFi84zHMmbw00Z4YOXWH3Wq+CVM2aTXVJJ6+oKMeCTZky7msoOdOoUVPUr5/b3MT6+9Wq1QjNm7crUJrOONsvGjRo77LmiTds0wgJKUjA1LO0Ac+aEnnCGgRt2vRmPPzwc1qTUx3Mn3/C6fzQ0MJXqbYNro4d+0Wh0wOA2Nhy6N7d8an4nXcOKdRNhZV9AE3fy8SHH9o/Ce/b90GMHv2Wru+hl+eeW4Lu3Ud6tG5oaG5tVk8DaHr8Vq5Yj5XWrXujWbO+aNPmQbfb2AbQPAmcvvLKjEIHbDt1cqy1CQBpab1dbnPPPeMBaDUx3fFk/01JqeN2HU+EhEQjNraW02WpqbfkPKzKj+06epx/rKpVc6xlV7VqF3TpMiTf7Tp2vA+BgcFo1+5Oh2V5g6nFWd5r0rx5KxEf7/rmzJ177nmmsFlyI7c8NXjwm6hQoRIA4KmnnsaIEd7X+vOsrOsYuCpduibCwhz3Q2t52vZc98Ybs7zOlzPOyjdJSfo8fLLy5rr29dcbMHOmY81nIwNotg98n3xyDT7/fFWB0woKKpqaLnqUFUaMmIFRoz52mG9bA60w8u5bTz9d+Af2QUHOgy2FCaBZOWudlJJSsMoUABAXl4x33lmAli17on79DoXJmlt67A+JiZXw2mv7nC5LSGiClJRuDvOrV9eac4aFxaFmzS4IDnZ+f9OjxzhMmnQBvXrlNsdft+4sGnpYE3HcuIn4NzMTw4ePQ1dL90relOkmTPgs5//i21DRd6w10BhAK2LODlxnT7XyGjlyH+65J/dCWaPG/1yu6+zp8MSJSzB//h9e3xg5y69eT3etacfG1kaFCu0AuH+yHRDg/r2Tkuybr+oVQLO9catd+z+6pAkAjRs3x8SJn9jNK0wB2pYRTTiNZvs9T5rkvjmIN/IWUpwVNAvCWgPt/vuf1zX4EBPjWDjr0GGIR+cMd2y/i1KlCt9sNjddx7zpVSXcdt9wVoArjPbtuyElpToAYMCAkRg//gMkJqbo+h4VKlTXJZ1GjTrjrrtesZvXrt1cp+t26PAlYmIqAyhYE069WW/AKlWqi6FDZyE01LHJQV72/eI4v0ZY13nqqS9w++3Oawt4Y9y41zF3rn0BefDgpWjb1nUNn6ZNb8EbbwhKlXJ/U2Xdf/M7X1jP3y1bPu9Jlg1lG0Br1sx1zUdv9e5tf6PYqdNj6NdvsdtaCBUr1sInn1xGUlJlh2X+FEDLe41u3tyzZrveqlfPsQlkQehds8uT87izdSpVcl5zrUaNW9Gu3dPo0eOtnLyWK1excJm0yPtbvfHGD3jyyZm6pO3qPQrCtglnWloTJCdX0u2hnm0ALTAwuFDpugrw6E2/crDjuTo6OlaXlPOes/RINyjI+YORiIjCB9DyPsj66KNluPNOfa4LzvaLxETPWlZ4wtU5Z9euo1izJt9emOwkJTkvzwUHO3/A1LTpC3jiiTMIC8u/vG0ymRASEoEyZbTgfHJyTURGevfQKrQQNfBtm/g2cdIklBhA84mwsCh06GBfc8BdUwUAiI+vjsTExjmvExLudrmus5NDeHgUkpMdC5ru2KYVEhKKvn0dO4AuKOsJ2FqTTnu//ANongQn8n5+/QJouelOmfKjLmla5a0GX7Gi97+VM9Y8G1mjxEqv97D9/SpXLnz/F67SBvRswqkVKl0VWArK2XeqVxNXPWoLOuMsf3oF3W0L60Y04Xz44XdRrVpDPPyw847pC+v99/U9b9hKTe2NPn32IS3NfpCQ8PAE1K2rdXxdPGqgmS3v4fllvmbN3FpfrgNoWrp6Nf8IDAxE+fL2tUvS0m7Wcb/z7Dt+5x1B69bjdHrPgrMG0BISquf0A6eHvL/ntWue9TuYH6PObf7s+edd943nDV8E0JwpX95537sBAYHo2vVVRETk9ken1zGbNxDTqFEHREbq9/DJ2XsUhO2DwSFDXsKSJRmFTtPKbHdXWLjrRN7jtFSpONxyi/sayd7S62Gbs9/GWQuSgjDinJX3QeuUKWtw110P6lJOzftdtGp1k26ByrwBtLFjP8GePa4HP/OWq/0hMTEJNWo4r6ntDVcBNKVMCA31fH/Jzac+5bEWN9zg9TZLdOiDsCRiAM1HWrWy78jXkwAa4MlFQCzr6Xcitj2pt217K2655Snd0s59Aq9vv0aO35O+NdBMJpPXnSC7Z3+CTE0teFVou1R1rqVTFIy8+TGqCaeVUf23WVWv3gJdujjvONhbRtVOdHYM6xXUMLIJJwA0aXITpk/f6lEfTQVhdI3QmJjqCA6u4DD/2jWtU2tvA2ivv+66pnNBWWswePNdxMVVx9ChFxESEoO2bV91uo71xl7P2kdG/l5GBSk///wk2rd3HDW6sKwBNGd9dhZG3vOFHgEa2+/2iy8OFDo9ymX7+1Su7H3n5nnlPQ5q134OlSo5jmJqq0ePRShXro3H76HXcVwU/W7qkdcWLbrk/K9HbXVbeh//1as3yfl/zpxTeOyx/EchLAi9zrV5f//y5avk9AldWHrVELSV93PXq9cKL774gS7fh+1+mpioT816q7wBNJMpQNcymdHlMFcBNG/pXQEiLjYWh7ds8WjddT/9hM3LlyPOoLKwPxPRxqfyZPIF/6l/XwB5C/ieXuDcB8b0D6D16/cwli2bp1t6tpzVQLP931bZsjegXLn2HqVrVA00a7pGFKJsT+jlylVAYmI5j0f/8iTdoqiBphcjC6l5L5yhofr2saZ3DbS8xo//GVevAtd0KMMa9T0729dat+6sS9q2ee7aNf8hxIsjIwLanTt/AaXyD7g3ajQE6enfoH59z5o2Wn/DqKjCjdzmjLUGg7f7X1BQOB566DRc32dIgdItaaKj45GQkNtkLSzM/ciQntA7gPbhh98hM7MU/v039/dq3XowevYcj8zMfDb0ku13QYVnren52We7Ubp0WTdru5f3nFiv3otOr29BQeG4ejXLso13x7he54SiKEfpcXNfq9YNSEtriL17fzU0gKbH9/H++5vRqZOx36teARP7Ac0CsWhRej7XI+8Y9eC4bdvuWLUq/5FOC8L2uHXVF1hB5Q2g6V/r1Zj9rUmTybh4cZ9HXQ15wpNuHryVdz9LTq6Lv/5yHPWz+X/+U6gRi0syjsLpQ3mDRJ7WWvG0EKBnAK158w4YO3amJV19TzrWi5rtycZZZ7EA0KvXJjRv7rzmgWO69p+/detbC5hDe9YTjxH9q9he4NeuPajbxdTf+0AzOm2992mjA2h6Kqp9Y9UqM+rXL9hIR3nZHhedO9+nS5pFyYhCclpaP8TH598nY0xMKp555jdERXk2AIz1uDBiH7HegOkdTCxoYK4kst40R0UlYcCAjbqkqXcArX37W1C7dmu73+veez/0qP84XxsxYgIWLNjm62z4RG5NT72CUp6dB3r0yO0n1tMyrt55LYprpl7vYT1Oi3sNtKKgXw3E3HTMOt9B29awevZZfQa9AIDJkxfqlpYtI4+FvPfEtoMIFWdly7ZBy5ZTdLyv0NLRs6yU93czYrTi6wGbcPpI3iabnhf43R2U+tdAM5L1pBAUlFvd1VUNtIKkCwAzZx7DsGH69NtmZA00o5paGvEEw/V76VtNPjhY72ay9nls166v7ukb0YRz4ED9+h20ZWRT2U2bbDt9N+7pmb/xtybVRuTXWhjW/zyqfxNOf2W9ab7hhkGIjdWnO4CiasLpD3r16o+0tMI3X8wrNLTwnXsbzXrDpV+tLu/PMd4PhqVPXo28/lg/k17nXOvARp52EeMp28BRXFwlXdM2in410HLTKV1a30B/VFTufVD79vqXTfVm5D1F3hpoegcrjaL3d2JIDTSHY8E+gBYTo0+N9ZKMo3D6UN4gkacRYHcHkTUdfwmgXbnyLwAgJCS3U0W9A2ixsYm69S1gLYQZXQPNH9I1kjXP0dGJuqdtvXlPTa2DZ57R7ymflRE10Pr00a/fQVv+uG/4ewDNX/JvZA0064Aben8Xet/Y+zPrNUrPYJc1gCaidwDN//pYMeo4/vjjE4akqy99A9We3hzar+fdNkYEUIyiV16t51mjaqBNmLAPkZH+cbNtxCACM2b8rEuaVmFh+nYn4s/yBtCM6EpCL3ff/ZXNK2NaaemZbt5rV974w+zZ+u7XJRUDaD6S94lQRIS+Jwe9L/K5gTl9Tw4XL54FYN/hot4BND1ZT2ZG94FmRLpGPi165ZUluqaXlXUeAFCqVIKu6QIFGwHQG0U1LLse/DOA5t+1i/ylBpo/NuHMDaD5x3dsJOs1Ss9gl1E10GJi9OmEuygZFaQNCdG/1rXe9A9Ue1o28b4M449NOPUqqxnVhDP3O/WfwLfeAdRWrW5D+fL61OwlR9Zy9K23PoUxYz5F+/a3+ThHrtWt2wsJCdrInXqXaYyogeZ4LIib5ZQXBxHwIdsg0ezZApMJuHRJv/T9pQbaxYvnAADBwfrWQDOqcFsUNdCMqgJslISE8rq3oS9VSnuq2ajR7bqmC9j2k2RUAM24PtD0ODZsGd2sd+rUfahYUd+Aor/U4HLF3won/tiEU++nwP4otwaafiU445pwmjBq1C+4dMl/+lby9/NQYRjZB1pKygMu14uJSXW6jSf0Otf4Ux9ouTV9jbmd8qcAmn7di2i/jb80KfRXycnaqJ6JidXQpct9KO5joOXeAxl1/8ZuUIqb4nwK8K+7DC9ZT+bt2vXTOWVjmnAaVQPN2oRT7wCaP9ZAy+0s0pgqwEYES3799Qxmzdqb81qv90hNrYUPP8zATTcN1yU9W0bXQDOiDzQAeP31C3jhhTOGpG2UlJTqKFdO3xHw/P3i7z/NC41vwql32kZdp557zpg+CI1kPU6MaMJpRCfiFSo0QoUKN+ierp7Gjp2c87/ex3GNGnV0Ta9//+fsXterp89ASrb0CsxYzwM1a3ZD3bofuVyvXLkmCAmxttbw7hjX67qRnFxBl3Sc0/ecaz1Ojbpm+lMATe8aaOx43Vht2tyJUaN+RKdOA32dFY/Exmp9AQYG6luD2JAaaHnSyrsvF0V/2f6uuPeBVqJroAHAjBlnEBcXgYsX9U/bX2qg9er1BPbuPYZ69R7JmVecA2jWAo6RNdD0vqk08olpVFQ0/v3XmLQTEirh1Cn90829yTbmezGqsBoSEoFr/lNBwzD+E4Byzl9qoOV2aK1/YcqoGmjWdPU+th9++ClERbXEyZNXdU3XSEbUQLNem/XuA81fDBjwKCZPfhFnzpzSPYj41Vc/Y/Hik7qlN3Dgi1i2bBaOH/8DCxb8jqNHq+qWtpVex2/Vqu1RpUpTdO36MvbsyX/duLg6OHp0rdfnJb3OCeXKlcfevaeQllYG5ctX1yXNvPSugWbUNdOfAmh6/f4JCVoAtXr1xrqkl1d8fDz+/vtv3dPt2fNxmExldU/XKEop1KrVvtjXPLO6++4vsGTJj4iM1HdQDb0HFgHc94HGAJpninMNtBIfQAsPj4b+99r+NYhAVFRp3H77NBw9mjtPnwCaMScAa6HZyD7QjGvCyZMikPsEuWPHe32cEyoIf6+B5m99oBmhS5cB+O67j9CwYSdd0zWqBhoA1KzZAqVLAxcu6J60IYxpwqk1x05L0/d38ycffPAjvvhiBmJiYnH5sn7pRkWVQkJCKfcresHoGyG9ykGhoVF48cWNOHoUbgNo3jfT1re5KQDExsbhk09+QWysvrWrrfSugWZUAE3vvtWMpNd3Wr16QyxZsh0mU21d0svr998PYeNG/Wu3DR48ye4+i/QVFhaDlBT9u5wxomVS3nNhbGwFnDixz+E9KX8MoJU4xgTQGjZsBwDo02eoruk6o2cALShI3+q01mHBjSiQGFFVt6j4U3X2+PgEvPTSZTRs6D+FP8rl7wE0f8m/9TxkxLFdt24LvPGGICkJOKHroIPGBdCMZMR3bL1G6VlTKjAwGI89th9VqqTg7FndkjXM119vw9q1+9yv6IWqVetiwIA3/aJmRO5xYMz12RcDuhQ0SK5/k9tGuHLFmJso/Yv7troAABZfSURBVPtAM6pPYP+5TdOz5nfNmvWQnq5bcnZCQ0MREuK7zsepuNG/TGN7LPTuPRstWnTCk0+W0S3964G1CWdx5T9n5mJI7wBafHwyvv5akJoK7N6ta9IO9Loo9+49FampbXRJyyq3Twn/acJpVTQ3lX5wVwHtRlDvr6NUqVicO5epb6LkwF+aQLriL8Edf8mnLaP7N/QnRtRAA4C4uGoINm6cFF2lpdWH2Vzf19nwGSOD4IAWmPHdTYRv+kArCnpd4z74YBk+/HAqSpc2puleQECQ33Qr4Y/XMyJrtxR63ltZzy89eryJOnXuRGSk/XIeK+5ZR+EsrhhAKwR/voHQK4DWrNkg3Qt35cvXQMeOA9Cnz5P6JgzbQpPeJy//qR3mzz77bDd+++2Yr7NBpCt/ql3qrzXQjMivtcbN9dpfGeUy6hg2mXwRQCvYZ/GnBy965bVmzYYYMOD/DKstaTIF+FEAzX9+fyIr67lb9wGXLl3CpPdDcO6c4zJ/Kz/5SnGugcazXQHkVm/3n6dteRXnjkkDAgLwyCPTUamSviNmAcZ22m1kuqSJi0tEpUoNfZ0NIl344/nCyD7Q/I1RNdDIf4wYMQuNG/dCSkoVQ9L3TRNO72qZ5t6A+k+Z2F+CPf50nvWnACqRVe7Dj6I71vzpuPYljsJZQvnLBdgZf+pXwQh6n7yKpgaJP9VSISJP+WMNNH9pSm6kwEDtOmrtt5OuP1WqNMLQoV8h0KAilS+CEgW9obwem3BSLn6nxqlY0ZgRSQmwlmm4/xYv7AOtRPL/G4jrNYBmVFVdKyOfKpQvnwYAaN3aiFFoiKioGd0BuRFYAy0Xm3CSUTp2vAs//DDLJ+/dtOkz+PbbnoiNTfNyS/85JxT3m+WPP96OzZs36ZrmG2/8gQsXQnRN01Zx/0791bx5mTh1KszX2SixjOgDzR2WnzxTnANoPNsVCANo/ioiIgodOjyEOXN+0DXdoqhBkpxcBdOmXUTXrg8Y/l5E/qhs2QRfZ8ErRndAboTmzfsBAOLjy/s4J77HJpxklNGjP8OCBWd88t5VqtyK554ThITE+OT9i0JxD/ZUqVIPnToN1DXNsmUrIyYmWdc0bflzq5ziLCqqNIKCQn2djRLLFw8FGUBzz1oDjU04SyB/PgD8uf+2wlBK4f7730eDBsClS8akb6SQkHDDOqsl8nc//vgrVq3K8HU2vOB/AbQuXZ5EvXpDERPDAn2dOi0AAM2aDfNxTqikCQwMRGRktK+z4ZFhwz7B//73HMLCwgH4R21Mfy6/F1f8TskfsVZ98VWcR+E07HGBUuoFpdRfSqltlqmrzbLRSql0pdQ+pdTNNvM7W+alK6VG2cyvpJTaaJn/pVLKpwO8N2jwE0qXfgxBQf77dI4nCn350w0wUUmVmJiEunVb+jobHvPHGmhKKT4Nt4iLS8TTTwuqVu3o66wQ+UzLln3w6qv7i32tLlssA+vPn35/olwcRKA40rsGmqsYU0EZXQNtkoi8YTtDKVULQF8AtQGUA7BCKVXdsngKgBsBHAGwWSm1UET2AHjVktZspdQHAB4A8H8G592lqKgGSEh4mzWByAFPilRSvPbaG8jKauDrbJRoPF8QEVFJwAAa+SPf1EBj2c8TejXPVFqzO1cxpgLxRRPOWwHMFpHLAP5USqUDaGpZli4iGQCglJoN4Fal1G8AOgDoZ1nnUwAvwIcBNKK8/KkGCRW9zz//EVlZ/tU/15NPDsfChb7OxfWB5w8iIvJnDKCRP4qOLgcAqF696Fov8OGpezqPwtkUTmJMAIptAG2YUuo+AFsADBeR0wCSAWywWeeIZR4AHM4z/z8A4gCcEZFsJ+vbUUoNBjAYAOLjK+j1GYiICqV58/ZIT/d1Lqi48ccmnERERHlxEAHyR0lJtfDZZ3tgMlV3vzIVKS8CaGWUUltsXk8Vkak2r5PhPMZUYIU62ymlViildjmZboVWQ6wKgAYAjgF4szDv5QkRmSoiTUSkSXR0vNFvR5QjNlbb32rVauTjnBCRv+jRoy8AoHLlNB/nhIiIqOBYq4b8VWpqTZhMRTe4Ho8V90S0QQQ8mQCcssZ/LNNUN8kXWqFqoIlIJ0/WU0pNA/Cd5eVfAMrbLE6xzIOL+f8AiFFKBVpqodmuT1QsVK1aC+PHb8BttzGARkSeufPO/6JixXuRnBzk66wQEV03WOtXf2zCSeQZBtA8o2MTzvxiTwVi5CicSTYvbwOwy/L/QgB9lVIhSqlKAKoB2ARgM4BqlhE3g6ENNLBQtKvcTwB6W7bvD+Abo/J9PalW7U3Ur7/C19koMapW/Q+CgngjTESeCwzkOYOIiPwbA2hEnmEAzT2dR+F0GmMqTP6M7APtNaVUA2jjwx4A8CAAiMhupdQcaB23ZQMYKiLXAEApNQzAMgABAKaLyG5LWiMBzFZKTQDwK4CPDcz3daNixSetVR+JiIiIiEqsadMWYvLkyUhJKQ/gqq+zU6IwKEBEetKrBpqIZOcTYyoQwwJoInJvPssmApjoZP5iAIudzM9A7kidRWLx4r14+eWiaw9NRERERETGqFWrAYYP/wSsLEVEvsJgs2d0bMLpMsZUULyEuFC5cg1ERFT1dTaIiIiIiIiKnW7d7vB1FqgY6dr1ATRo0N3X2SjWGEBzT+cmnLozsgknERERERERlUDvvPMF7rjjA19ng4qJESM+wqFDvs5FcccAmjvWUTiLKwbQiIiIqERKSqoPAChXrpWPc0JEVPIEBQUhKirW19kgohLGV7XLPMEAGhEREZVIlSq1wr33HkWZMkn4+29f54aIiIiuZ2zC6RkG0IiIiIh8ICIiyddZICIiImIAzQPWPtCKKwbQiIiIiIiIiIgMxACaZxhAIyIiIiIiIiIicoGDCBARERERERERXcdYA8294t6E0+TrDBARERERERERlTRPP30o538G0DxjNns2+QJroBERERERERER6SwmpnzO/wygeaY410BjAI2IiIiIiIiIiHyquDfhZACNiIiIiIiIiMhQrIHmCQbQiIiIiIiIiIiuU2zC6R5H4SQiIiIiIiIiuo4xgOYZ1kAjIiIiIiIiIiJygX2gERERERERERFdx5RSEPF1Loo/BtCIiIiIiIiIiK5TDKC5xxpoRERERERERETXMfaB5hkG0IiIiIiIiIiIiFzgKJxERERERERERNcx1kDzDGugERERERERERFdtxhAc6e494FmKszGSqk7lFK7lVJmpVSTPMtGK6XSlVL7lFI328zvbJmXrpQaZTO/klJqo2X+l0qpYMv8EMvrdMvy1MLkmYiIiIiIiIiIih+z2bPJFwoVQAOwC8DtAFbbzlRK1QLQF0BtAJ0BvK+UClBKBQCYAqALgFoA7rKsCwCvApgkIlUBnAbwgGX+AwBOW+ZPsqxHREREREREROQX2ITTMyU2gCYiv4nIPieLbgUwW0Qui8ifANIBNLVM6SKSISJXAMwGcKvS9qQOAL6ybP8pgJ42aX1q+f8rAB0V9zwiIiIiIiIi8hMMY7hnHUTAk8kXClsDzZVkAIdtXh+xzHM1Pw7AGRHJzjPfLi3L8rOW9R0opQYrpbYopbacPfu3Th+FiIiIiIiIiKjgGEBzz9oHWnGtgeZ2EAGl1AoAiU4WPSsi3+ifpYITkakApgJAtWpNxMfZISIiIiIiIiIiDxXnQQTcBtBEpFMB0v0LQHmb1ymWeXAx/x8AMUqpQEstM9v1rWkdUUoFAoi2rE9EREREREREVOyxBppniiKAppS6A8ALAGoCaCoiWzzZzqgmnAsB9LWMoFkJQDUAmwBsBlDNMuJmMLSBBhaKiAD4CUBvy/b9AXxjk1Z/y/+9AfxoWZ+IiIiIiIiIqNhjAM29ImzC6XRATHfc1kDLj1LqNgDvAogHsEgptU1EbhaR3UqpOQD2AMgGMFRErlm2GQZgGYAAANNFZLcluZEAZiulJgD4FcDHlvkfA/hcKZUOIBNa0I2IiIiIiIiIyC8wgOaZoqiBJiK/Ad7/JoUKoInIfADzXSybCGCik/mLASx2Mj8D2iideedfAnBHYfJJRERERERERETFl3UUTg+VUUrZNr2caukX3zCFCqARERERERERERHpwYsaaKdEpImrhUYMiMkAGhERERERERER+ZS1DzR90irQgJj5YgCNiIiIiIiIiIh8rij6QCsoo0bhJCIiIiIiIiIi8khRjcKplLpNKXUEQHNoA2Iu82Q71kAjIiIiIiIiIiKfK6JROF0OiJkfBtCIiIiIiIiIiMinvByFs8gxgEZERERERERERD5XnPtAYwCNiIiIiIiIiIh8Ss9ROI3AABoREREREREREfkcA2hERERERERERET5YACNiIiIiIiIiIjIBQ4iQERERERERERElA/2gUZEREREREREROQGA2hEREREREREREQusAYaERERERERERGRGwygERERERERERER5YMBNCIiIiIiIiIiIhc4CicREREREREREVE+2AcaERERERERERGRGwygERERERERERER5YMBNCIiIiIiIiIiIheKexNOU2E2VkrdoZTarZQyK6Wa2MxPVUr9q5TaZpk+sFnWWCm1UymVrpR6RymlLPNjlVLLlVK/W/6WtsxXlvXSlVI7lFKNCpNnIiIiIiIiIiIqfsxmzyZfKFQADcAuALcDWO1k2R8i0sAyDbGZ/38ABgGoZpk6W+aPAvCDiFQD8IPlNQB0sVl3sGV7IiIiIiIiIiIqIayjcHoy+UKhAmgi8puI7PN0faVUEoBSIrJBRATAZwB6WhbfCuBTy/+f5pn/mWg2AIixpENERERERERERCVESa6Blp9KSqlflVKrlFKtLfOSARyxWeeIZR4AJIjIMcv/xwEk2Gxz2MU2dpRSg5VSW5RSW86e/VuXD0FERERERERERMay9oFWXANobgcRUEqtAJDoZNGzIvKNi82OAaggIv8opRoDWKCUqu1ppkRElFLi6fo2200FMBUAqlVr4vX2RERERERERETkG8V5EAG3ATQR6eRtoiJyGcBly/+/KKX+AFAdwF8AUmxWTbHMA4ATSqkkETlmaaJ50jL/LwDlXWxDRERERERERER+rkSPwumKUipeKRVg+b8ytAEAMixNNM8ppZpZRt+8D4C1FttCAP0t//fPM/8+y2iczQCctWnqSUREREREREREJUBxHkTAbQ20/CilbgPwLoB4AIuUUttE5GYAbQCMV0pdBWAGMEREMi2bPQxgBoAwAEssEwC8AmCOUuoBAAcB9LHMXwygK4B0AFkABhQmz0REREREREREVLwU9xpohQqgich8APOdzJ8HYJ6LbbYAqONk/j8AOjqZLwCGFiafRERERERERERUvJXYABoREREREREREVFhFfcaaIb0gUZEREREREREROQNs9mzqTCUUq8rpfYqpXYopeYrpWI82Y4BNCIiIiIiIiIi8rmiCKABWA6gjojUA7AfwGhPNmITTiIiIiIiIiIi8imRohlhU0S+t3m5AUBvT7ZjAI2IiIiIiIiIiHzKyz7Qyiiltti8nioiUwvwtv8F8KUnKzKARkREREREREREPudFAO2UiDRxtVAptQJAopNFz4rIN5Z1ngWQDeALT96QATQiIiIiIiIiIvI5vUbhFJFO+S1XSt0PoBuAjiIinqTJABoREREREREREfmUl004C0wp1RnA0wDaikiWp9sxgEZERERERERERD5XFAE0AO8BCAGwXCkFABtEZIi7jRhAIyIiIiIiIiIyQEREZVy8mOHrbPiFIhyFs2pBtjPpnREiIiIiIiIiIgJuvHE7wsKO+zobfsNs9mzyBdZAIyIiIiIiIiIyQGBgJJSK9HU2/EJR9YFWUAygERERERERERGRzzGARkRERERERERE5AJroBEREREREREREblRFIMIFJQSEV/nwRBKqfMA9vk6H0Q+UgbAKV9ngshHuP/T9Yz7P13veAzQ9Yz7v3+qKCLxvs5EcaCUWgptP/bEKRHpbGR+8irJAbQtItLE1/kg8gXu/3Q94/5P1zPu/3S94zFA1zPu/0TGMvk6A0RERERERERERMUZA2hERERERERERET5KMkBtKm+zgCRD3H/p+sZ93+6nnH/p+sdjwG6nnH/JzJQie0DjYiIiIiIiIiISA8luQYaERERERERERFRoTGARkRERERERERElI8SGUBTSnVWSu1TSqUrpUb5Oj9ERlBKHVBK7VRKbVNKbbHMi1VKLVdK/W75W9oyXyml3rEcEzuUUo18m3si7yilpiulTiqldtnM83p/V0r1t6z/u1Kqvy8+C5G3XOz/Lyil/rJcA7YppbraLBtt2f/3KaVutpnP8hH5HaVUeaXUT0qpPUqp3UqpxyzzeQ2gEi+f/Z/XACIfKHF9oCmlAgDsB3AjgCMANgO4S0T2+DRjRDpTSh0A0ERETtnMew1Apoi8YrkwlhaRkZaL6iMAugL4D4DJIvIfX+SbqCCUUm0AXADwmYjUsczzan9XSsUC2AKgCQAB8AuAxiJy2gcfichjLvb/FwBcEJE38qxbC8AsAE0BlAOwAkB1y2KWj8jvKKWSACSJyFalVBS0c3dPAPeD1wAq4fLZ//uA1wCiIlcSa6A1BZAuIhkicgXAbAC3+jhPREXlVgCfWv7/FNoF1jr/M9FsABBjuSAT+QURWQ0gM89sb/f3mwEsF5FMyw3TcgCdjc89UeG42P9duRXAbBG5LCJ/AkiHVjZi+Yj8kogcE5Gtlv/PA/gNQDJ4DaDrQD77vyu8BhAZqCQG0JIBHLZ5fQT5n2SI/JUA+F4p9YtSarBlXoKIHLP8fxxAguV/HhdUEnm7v/M4oJJmmKWJ2nRr8zVw/6cSTCmVCqAhgI3gNYCuM3n2f4DXAKIiVxIDaETXi1Yi0ghAFwBDLU18cojWPrtktdEmcoH7O12H/g9AFQANABwD8KZvs0NkLKVUJIB5AB4XkXO2y3gNoJLOyf7PawCRD5TEANpfAMrbvE6xzCMqUUTkL8vfkwDmQ6uafcLaNNPy96RldR4XVBJ5u7/zOKASQ0ROiMg1ETEDmAbtGgBw/6cSSCkVBC148IWIfG2ZzWsAXRec7f+8BhD5RkkMoG0GUE0pVUkpFQygL4CFPs4Tka6UUhGWjkShlIoAcBOAXdD2deuoUv0BfGP5fyGA+ywjUzUDcNam2QORv/J2f18G4CalVGlLU4ebLPOI/E6efixvg3YNALT9v69SKkQpVQlANQCbwPIR+SmllALwMYDfROQtm0W8BlCJ52r/5zWAyDcCfZ0BvYlItlJqGLQLYgCA6SKy28fZItJbAoD52jUVgQBmishSpdRmAHOUUg8AOAhthB4AWAxtNKp0AFkABhR9lokKTik1C0A7AGWUUkcAjAXwCrzY30UkUyn1IrRCJACMFxFPO2Yn8hkX+387pVQDaM3WDgB4EABEZLdSag6APQCyAQwVkWuWdFg+In/UEsC9AHYqpbZZ5j0DXgPo+uBq/7+L1wCioqe0LgOIiIiIiIiIiIjImZLYhJOIiIiIiIiIiEg3DKARERERERERERHlgwE0IiIiIiIiIiKifDCARkRERERERERElA8G0IiIiIiIiIiIiPLBABoREREREREREVE+GEAjIiIiIiIiIiLKx/8D1Bvin4q/SQwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = murmur_model\n", + "layer_name = \"conv1d_311\"\n", + "num_data = 5\n", + " \n", + "for example in val_data[:num_data]:\n", + " exp = grad_cam(layer_name, np.expand_dims(example,0), model)\n", + " idx = 0\n", + " for i,j in enumerate(reversed(example)):\n", + " if not j == 0:\n", + " idx = i\n", + " break\n", + " plt.figure(figsize=(24,4))\n", + " plt.imshow(exp,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", + " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", + " plt.plot(example,'k') \n", + " plt.xlim(0,len(example[:-idx]))\n", + " plt.colorbar()\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CWUhn-sfUq3q" + }, + "source": [ + "## XAI Outcome Model" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "c6e6MCE0TRZc", + "outputId": "d409a5af-eb88-4601-a750-5f7fa2578b0d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model_4\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_5 (InputLayer) [(None, 16128, 1)] 0 [] \n", + " \n", + " max_pooling1d_40 (MaxPooling1D (None, 16128, 1) 0 ['input_5[0][0]'] \n", + " ) \n", + " \n", + " conv1d_208 (Conv1D) (None, 16128, 32) 1280 ['input_5[0][0]'] \n", + " \n", + " conv1d_209 (Conv1D) (None, 16128, 32) 640 ['input_5[0][0]'] \n", + " \n", + " conv1d_210 (Conv1D) (None, 16128, 32) 320 ['input_5[0][0]'] \n", + " \n", + " conv1d_211 (Conv1D) (None, 16128, 32) 32 ['max_pooling1d_40[0][0]'] \n", + " \n", + " concatenate_40 (Concatenate) (None, 16128, 128) 0 ['conv1d_208[0][0]', \n", + " 'conv1d_209[0][0]', \n", + " 'conv1d_210[0][0]', \n", + " 'conv1d_211[0][0]'] \n", + " \n", + " batch_normalization_52 (BatchN (None, 16128, 128) 512 ['concatenate_40[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_52 (Activation) (None, 16128, 128) 0 ['batch_normalization_52[0][0]'] \n", + " \n", + " conv1d_212 (Conv1D) (None, 16128, 32) 4096 ['activation_52[0][0]'] \n", + " \n", + " max_pooling1d_41 (MaxPooling1D (None, 16128, 128) 0 ['activation_52[0][0]'] \n", + " ) \n", + " \n", + " conv1d_213 (Conv1D) (None, 16128, 32) 40960 ['conv1d_212[0][0]'] \n", + " \n", + " conv1d_214 (Conv1D) (None, 16128, 32) 20480 ['conv1d_212[0][0]'] \n", + " \n", + " conv1d_215 (Conv1D) (None, 16128, 32) 10240 ['conv1d_212[0][0]'] \n", + " \n", + " conv1d_216 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_41[0][0]'] \n", + " \n", + " concatenate_41 (Concatenate) (None, 16128, 128) 0 ['conv1d_213[0][0]', \n", + " 'conv1d_214[0][0]', \n", + " 'conv1d_215[0][0]', \n", + " 'conv1d_216[0][0]'] \n", + " \n", + " batch_normalization_53 (BatchN (None, 16128, 128) 512 ['concatenate_41[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_53 (Activation) (None, 16128, 128) 0 ['batch_normalization_53[0][0]'] \n", + " \n", + " conv1d_217 (Conv1D) (None, 16128, 32) 4096 ['activation_53[0][0]'] \n", + " \n", + " max_pooling1d_42 (MaxPooling1D (None, 16128, 128) 0 ['activation_53[0][0]'] \n", + " ) \n", + " \n", + " conv1d_218 (Conv1D) (None, 16128, 32) 40960 ['conv1d_217[0][0]'] \n", + " \n", + " conv1d_219 (Conv1D) (None, 16128, 32) 20480 ['conv1d_217[0][0]'] \n", + " \n", + " conv1d_220 (Conv1D) (None, 16128, 32) 10240 ['conv1d_217[0][0]'] \n", + " \n", + " conv1d_221 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_42[0][0]'] \n", + " \n", + " concatenate_42 (Concatenate) (None, 16128, 128) 0 ['conv1d_218[0][0]', \n", + " 'conv1d_219[0][0]', \n", + " 'conv1d_220[0][0]', \n", + " 'conv1d_221[0][0]'] \n", + " \n", + " conv1d_222 (Conv1D) (None, 16128, 128) 128 ['input_5[0][0]'] \n", + " \n", + " batch_normalization_54 (BatchN (None, 16128, 128) 512 ['concatenate_42[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_55 (BatchN (None, 16128, 128) 512 ['conv1d_222[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_54 (Activation) (None, 16128, 128) 0 ['batch_normalization_54[0][0]'] \n", + " \n", + " add_12 (Add) (None, 16128, 128) 0 ['batch_normalization_55[0][0]', \n", + " 'activation_54[0][0]'] \n", + " \n", + " activation_55 (Activation) (None, 16128, 128) 0 ['add_12[0][0]'] \n", + " \n", + " conv1d_223 (Conv1D) (None, 16128, 32) 4096 ['activation_55[0][0]'] \n", + " \n", + " max_pooling1d_43 (MaxPooling1D (None, 16128, 128) 0 ['activation_55[0][0]'] \n", + " ) \n", + " \n", + " conv1d_224 (Conv1D) (None, 16128, 32) 40960 ['conv1d_223[0][0]'] \n", + " \n", + " conv1d_225 (Conv1D) (None, 16128, 32) 20480 ['conv1d_223[0][0]'] \n", + " \n", + " conv1d_226 (Conv1D) (None, 16128, 32) 10240 ['conv1d_223[0][0]'] \n", + " \n", + " conv1d_227 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_43[0][0]'] \n", + " \n", + " concatenate_43 (Concatenate) (None, 16128, 128) 0 ['conv1d_224[0][0]', \n", + " 'conv1d_225[0][0]', \n", + " 'conv1d_226[0][0]', \n", + " 'conv1d_227[0][0]'] \n", + " \n", + " batch_normalization_56 (BatchN (None, 16128, 128) 512 ['concatenate_43[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_56 (Activation) (None, 16128, 128) 0 ['batch_normalization_56[0][0]'] \n", + " \n", + " conv1d_228 (Conv1D) (None, 16128, 32) 4096 ['activation_56[0][0]'] \n", + " \n", + " max_pooling1d_44 (MaxPooling1D (None, 16128, 128) 0 ['activation_56[0][0]'] \n", + " ) \n", + " \n", + " conv1d_229 (Conv1D) (None, 16128, 32) 40960 ['conv1d_228[0][0]'] \n", + " \n", + " conv1d_230 (Conv1D) (None, 16128, 32) 20480 ['conv1d_228[0][0]'] \n", + " \n", + " conv1d_231 (Conv1D) (None, 16128, 32) 10240 ['conv1d_228[0][0]'] \n", + " \n", + " conv1d_232 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_44[0][0]'] \n", + " \n", + " concatenate_44 (Concatenate) (None, 16128, 128) 0 ['conv1d_229[0][0]', \n", + " 'conv1d_230[0][0]', \n", + " 'conv1d_231[0][0]', \n", + " 'conv1d_232[0][0]'] \n", + " \n", + " batch_normalization_57 (BatchN (None, 16128, 128) 512 ['concatenate_44[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_57 (Activation) (None, 16128, 128) 0 ['batch_normalization_57[0][0]'] \n", + " \n", + " conv1d_233 (Conv1D) (None, 16128, 32) 4096 ['activation_57[0][0]'] \n", + " \n", + " max_pooling1d_45 (MaxPooling1D (None, 16128, 128) 0 ['activation_57[0][0]'] \n", + " ) \n", + " \n", + " conv1d_234 (Conv1D) (None, 16128, 32) 40960 ['conv1d_233[0][0]'] \n", + " \n", + " conv1d_235 (Conv1D) (None, 16128, 32) 20480 ['conv1d_233[0][0]'] \n", + " \n", + " conv1d_236 (Conv1D) (None, 16128, 32) 10240 ['conv1d_233[0][0]'] \n", + " \n", + " conv1d_237 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_45[0][0]'] \n", + " \n", + " concatenate_45 (Concatenate) (None, 16128, 128) 0 ['conv1d_234[0][0]', \n", + " 'conv1d_235[0][0]', \n", + " 'conv1d_236[0][0]', \n", + " 'conv1d_237[0][0]'] \n", + " \n", + " conv1d_238 (Conv1D) (None, 16128, 128) 16384 ['activation_55[0][0]'] \n", + " \n", + " batch_normalization_58 (BatchN (None, 16128, 128) 512 ['concatenate_45[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_59 (BatchN (None, 16128, 128) 512 ['conv1d_238[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_58 (Activation) (None, 16128, 128) 0 ['batch_normalization_58[0][0]'] \n", + " \n", + " add_13 (Add) (None, 16128, 128) 0 ['batch_normalization_59[0][0]', \n", + " 'activation_58[0][0]'] \n", + " \n", + " activation_59 (Activation) (None, 16128, 128) 0 ['add_13[0][0]'] \n", + " \n", + " conv1d_239 (Conv1D) (None, 16128, 32) 4096 ['activation_59[0][0]'] \n", + " \n", + " max_pooling1d_46 (MaxPooling1D (None, 16128, 128) 0 ['activation_59[0][0]'] \n", + " ) \n", + " \n", + " conv1d_240 (Conv1D) (None, 16128, 32) 40960 ['conv1d_239[0][0]'] \n", + " \n", + " conv1d_241 (Conv1D) (None, 16128, 32) 20480 ['conv1d_239[0][0]'] \n", + " \n", + " conv1d_242 (Conv1D) (None, 16128, 32) 10240 ['conv1d_239[0][0]'] \n", + " \n", + " conv1d_243 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_46[0][0]'] \n", + " \n", + " concatenate_46 (Concatenate) (None, 16128, 128) 0 ['conv1d_240[0][0]', \n", + " 'conv1d_241[0][0]', \n", + " 'conv1d_242[0][0]', \n", + " 'conv1d_243[0][0]'] \n", + " \n", + " batch_normalization_60 (BatchN (None, 16128, 128) 512 ['concatenate_46[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_60 (Activation) (None, 16128, 128) 0 ['batch_normalization_60[0][0]'] \n", + " \n", + " conv1d_244 (Conv1D) (None, 16128, 32) 4096 ['activation_60[0][0]'] \n", + " \n", + " max_pooling1d_47 (MaxPooling1D (None, 16128, 128) 0 ['activation_60[0][0]'] \n", + " ) \n", + " \n", + " conv1d_245 (Conv1D) (None, 16128, 32) 40960 ['conv1d_244[0][0]'] \n", + " \n", + " conv1d_246 (Conv1D) (None, 16128, 32) 20480 ['conv1d_244[0][0]'] \n", + " \n", + " conv1d_247 (Conv1D) (None, 16128, 32) 10240 ['conv1d_244[0][0]'] \n", + " \n", + " conv1d_248 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_47[0][0]'] \n", + " \n", + " concatenate_47 (Concatenate) (None, 16128, 128) 0 ['conv1d_245[0][0]', \n", + " 'conv1d_246[0][0]', \n", + " 'conv1d_247[0][0]', \n", + " 'conv1d_248[0][0]'] \n", + " \n", + " batch_normalization_61 (BatchN (None, 16128, 128) 512 ['concatenate_47[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_61 (Activation) (None, 16128, 128) 0 ['batch_normalization_61[0][0]'] \n", + " \n", + " conv1d_249 (Conv1D) (None, 16128, 32) 4096 ['activation_61[0][0]'] \n", + " \n", + " max_pooling1d_48 (MaxPooling1D (None, 16128, 128) 0 ['activation_61[0][0]'] \n", + " ) \n", + " \n", + " conv1d_250 (Conv1D) (None, 16128, 32) 40960 ['conv1d_249[0][0]'] \n", + " \n", + " conv1d_251 (Conv1D) (None, 16128, 32) 20480 ['conv1d_249[0][0]'] \n", + " \n", + " conv1d_252 (Conv1D) (None, 16128, 32) 10240 ['conv1d_249[0][0]'] \n", + " \n", + " conv1d_253 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_48[0][0]'] \n", + " \n", + " concatenate_48 (Concatenate) (None, 16128, 128) 0 ['conv1d_250[0][0]', \n", + " 'conv1d_251[0][0]', \n", + " 'conv1d_252[0][0]', \n", + " 'conv1d_253[0][0]'] \n", + " \n", + " conv1d_254 (Conv1D) (None, 16128, 128) 16384 ['activation_59[0][0]'] \n", + " \n", + " batch_normalization_62 (BatchN (None, 16128, 128) 512 ['concatenate_48[0][0]'] \n", + " ormalization) \n", + " \n", + " batch_normalization_63 (BatchN (None, 16128, 128) 512 ['conv1d_254[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_62 (Activation) (None, 16128, 128) 0 ['batch_normalization_62[0][0]'] \n", + " \n", + " add_14 (Add) (None, 16128, 128) 0 ['batch_normalization_63[0][0]', \n", + " 'activation_62[0][0]'] \n", + " \n", + " activation_63 (Activation) (None, 16128, 128) 0 ['add_14[0][0]'] \n", + " \n", + " conv1d_255 (Conv1D) (None, 16128, 32) 4096 ['activation_63[0][0]'] \n", + " \n", + " max_pooling1d_49 (MaxPooling1D (None, 16128, 128) 0 ['activation_63[0][0]'] \n", + " ) \n", + " \n", + " conv1d_256 (Conv1D) (None, 16128, 32) 40960 ['conv1d_255[0][0]'] \n", + " \n", + " conv1d_257 (Conv1D) (None, 16128, 32) 20480 ['conv1d_255[0][0]'] \n", + " \n", + " conv1d_258 (Conv1D) (None, 16128, 32) 10240 ['conv1d_255[0][0]'] \n", + " \n", + " conv1d_259 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_49[0][0]'] \n", + " \n", + " concatenate_49 (Concatenate) (None, 16128, 128) 0 ['conv1d_256[0][0]', \n", + " 'conv1d_257[0][0]', \n", + " 'conv1d_258[0][0]', \n", + " 'conv1d_259[0][0]'] \n", + " \n", + " batch_normalization_64 (BatchN (None, 16128, 128) 512 ['concatenate_49[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_64 (Activation) (None, 16128, 128) 0 ['batch_normalization_64[0][0]'] \n", + " \n", + " global_average_pooling1d_4 (Gl (None, 128) 0 ['activation_64[0][0]'] \n", + " obalAveragePooling1D) \n", + " \n", + " clinical_output (Dense) (None, 1) 129 ['global_average_pooling1d_4[0][0\n", + " ]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 760,801\n", + "Trainable params: 757,473\n", + "Non-trainable params: 3,328\n", + "__________________________________________________________________________________________________\n" + ] + } + ], + "source": [ + "clinical_model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "kUjy4uqqTBtf", + "outputId": "459975fb-6dae-4a56-95f2-fcf023235449" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABNkAAAEDCAYAAAAItdIJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3hUVf4/8PdJJ3SwIAIiroIdFdvXtbEr6q5l17ayRWy4dv2tqNhQsSFiV1QEVxAXbBSp0kGlBhIghBZCSCGQnkmbTPv8/jhz584kEzKT3CEZfL+eZ55k7tw598wt5577ueeeo0QERERERERERERE1HwxrZ0BIiIiIiIiIiKiaMcgGxERERERERERUQsxyEZERERERERERNRCDLIRERERERERERG1EINsRERERERERERELcQgGxERERERERERUQsxyEZERERERERERC2mlPpCKVWolEq3KL0+SqlFSqntSqkMpVRfK9KNFAbZiIiIiIiIiIjICl8CuMbC9KYAeEtETgVwAYBCC9O2HINsRERERERERETUYiKyCkCp/zSl1ElKqYVKqY1KqZ+VUgNCSUspdRqAOBFZ7E27SkRqrM+1dRhkIyIiIiIiIiKiSJkA4BEROQ/ACADjQ/zeKQDKlVIzlFKpSqm3lFKxEculBeJaOwNERERERERERHTkUUp1APB/AL5TShmTE72f3QRgdJCv5YvI1dAxq0sBnAMgB8A3AO4EMCmyuW4+BtmIiIiIiIiIiCgSYgCUi8jA+h+IyAwAMw7x3TwAaSKSBQBKqVkALkIbDrLxcVEiIiIiIiIiIrKciNgA7FVK3QoASjs7xK9vANBFKXW09/1gABkRyKZlGGQjIiIiIiIiIqIWU0pNA7AGQH+lVJ5S6h4A/wBwj1JqM4BtAG4MJS0RcUP34bZUKbUVgALweWRybg0lIq2dByIiIiIiIiIioqjGlmxEREREREREREQtdMQOfNC9+1Fy4ol9UVEBxMUBNTWA2w3ExwNOJ2AMapGYCJSXA0lJ+tWxI1BWBpSUAP36AS4X4HDoae3bm/MmJOg04rxrsK4OqK4GunXT8zmdelkx3jBmbCwQAw9cnhjExAAxSmCvU0hMBKqqABG9nNhYnWZdnf5efDxQW6vz1b69/g2xMWL+AI8HTncM4uP1Zx6PniwCJCgnHBKP2lqdZ0Dn0eHQvzsuDsjJAY49Vv+e/fuBE08Eiop0PhwOvUzvYtC+vU7X6dTLcruBDh10XuPj9Xwul36flKTnd7n0/8Z6jI8HEuIFbo/y5TM2VqcZF6fnE9Hrra5O57O6Wk9v105Pj4nRPz82Vv+NgQcQgcc7kq/LZc7v8QCx4oLDE4faWr2crl0Bu938De3b62V1THbD4Y5FfLx39brdQGwsPB79XkH/eFdMgm9fAvTyRcVAKb2f1dXpNI1t166d9zfB03DHcLvhRqxvvbaL1ytQktv71pmxDm02/TWXS//24mI9PTFRz5eQoD/r1Mn7u2P1++Rkc5u73UBygguemDg4HEBSnAvVdXFITgYqK83t27mz/puYqNMR0WnFx3n3PacT7hi9Aux2nY/YGIHDqVBXp5efkKC/550dbrfOf/v2epqxvyYkmGnU1ZnbNT7euzG9G7u2Vs8bGwtUVJj7aHKy/r6xnmtrzeMyKUnPExenl5WYaC4jLk7P693MKCvTnyuljzejzHC7dRqdO+tpycl6mv+6FdHLVwq+/SUx0SxrjH3amNd/+xj7s8tlHvNut54PML8XF2fOp5T5v8ejP0tONterkb+EBKB9O2+hoBRq7Qrt4vX2B4AYcftWfp0rFokxTkAErpgEX/48Hr2e4uP1e2M7xsXpsss4LmNj9V8j78Y6999njXwnJup1aeTXOO7j4vQrJsb8rlEuGtva6dT7UG0t0C5Rl39Op57HOP6NdWfsLw6HuZ495urwlSci5j5ulHtGGez2rqK6Ol3eVVbqfNTV6fmN8rp9e/3ddu3MfcMoi9q318tJTPQe+h6PWb4gBrW13jI7wdx3lQKUywmXikeccusfnpRkHlS1tUBiIjzQ5xSIPv4S4jxwuGIgovNt7GvGcWGsfxG9z4sAXbrAd54oLtb7unFsOhzmOcxYt+3bm787Lk6nZ7fr48Z3ANjtAYW1xMRCecydw+PR+59HxaKmxtzHKit1fmw2vczycp2fuDjzHGL8NbZDfLxe7wkJ3v1GCWrtylemJCXp1V1UpD83vqOUWf4kJprbJzbW3G/i4vT3jTIsNhZIqNUVC0+79qio0Gk6nTqd2Fh9zhLR6yMhQf8W41yWlKT3/fbt9fydOpnHfrt25jnJ/1gy/jfK+MREnX9jVcfAAw9ifMcXROARhZhavUCHOxaxsXq5cXFmORkbq/NgHFNOp3kcGlWMqir9t0sXvT6O7uKEE/GorNTnUmP9VlWZeTTWq1HWGWW5JyYOMfCgxh7jOw8pBSi3PlBqJcm3DxjHpsul85WQ4HfOjQk8Tox9vKZGz5OU6F2wUVh6K4Ge5A6IgT4+ysr0/mOsD6MOZhy3xvbxrVOYp2+nUyfvcOjfbZQzxmndKG86djTLS+Pz2FizzHa7vedU7w7tdMf4jjMjDWObGOdwY9lGUWDUzzp3NusBxjnLv37aqYMHpeW6rIiP1/n26KoTiovN40HErB/GxZnHYWys3i5JSXodJSToNLp00d/r0kWv/3bt9PTOnfX+3r69WZcyyiyIQGJi4XYDcTF6O7liEhDncUDidf2qutrMf0yMzkdcnD73JyfrdBMSgMR4D9wS4zsG3W5vOeRwmAeYwwEHEnzbJybGLJ6M8r+uTs8Kt9t3cjDyIGL+NuM7sbH6O0ZxbBw3xjZzuYCO7fQJ3oMYfa41TjJGpc1b+XXFt0NcjL4+iIvV9WNjVqOMNc5BXboABw6Y+5yRlLGvGftDXJxZP/e/5jH2deP82rGjud8Y9RtjQr1Tjf4NRgFt7KBxcb7NW1Ojt5tRbzTOycZ5xNiHlQr4uq/cqKszTx2xsWYZZxwTRn3Tv6yPjwdiPC5fhcPhijHLi1jvyd6bqRpXgq+um5Sk0zKODyMv8fHAwYN63cXHm3UB/7LMyK+xvo16gnFeNfZFYx0b+1ZCgj6fxcebu0JysnmdYKQRo/SKN+peRrnvdOqfYqwXmw046iizPmXk3243j83qar2NldK/2zi3JCTofJeU6P87dAi8Vu7cSeByK8S563wFjSchyfebY2KAWJdfZdrpBGJidD0yUeevuto81xrHnNOpl2Xsb7GxZlnrcpn1bGMfNta3UV8zygGPx3xVV5vnz6qqwHO2sZ8Y+fCvsxvXpkY9tF0781gw6nExMUBcXbXvAkNiYmG36zx27+xCdl4cevQAkhI8qK2LQbt2ul5VUwMc39GG6thOaF9diBz7MXC79fTTT3HiYGk8EhP179271zz3uN3ZKCkpViBco5QUhzjvRuAnEbkmohlqhiM2yNanT19s2JCCuXOBY44BNm3SB2ePHjqYlJCgD55+/YDZs4FTTwVOOQW44gpgxgxgyhRg+nR9Mtu/H/j2W+CCC4A5c4D+/YFevXTB1r27Xt6ePcCGDcCttwIXXwwUFADHH+89YUH/7YhKFNk76mBekhM7s+LRrx+wapUuBLKzdUHcoweQmanz16MHkJYGDB4MXHiBoMKm0DlZBzhiYgBVVYmCqo44roegrFzB4TArfyckHcQ++7HYsgU47TQ9PSUFyMsD+vbVhfOjjwKPPw706QO89BIwdSowfrzOR14eMGiQLrCqq4Hzz9fpHjigTxQ2G/D73wNZWUDPnvp3FhbqvJ92GnDRRfqipn9/XYnLztbrrfcxdaiwJ/rqwJ066TS7ddPpGkGlPXuAk04C1q/X6Z51lp7eqZNZgYiPBzooHYWriu2M2Fh90jh4EDjjDF2gdfWUIK+2O1JT9XJuuw3YscP8DRdcoH/DledWINfWGcccAyQmCFBeDunS1XdSS0QdcOAAipJPgM2mf7PLBXSMq0VdTDvExeltlZkJXHKJDl6mp+t14XDo+XDgANCjBySpnQ7alZejDF3h8ej97MweRUBWFuoGXojycr3OSkuBAQOAhQv1flRaqk+eEybo/fbEE/W26t1bf3bllWbdsrQUGDhQB1N/9zv9e8/pU4LKhO7IywNOPaYE6zK7Y+BAYMUKnc/CQuBPf9JZ7dvXvAgsLweO7VIHSUiE2p+PsuTjAQC7dun8dU6qQ25hIjIz9fJ79jQrJQUFZoD6//5Pb7/KSv3q1Uuncdpp+m/37vo7xx4j+gfExcHdoTO2b9fHVNcugjlzFbp21evnvPP09jzrLJ3/9HR9zAP6mM7O1vu63a5/T3a2vjjs3l1vr6oq/Ru//16XBwkJwGWX6TKjqkrnOz8fuPZaffwMGqSzVV6ul5mXp0/gZ55pXkDHxentUlCgz81Op9522dk6jzU1ehsWFpqVm+Jifcz37KnTNwJHSUl6+3XrpvNWWmoGY0pL9bHZpYteD8YFvc2mt1+/fsD5p3lrIHFx2LorEWf2KEJlku43tKOnQq/0U07BnuLOOKnDQcBuR1HyCb79p6pKr9NevfRxZQSZunUDVq8GTj9dV+I6ddJ5NY7hY47Rv9MI3HTpYl64/e53et3Hxen5i4v1d446SqdrBE/atdPrrFs3/ff88/W2GDRI5+ns31WjwNYeBw6Y6/HAATM40aePzld+vi6vjYqdcaFk5Nm4qC0uBvbt02V4Vpbef8vL9f61bx9w4YXAypU6H7t367Kme3ddSRo0SC/n1FP1dwYO1OurpESXhe3b6/2vQzvvFbD3QK6NaY8tW/T27t1brzcjQJpYnI+SpOPRPaYMKCyEnNIfyuW9I5GeDvTtiyrVUafpciGvKBG9utcit7gd7HZg505dSe/UyTwulNLlqtsN/PCDPi5uukl/fvLJwKRJwHXX6e/17g3k5urdp2NHnWW7Xf+eo47S66h7d53ejh36/KnstXrl7t5t1ug7dUJdclck2iv0b+/WDZU1sejoKkNlXFds3gxs26bz9/PPwJ//DCxdqiugs2bp90cfrbfBscfqsvKYY/Q637VL75tnnKGPndpaoEOiE5sz4jFggN5vfvc7vR9/+qn+u2eP/m2xsfrvjh36t/ftq7PcqZPe57Ky9HIGDND7lVH2nrBlDnDUUagdeDF+/FGvk8JCICNDly3r1ulteNllOm/Llul1tG6dLpPS0vR5Z9cu4A9/0PsIoH+DzaZ/V3Ky/t8I+paX6/yVlOi/PXua+3LHuFrUop0O5MbpfaHSkYiO6WuA005Drq0zOnXSy+3eXR9b6en6d2Zm6vV53nl6fzWOQyPAsXq1Pg5uukmvywduOoiDOBbLlulpWVn6N61Zo8uG3r11+d2nj14vdjtwXA9dltcmd0c7TzU27miP8/rocigpCYgvLwJKS7HZ3t+3vtq10/tcYaFe97166Zdxw+/oo33Fmq8MT0vT66V/P6deOcXFeoZjjgFSUlB1zqXooKqRW9oe336r13O3bmYAIC9PH7fl5cD557qxMzPWV1cEdD6OP16X6zabXm+rVpnlTHKynteoy11xhU6rXTu9Lycn6+l2u95PKiuB445y6gUfdRQKqjqiSxe9jffu1fMXFur5c3L0es7L0+9POcWMI9bUADfcoJfbt6/OW1aWrj+6XHr6VRdVYtrcjkhO1qtj7Voz0DZhgp7XCDz87nd6vfToASxapMvWbt30djnlFF3+9e6tj9Ubb9Rl1fXXA6mpeh/+9Vfguj8L1q1XuOACQNkqIJ06Q6Vv1Yk7HHAmd4bNBnRPrgWKi1GS3Bvda3JRd0xv2Gz6WDn2WDOguGyZzsP8+Xq7nXuuXu8n96xGhas97Ha9bsrLgT8MFv0mIwMYMgTIy0Muevvq44mJungyAoYulz4Orh4ivoqKO6Ed1q/X68Dh0PX7M8/U66JDB70d9+wxg2Aej3nuOnhQ132vPKMI6NABtWiHdvYyPVNhoV4HOTm+ym9RjzNxdFIlShwd0b2TExU18XC59O6blaWPx4wM/f8NNwDjxunf3rGj3t75+bqsMQLiNTU6L5f+XrA3WyEvzwyqGIHIykq9Xw4erLPSq5c+fs4717vuevbUAZMEQfo2hZNOAto5KvSGuOEGvfMnJQHduqHMFouundzYmBaLlBRd7+jUSb+MOs3+/Xo5/fqZN/iNfbGiQu9PWVm67Ni+XX+3Z0/9m7p10+tTRJfVAwfq319To8uBDrVFeia7HfuK26OwUP+e4zpV63W+aRPQrx82FvbGeQPdWL4qFgMG6PLXqMN26KDXc48ewLvv6jpAr166nM7MNANcPXvqXaRPH32cGcHL8nLzvFpZqcsKI8icna3X8wm93Jg9NxY9e+r9pqRE/5aMDH3cVFToNNrF6Hp2dbVeF3366PQKC83joqYGWLIEuPde/Z3UVH1u6tVLr6NVq3T5vHatviaIjQV++UUfOx066DQ9HuDLL/W6v/xy/X2jTnzt4DqUVCWie+luX7Sptk9/2Gz6e8nJQOfC3UCXLnB3OxqxxQeBhATsKe2Kfv30b9+40SyHkpJ0vvbvN8+LGzfq89GgQbquUlSk6x5GHrp10+vbCKwlJwM//WT+/spKvR7XrtXb4Kyz9Pmqa1d9PZGfb56Hdu/WaZ19ts6Dw6HP6wcP6n2upka/379fz3fmmfDdiOmetUF/6HKhLrkrdu3SefzXn0ow7D/dMXIkcGrfWmzNbIczzxB8971Cairw+pWLsabDVbh4/ft4cOdjKC/X2yllYQHe/t9x6NdP/95//lMfD+ecA6xZM+jQwY3fkGIAKSHOq4CjIpmX5jpig2xERERERERERBRFjDtcTTEeUWljGGQjIiIiIiIiIqLW5d8nV1OMfk3aGAbZiIiIiIiIiIgioK5uO6prElo7G9Ej1JZsbVR0556IiIiIiIiIqA0SEezdexpuuPPO1s5KdPAfnaypVxvVdnNGRERERERERBS19City375pZXzEUWiPMjGx0WJiIiIiIiIiCwmooNsyhiSlprWhgNooWCQjYiIiIiIiIjIctLaGYguxuOiUYxBNiIiIiIiIiIiy7ElW1jCGV20jYru3BMRERERERER0ZGBLdmIiIiIiIiIiMif0ScbhYFBNiIiIiIiIiIiCsQgW1iOgD7ZLMm9UuoLpVShUirdb9pLSql8pVSa9/Unv8+eUUplKqV2KqWu9pt+jXdaplJqpN/0E5VS67zTv1FKJViRbyIiIiIiIiKiyGCfbGGLiQnt1UZZlbMvAVwTZPq7IjLQ+5oPAEqp0wDcDuB073fGK6VilVKxAD4GcC2A0wAM9c4LAG960/odgDIA91iUbyIiIiIiIiIiy/Fx0TAZAx+E8moyqYaNwep9foVSqsKvYdgoK36CJUE2EVkFoDTE2W8EMF1E6kRkL4BMABd4X5kikiUiDgDTAdyodMh3MIDvvd+fDOAvVuSbiIiIiIiIiCgy2JItbNa1ZPsSwRuD+fvZr2HY6BbnHda1ZGvMw0qpLd4IYlfvtOMB5PrNk+ed1tj07gDKRcRVb3oDSqn7lFIpSqmUkpIiK38HEREREREREVEY2JItLEafbBYE2cJsDGaZSAbZPgFwEoCBAAoAvB3BZQEARGSCiAwSkUHdux8d6cUREREREREREQVlPC7KlmxhCD3IdpTRyMr7uq8ZS7tYKbVZKbVAKXW6FdmP2OiiInLQ+F8p9TmAud63+QB6+83ayzsNjUwvAdBFKRXnbc3mPz8REREREREREUW78EYXLRaRQS1Y2iYAJ4hIlXegzlkATm5BegAi2JJNKXWc39u/AjA6m/sRwO1KqUSl1InQP2I9gA0ATvaOJJoAPTjCj6JDv8sB3OL9/jAAsyOVbyIiIiIiIiKiluPjomE7TKOLiohNRKq8/88HEK+UOqql6VrSkk0pNQ3AFdDN9fIAvAjgCqXUQOi9KhvAvwFARLYppb4FkAHABeAhEXF703kYwE8AYgF8ISLbvIt4GsB0pdSrAFIBTLIi30REREREREREkcHHRcNijC56WBalegA4KCKilLoAuhFaSUvTtST3IjI0yORGA2Ei8hqA14JMnw9gfpDpWdCjjxIRERERERERtXlGn2wUBgtaqQGNNgaLBwAR+RT6ackHlFIuALUAbhcLNtjhCRESEREREREREf2msCVbWMLrk+2QGmkM5v/5RwA+smRhfhhkIyIiIiIiIiKyHFuyhc2iIFtrYZCNiIiIiIiIiMhixtOHbMkWBgbZiIiIiIiIiIgoEFuyheUwDnwQKdGdeyIiIiIiIiIiin4W9snWWhhkIyIiIiIiIiKyHFuyhY1BNiIiIiIiIiIi8ufrk62V8xFVGGQjIiIiIiIiIqJAbMkWFj4uSkRERERERERE9XF00WZgkI2IiIiIiIiIiAKxJVtYOLooERERERERERE1xJZsYWNLNiIiIiIiIiIi8mc8LkohYp9sRERERERERETUEFuyhY1BNiIiIiIiIiIiohZgSzYiIiIiIiIiImqIj4uGjUE2IiIiIiIiIiLyZ/TJxsdFQ8TRRYmIiIiIiIiIqCG2ZAsbW7IREREREREREVEgtmQLC/tkIyIiIiIiIiKi+ozHRSkMDLIREREREREREVEgtmQLC1uyERERERERERFRQ2zJFrYoH/jAkhChUuoLpVShUirdb1o3pdRipdRu79+u3ulKKfWBUipTKbVFKXWu33eGeeffrZQa5jf9PKXUVu93PlAMAxMRERERERERHTmMlmyhvNooq3L2JYBr6k0bCWCpiJwMYKn3PQBcC+Bk7+s+AJ8AOigH4EUAFwK4AMCLRmDOO89wv+/VXxYRERERERERUZvBPtmagUE2QERWASitN/lGAJO9/08G8Be/6VNEWwugi1LqOABXA1gsIqUiUgZgMYBrvJ91EpG1ovfQKX5pERERERERERG1QeyTLSxHQEu2SD7seqyIFHj/PwDgWO//xwPI9ZsvzzvtUNPzgkxvQCl1H3TrOPTu3aeF2SciIiIiIiIiai62ZAtbGw6gheKw5N7bAi3ie5eITBCRQSIyqHv3oyO9OCIiIiIiIiKioIzHRdmSLQxR3pItkjk76H3UE96/hd7p+QB6+83XyzvtUNN7BZlORERERERERNRGsSVbWJTSo4uG8moyqYYDdNb7vNFBOVsikkG2HwEYI4QOAzDbb/od3h90EYAK72OlPwEYopTq6h3wYAiAn7yf2ZRSF3lHFb3DLy0iIiIiIiIiojaILdnCYm2fbF/i0INmBh2Us6Us6ZNNKTUNwBUAjlJK5UGPEjoGwLdKqXsA7ANwm3f2+QD+BCATQA2AuwBAREqVUq8A2OCdb7SIGIMpPAi9gtoBWOB9ERERERERERG1SRxdtBksehRURFYppfoeYhbfoJwA1iqluiiljvMbW6BZLAmyicjQRj76Q5B5BcBDjaTzBYAvgkxPAXBGS/JIRERERERERERtWOhBtqOUUil+7yeIyIQwltTY4JutH2QjIiIiIiIiIiJ/bMkWFuNx0dAUi8igSGanORhkIyIiIiIiIiKynLdPtlbORVQ5fCOHNjb4Zou03XFPiYiIiIiIiIiilNEnGwc+CJGFo4uGoLFBOVuELdmIiIiIiIiIiCzHx0XDZlFLtkYG6IwHABH5FI0MytlSDLIREREREREREVmMLdnCFF6fbId0iAE6jc8bHZSzJRhkIyIiIiIiIiKyHFuyhe3w9ckWEQyyERERERERERFZji3ZwmJhS7bWwiAbEREREREREZHFjMdFKQzWDGrQaqI790REREREREREFP3Yko2IiIiIiIiIiBpiS7awMchGRERERERERESB2CdbWNiSjYiIiIiIiIiI6mOfbM3AIBsREREREREREQViS7awMchGRERERERERESB2JItLEpxdFEiIiIiIiIiIgpkPC7KlmwhYp9sRERERERERETUEFuyhY1BNiIiIiIiIiIiohZikI2IiIiIiIiIiAKxJVtY+LgoERERERERERHVxz7ZmoFBNiIiIiIiIiIiCsSWbGHh6KJERERERERERNQQW7KF5Qh4XDTiuVdKZSultiql0pRSKd5p3ZRSi5VSu71/u3qnK6XUB0qpTKXUFqXUuX7pDPPOv1spNSzS+S4v/xnnndcH1dWVkV4UERERERERER1hfI+LtnI+okpMTGivNupw5exKERkoIoO870cCWCoiJwNY6n0PANcCONn7ug/AJ4AOygF4EcCFAC4A8KIRmIuUvXufRX5+LnbuTIvkYoiIiIiIiIjoiMTHRcPGIFuz3Ahgsvf/yQD+4jd9imhrAXRRSh0H4GoAi0WkVETKACwGcE1ksxgLAHC7XZFdDBEREREREREdgfi4aFiMx0WjOMh2OPpkEwCLlFIC4DMRmQDgWBEp8H5+AMCx3v+PB5Dr990877TGpkeMUnrVuN3uSC6GiIiIiIiIiIg48EFIfi8i+UqpYwAsVkrt8P9QRMQbgGsxpdR90I+ZonfvPi1Miy3ZiIiIiIiIiKh5jD7ZKAxtuJVaKCKeexHJ9/4tBDATuk+1g97HQOH9W+idPR9Ab7+v9/JOa2x6/WVNEJFBIjKoe/ejW5RvsyUbg2xHEo/Hg/Ly8tbOBhERERFFsT//uQ9GjLi1tbNBRG2eDrLl7t8Ph6OmlfMSJaL8cdGI5kwp1V4p1dH4H8AQAOkAfgRgjBA6DMBs7/8/ArjDO8roRQAqvI+V/gRgiFKqq3fAgyHeaRHMOx8XPRLNnTsafft2RWlpYdMzExEREREFcfBgLpYs+b61s0FEbZx/S7Zly95oxZxEiSOgT7ZI5+xYAL8opTYDWA9gnogsBDAGwFVKqd0A/uh9DwDzAWQByATwOYAHAUBESgG8AmCD9zXaOy1ijvTHRV0uJxyOutbOxmG3ceN3AICyMgbZiIiIiOjI5nK58NlnL6C62tbaWSH6jTKDbE5nbSvmI4pEeZAton2yiUgWgLODTC8B8Icg0wXAQ42k9QWAL6zOY2OO9JZsTz99DnJzt+GMM35rz4hzdBciIiIi+m1YvHg6/vvfV1FeXorHHvu4tbND9BtkXm+zf7YQGFDRePAAACAASURBVC3Zolh05z6CjvSWbLm521qcxsaNX+GiixTKygqanrmNMAo2BtmIiIjaFhFBRsZKXoQQWcjhsAf8bevS039BWtrq1s4G/Qakpy/DlCn3R3w5/uc0EU/El3dEiIsL7RUCpdQ1SqmdSqlMpdTIIJ/fqZQqUkqleV/3tjT7DLI1SgfZPJ4jsyWbFdatmwgAKCjY2co5CZ0ZZOOuT0TUVqSkfIsRI86LuuCKHkznQGtn44gxZ84PeOmlK7Bw4YTWzgpRq3n66YexfPlcy9KLtrrviBGX4o47LmntbNBvwKuv/gErVnx2GJbEIFtYLOyTTemWUx8DuBbAaQCGKqVOCzLrNyIy0Pua2NKfEB2lbSswW7JFf5Bt6dIv8d57oyKWfjS1CjMKtmjKc2npAcyaNbW1s0G/MTabDTt3trzFK1EoJk26HVlZm6Ku8jlr1ut4/PHjUFaW09pZOSLk5GQDAPbv32152hUVFbjwiiuwZ0/03BhsDW63A263s7Wz8Zs2adLHeOCB6y1LzyhXY6L88avfoqKig62dBbKENPI/Ncq6PtkuAJApIlki4gAwHcCNEc07GGRrlNEn25HQku399+/CRx+9Ynm60dbiQIu+x0Vffvl6/Oc//0JlZfQM1uBw2FFQYP1FZ3r6ZpSXl1ueLjV0ww3X4sorz2jtbBzx3nzzNWzfntLa2QhZaupU/PzzzAikrMtkjye6umjYuHEOAKCyMnq6TWjLzHOz9fWLRYvmY31KCt5550XL07ba6tVzsXfv9lZZ9syZHTB1au9WWTZFhscTfTeYIyU9/Vf07KlQWJjX2llp0pIl3+HMM3tg06afWzsrR7zDeU1rHI90COG1ZDtKKZXi97qvXmrHA8j1e5/nnVbfzUqpLUqp75VSLT4JMsjWiCO9TzZrRFfzc8C/EI2eikZJST4AWH5nuby8BJs2b7Y0TcPYsX/HtdeeYHlL0MsuG4grBw+2NE0Kbu1a3R9KdAbTo8fLLz+Pu+463/J0S0uLUFxs/UXEd9/9Cy++eJPl6RoXfyLRdc41goIxMREdR6pNc7ms22bGfvBbvwgZOfJ63HprsKdZIs/jcaK2tnVbz+TkZGD37i2tmocjSbQ9LhpJs2ePBwBs3ryylXPStNRUncedO9NaOSehqay0ISZGYebM71o7K2GLdF2XfbI1Q+hBtmIRGeT3ak5/E3MA9BWRswAsBjC5xdlvaQJHKqMlm5WVxyONWUhYG7AqLi7EggWRaCkRnQWbefFp7Qngb3+7EOf9ocEgv5ZYu3Y2gMhcKKWlRUdl40jxW7/YjVYXXXQM7rormlqjRF9LtiVLFqGgYBeA326QLSNjE5KS4rF27QJL0otkSzbW56LHQw+djn/84+zWzsYRg4+LNhQNNxCNPMbExLZyTkKzb18mAGDcuNdbOSfhi3xdl0G2sChl5cAH+QD8K8S9vNN8RKREROq8bycCOK+lP4GlbSOOpMdFI83q5ud33XUN7rnnJtTUVFqaLmCesKwu4GpqapCVlWVpmqbIBNlyc/dYmp4/42Rl5fHDYE/rOBL6paS2z7yZED372w03XA27vQpA278ISkvbiIkTn7M83dRU3eJ1zZp5lqQXqZtK3y1fjvvuu8PSNAsLszBxosKePUvhcjksTTsSRo48G08+eWFrZ4OaEIm6jpmm9U9x1NbWYvAf/4jMzK2Wpx0J0fTIrLHdoiU4atT540Ic8bEtiXzgi32yhc26Ptk2ADhZKXWiUioBwO0AfvSfQSl1nN/bGwC0uL+G6DhqWwEfF21apO4CGXdCIhNUkYikfeutf8Epp5xkaZoG8+QafYWyleuZx2Lr4HqPnGi4k364GI8xWd2SLSXlZ7z77jsRb8XU1rfllVeej6lTX49Y0Nzq3291ej+sNB8Nsyrt3bt1gPGHH/6BESMSsWfPGkvSjZScnC3YvXt9a2ej1TmdzjZ9vEbmGDVaRFl/2ffOO69j+YoVeOutRy1P22qFhYVYs2aO9511+0B29nb07Klw002XYsSIoZalawStouUxX+M829ZvOgVj5fXK7t1zoYYMgc1W5pvGx0XDZOHooqL7IXkYwE/QwbNvRWSbUmq0UuoG72yPKqW2KaU2A3gUwJ0t/QnRcdS2AqMlW7CT3b59i7B/f2T6sooukenjIZKVH6MQHTr0NIwe/VfL0l26dDGASOXdeIwqelp4GAoKslFTU21JWk4nRztrDdHUks3j8WDq1LGorra1dlZCwtaZJrMvLmuDYf/852V48skncNll51iabv3jwsoWeCJi+b5hnJusPI/MmzcHr732SED6LRWpx0U9ETg3x8UlAACqqnT/Zbt3R0fn5LNmffabHT20qqoK3bol4LPPXm7trDTK/4bAokVfWJJmJAc+ePvtVwFExw25IddeG5H6wZYtvwAANmz4BfPnT7cs3Ui2ZPvxx29RXp7b9IxhMM4vsbHRF2Sz8pyzevVrAIB9+3RjqF27vsaqVdeZS2rDQf42xbqWbBCR+SJyioicJCKveaeNEpEfvf8/IyKni8jZInKliOxocfZbmsCRq/GWbDNnXo133hl4uDPU5kTqpG2kG5lIv1mwrV49y/rUI1BwGut31Kh+mDbtCcvT//DDpyJ2sX/LLafjgQeusSStaKjAHW41NeUoLNwV0WVEU3B32bK5GD/+aXz44X9aOyshYZDNFKmWbIaMjHRL06utqwt4b+W2fPzxP+CCCyJzkWJl0PzDD9/z/W91kM3qc6n/9rEqbSPIZoiW1htjx96P5cvfau1stIr9+3VQYcaMz1o5J43zD7K99949lqRp1tcjd9kXDXWFnTt3+v63soyJVP00Un3peTwe3H//3/DZZ5dYmq5xfonGIJuV53CPR9/EMM4RS5f+M+BztmQLkYVBttbQdnPWytgnW+sx+/OyvhCK9N2DSOTZ/+T600/vWJ7+11+/hU2bNlqermHTpl8sSSeag2xVVZXYvNn6dfzaaxfjlVf6W56uv0i0ZHM6nRFJ1+HQgY+qqnJL07XbbVi27GHU1dVYmi6DbKZItWSLlBq7PeC9lS3ZUlOXW5ZWfeefn4z8/L2WpBV4PrXm3Gqc7w4e3GvpI76ROPdHKsh2OMqFior9EV+GFZ577jYUFlqX1//7Pz1ia1tuoR2Zuk7kHhc1tOV1aojUNUCkWoZGKjhqPBlSURGZlmzR2Cebtd3b6D464+Lig37OIFsILHxctLW03Zy1MqNPtt/SaFQigk2bwulTxBhEwOq+WKzvNN8v9Qik6Zd6RArOyHfSGg1Nl12u6H285eGHb8XVVw+C3W5tkKagoMWtmZsUieMwMTEBd955seWVcqMiavVxuGTJGGze/DEWLRpvaboMsvkzWjBFxzm3pkFLtrZ/gWnYtGll0zOFILCPGWtbsqWkzMdHHz1uSZpAZB4XjY0NDLJZdSF8OIIVLpc96PTa2oyw08rMXIe9eyMz8NPSpd9h/PgXLE+3LR+vkdj+kRz4wFxG212nhkidcyN1rWjk95tvPkZlZVkTc4cuUvVpYz1EY0s2K+uNxs3C3NzdjSxLsHz5ZGzezK6nGmXt6KKtgkG2JhzO1jP792/Dr79OO2zLq+/gwU9xyy3/hz175oY0v1EgWX1Ba1TWb7jhWOzebW0QIdIXtdF60RwdQTbzWLTbrennzZ+IRGyEuNTUtQDMllZWi8R+Z1zsRuqCb9u2DTjnnDjs2WPdiGTGXXqr14dxV9LqIP3hOO6KivaFtZydO1/Hvfeqw95nk9mSre1fqAENHxeNplFRy8uLLUknEo9g+nc/YXZQ3nKRONbqtwqyKsh2OG7uulzBz0Xbt58edlqjRl2Es86KzMBPQGS2nRXntUiV3/W3vxX7g5FXq1uy+a/HaGvJFk2Pi2ZkpOD99/9tWboOh1nXLSy0pmUzYJ6/ly9fgtLSg5alKyKYPftbFBRErnuUSDwu+vzztwZNd9u22fjwwztx/vnseuqQ2JKt7dq5cyfy85t7QOrC93C2nnnppTPw4Yd/P2zLq6+6egsAoLIytObDxgkqOzsVBQVWFtJmgZSaus6ydIHIN9GNRPqHY+ju6Aiymcfi8OEnWp5+auqHePTRRBQVWX9H3rirF6n9z+kM3iqhJQ5X0CMjY61laUVqJF7j+DAuohcv/gBvvKHgcFS0KN3DEZR/6KG+mDnzvaZn9Nq1S3diHYl96lDMVohR0pKt3uOi0RIcBNp2kM2/pY2VNyUicY6rf/xada4+HDd3Gwuy/VZYcbxGKqhUP6j2xhv3tThNo+5h9WOHdX43G6KhS49oC7L576eVlaWWpetfn37iiX6Wpet/TGzY8FOj81VXV4aV7u7dGRg+/G/48MNbmp23YCI14qd5YxbYVVTU4HO7vWV1x98MBtnarlNPHYAHHmhef0XGwdYaj6itXj0HNlvhYVlWYAFjDL0c/Bnyxkye/AiGDrWukPavuFo/ElL09cnGx0U1/0pMRUXDk1ZLZWUtAABkZv5qabolJUUoL9eVo0i1UHA4ai1Nb9eu7b59OdJ3p608ZiLVks04H0ydOgJlZduxYsUnAIDq6ub3FSQi+OwLa0aOa8rWraE/HmjcgQ12EVpZad6Zrq6uhNNp3YW6UdZ/9dVZmDKl7Y78Z4jmIFtZmTXlZyQfFwVg6f7liUBe629zqwIYh2Mk7cYeF21ZmpFqzROJAGnLj9dIHfP11+PChV+3OM1IDVQW6SBbXZ21dZtI9CMJRDLI5l+XsW7b+bdkA4Dq6ipL0vWvLzocwcuY1NRlOP/8Tti2bWnI6dbW6q5WcnOte/IBAFaunOT738pyxqhHAcCeYmtuav3msE+26PPKKxdjwoTLQphTH2z1C87D8UjIs8/egPfeu9bydKuqbKipqR89N3+PiC4UYmJCfb45MoEZ/4LusceGRSztSIjkY3v+duxYge3bh1hWyYvkerGqUhfpu6RxcYkArK84T5r0vu//SD2Cl5eXjs2brWv1+fvfn+b73+ogW/19zdrWfUbru8g8wg4AixcPRWlprnd64HIqK3Oxf/+2kNJMTU/HiGeftS6ThxATE4sVK8Zhw4YfmpzXuNkSbF99991Bvv8vvrgTRow437I8+gcopkx5ybJ0Q3HwYArGjj0vrMfQo/lxUasuXAP3f+uDbFY+vh+Jc1z9bW5dn2zmuW7lyukoL7fusStDKC3ZFi16EgcPTmpyPsP48SNakqWI8w9eWXFei1RL5PotOK1YjrH/Fxfnw+m07rjyD9ZEIuh45ZXJWLFinmXp+a/LN9+827J0I1W3W7LkW9//VgZI6zcgqauzJujuX3Y1dpNk2zZ9IzsjY1nI6UYqgJ+dner739qBD8z1W3MYbpocsRhkiy579qxFdvbPIcwZ/HFRt9vsuLz+AVlXV4Qvv3wo4M5OcxUV7QEA/OlPCjNnNr+peEWFOcreued2xr33dgn43L+SaAbZQmvJFolH3+z2yD6iZFVFW0SQk7OvwfS1axtvHt1c9R9B2b59IT799HZUVCyG3d68Fo8LFgT2uxfJIFtsrDWdUtaveFpZUfR4PMjLWwXArCTs378TDz3UARs3Tm1R2lVVNt//kWoZ+/rrV2Do0IuwZ88O3Hvv5aipseauJAAsX25dv0hAw8qclfuecaxY30+kmV5JyWbU1RnBmMDlTJzYBy+9dEaIaR6+1qNKxWDu3CfDetQi2Cif5eV5Ae/37bPurnJ1tXWPwjTm669vCzp91arHkJu7CXv2pAb9PJj6QTarLjBnznzMknQOJZwbFi6XHQ5H8Ed7It2SLVKPi7b1lmz+F5RvvjkUzz33e0vS9RfscXCXK7Bj9dWrx2HPnnsPmY7/Oti4MfSWKa2httYMLltx087/txcXH2hxeobzzx8Q8N7tdrW4fDHOYQsXTsH06W+1KC1/gS3ZInOjYcaM/1qSzrZtGxpMW7SoZfU7Q/26nRVlzIEDBQHvrQyy1W/JZrfX4u2332jx4AqBLdmCl98JCUkAwmupHOx4dbkc+PbbEaira0meze307ruPWnYz378lW7UFMYHfJLZkiw5pab8AAGpqQq/EN/a46Lp1V/j+nz37qYDPtm9/BkuXjsf8+d8iXPULZP+h4Dds+Dzs9AyPPXboPt4yM8/G3r0bvHkIN8hm/UXi1KmfNJhm7d1Ca/L8xRfvYsCAvsjISA9YDyNH3mZpfkUEubmBgz98/vm1sNn0ne1gF8Kh+P77wAE2pk2zpqIRjFVDed966zkB7996y7pOYL/55n3Y7fpEbazTOXPeQl1dNaZN+1eL9vWqKvMC1cogW7A8XX31qdi0aRU2bbLuYue116wb4Q8AamoCWwtZebysWaPvjK5bt9DSkVwbC9q1JJhXV6+Se/BgaH1hNkcofUW53a6AsuZwDnywdOk3jUx/FWvXqoB9va6uCpMmnY7Fi19BcXF4j+tu3fpd0OnGo3NG5T8Ujnp31g91ESwiIZchP//8ge//lSu/Dzk/wezOzcWcBQtQUBAYHHW7XaioOIh//asrFix45pBpfPfd6ZgypVPQzyIdZLOypfb8tdb1/Wh4990bAt7719ta4sUXHw14X1CQCbfbaenjs8FasmVnPxVkzkPz76og0q3Nc3I2o7R0Y7O/b7ebebXivOMfUBgy5Djs2GHto2z+li1rWDcOh//vzcxMa2l2fPyDbJF6fLawsPndMvj79df5Daa9/vq/LEm7/r5vxbqo33pr48ZFLU7TTDvw/D58+F/x8svP4oMPWnaTx/93N/a4qBlkC71RRbCWbCNHno5Fi97Ghg3NfyLA/7y1dOk32LlzdbPT8hcQZHNEZkC13wSOLtr23X//pRARTJhwRYPP6upqGwlU6AOvft8YNtsm3/+//BJ40jNahTWnhU2wO6L+hWBzK7BZWTsP+bnDsRM7diz3LsMIsrXe0Mv+lSCDlRXL+usxI2MlPv749bDTWbduBQBg7949mDw1MED1979bt/6WLTv0RZbL1bxRNuvfcfz880+blU4o4uLC6+MvVOvXW9dqMCvLfMRv6tQH8P33gX1lud3N3wf9W7JZ1dLR4/Fg3rwPG/383XcfaHbalVXWtYKrT0Rw0UVH159qSdpOpxMTJ77te5+VZd0FT2PBNP/9Yu/e8Pryq6kNLOsmT34l/IyFKJQWNvPnP4sHHzzV9z7UAL4VwZWMjOCPOi9e/AKAwIBATs4GlJRk4KefRuGee85u8bJ1+npbhHPuc9SrG1RUNB4k3bz5Prz3XtPbICUlsLx/+eVbQ85PMKf87W+4YehQXHhh74DpNlsZHnusB6qry7F8+ZhDplFZGXwgGIejFuvXm9tt/35rBoyJxM279G2Bj3AvWPBDhAaLicGuXatQVdWyVk3z5zd8rPuFF3rgxhtDDwIbbLZy2O01sNlsAdOdzoZ1Lbc79M64PR4PcnK+woYNZuA6J2cH9uzZHXYem2LsE6NGDcSSJYOamLtxRr9OVqkfqCstjVzfS5WVLe1H0TyurAyG+QfZDhzIichxlZgY/n4fTKRaj4sI8vIyA6ZZcUM12FNReXnrW5wuAOTkBA5Wt3WrDl7X1IQ3IEF9/sGwxq7dmhNk8w9ivvTSX/Hzz9Nx8GCm97PAsqy8fBfKypq+aelw1GHZssBrnzVrWnZjCwD27k2F02mWNXxctJnYki16vPXWRThwoOFF19/+loxly/4Kl6sONluJ3ydND3zgcASesJXSFfTm3M2rv5yYmFhfvz8AsGDBV2GnCYR2Uvnhh6cxZIjyBdn8T8ClpbnYv387AGDy5Ddw//0X+aferDyFqyUnbbvdDluledKof7H80ktX4K23nsPo0X8LK13/DtZTN29udv6aUv/EXZ/LFbgPVlUV4O23/9lk30KHs5Pu2Ng4FBfnIz19OWprrQvgWFVhevzxSzBnTmC/M88+ew+WLzenGY9L1daWo7w8vMquf5DtnXcexZYtv7Qgt8DYsX/GbbfFYuLExu84lpQUNHv93PbQQ83NWpPqt2IDdMB3/PjhSE9f3qK09+4NvKFgRauKnJzdqK62Nbou/YNsH39sPtKVmdn0b6kfZLPyZkJ9/sGjrVsXB50nM3NFwPtQW7JNmfJas/NlLitwW9V/LMa/wuq/LSoqDn1RG2r3A2633fs39Mpw/SDbjBn3AwB27vwGNTWBQZ2cnIkAgF27dMtyp3M/bLaGI3J/+mnLgmqh2rhxRZPzvPrqJfj118brHTt3BgaVN29e1eLR71atmoeFC38M+tn+/c0dKT74Y2zPPNOuWWlVVVXinXceb2TfE4wdeznee+84y/vrCudJDMPUqZ9g0KCuGD78NAy+/vqAz+x2sysRtzsfHk8dREK/Qfz11//Axo13YNKkwH6tUlJa1mJw166dOOmkzgHT9u/PRn5+y1tfBbuJ25QVKxbgiSeCPxHS8OZ45Aepai7//bG62rqRDe+85x7f/yKCTz+9qUXpud1uvPji5QHTkpKad6zW19jNsvvuU8jLC60v1WCmTHkXv/wyO2BaXV0tUlODn2tDFWx/Xb36PWRkLIHL5YDD0byg7p492zBs2I1BP/v551kt2j+MBghA4y3ZjBvv4Yxw7B+8W716Ft5+e6jv/e7dk30jvefkfItp0/pj1Kg+qKjIOWSalZUlDaYtWND4zevA/Dgw+C9/wbffHhMwfebMmXj66XMDpoX6uGgkumCKegyytU31KzjZ2Q2j/9u3LwQA5ObOxfPPt8d99/X1fWZU5P2DX1VVhy7QlNJNFt1uNyory5Cf37DPrsZ89FHgha1SMRg58iTf+61b14Sclr9gF4c2W0GQOc2WbEbH1wAwcmQfPP/8aVizZhI++eRZZGSsw6xZ+s53/XX83/++iNtvb36zTYfDEXRUrb17N6OsLC/IN5o2ZMhF6Hziib73jRViK1aE94ivf5AtWGXaqgBQU60iKyv3BLz/5ZensXLl11i/foYvf2vXLkNq6lK/71Ri1qyGd2vCvUCqq6tDWlrDRzfq//a4uHj8/e+9MHr0YDz2WPNanuTlBdv+gvLyAhQVBd+fm+LxeFBQkI2MjKabhzscOlA2ZkxP3HbbMU3MHaiyMrAFQXW1rZE5zXytXj0L27evRmVlGd58886AAUvS0ho+8hBMdXV5wHu32439+80yadGiBXj+1VcbfG/ZmuaVNU2ZPv1jXHLJUQ2m19XVYMmSiRg9evAh76J6PB707q3w+ecvBf18584tAe+Nstvj8TRrtD4RwW23nYKbb+6MqqrgfR/Om/dHAMCmTYEBzwkTBmPs2DsOGTi78e7Ai9PGKqRWWL7cHJ1u7NghjfSVEnjcvvrqAEyfbo7y2dhvWbYs+KOeoTpwoAA//BBYsY2NjcOqVS/63r/xRnfMmaPfV1eHfmGxa1fDltwul90XVAOAnJyNvoDXocrbjz56A+vWmeWos5GOmOfPvx1paWcEfUS0uFg/pr9t2/GYPt0ckXvFisexYMGhu3Y4nJxOOzIzV+Pzz+/wTZsx4+16czU8x73xxm1YtOj7ZrUY+t+cOXj00euweHHDTs63bJmFhx/uj/Hjn9NLDvP8+sa4cUGn675VzRtZFRVN93H62WfjMH36+7j55votcoENG8xjYfXqD2GzleH665Nx6aUKn346Oqw8N2b27FEoKMho0I1EMKNGPQgAOHhwHzamBvY3aATtPB43Dh7shbS0JFRUhH6jIzV1etDpLe2gfMqU/zY4Z27cuBJvv31OI99oyOl0Bi3zi4rC78P27rv/hHnzpmHfvoY3Uxv2y2yHy+XC999/3uzyvLE+nTdvnofRoxU+/1zvR7occ8LhqIWI4IsvRiM7u/FAkX9eq6oq4PF4sGXLKmRkZASdv6amBuXl5UE/87dxY2AdcNu2BU1+Jy1tPWy2hvXNzMx0vPHGI9i+fVXAdGNbzp07CZ9/PrTZ/d8dqu61dm343fwAwNSp72PcuCcaTJ848RmMGjUE6enNH62+trZhkG3r1ml4772rMGJEIhYtOjqksrC2thq1teYNzuzs7Yecf/v25tcB/Z8CaazOYNxUC+UYmTTpY5xxRnKTLQOrq/PhdjuxerXZYGL69D/Cbtd1SpttL1JSJsJmK8H99yssWDAaY8b8o9H0bDYbsrKC39jZunU97r47Ect/+QV2exFOO03hvocewllnKdx0880N5g+lJZvTWYxPP229p8jaJLZka7u2bdvS5Dyff26O4OnxuGG3V2HOnJkAgPJy3beP/4H93XcN+yYqLs7xFc7+LdnuvvscXHpp34B57XY7bLaGdwjKyg7ip58CO/as/9hKcnJHAEBeXi7uuvfekO/QByuAX321Z9B53W7dymjevH8gKytw1Jf//e9ev/+NPlwC0548eTQ8Hjf27jUHlqirs6OgIDAI8suvvyI/v2HQpF+/o/Huuy81mP7CC1fi6ad7Y9Wq2Q0+q8/pdKKw8ABSUpYjLy8P6elmxaiioshX4IZq165dmDixYV8YxuNXHo8n6F3yHTu24oILzm0yAORyubBgwY8B2ylt1y7s27cP27ZtxsSJLx3y+ytW3IasrOUQEXz22YXYvl23PIiLS4TL5cQ993TC3Xf/Ac8880e8++4LKC8vwd6c4Hd3br21e5OBNv/OUp977v9h8OBB2L49BYsXmxWrp54aEvCdkhJzZLQDB7KwdOlC3/vq6qoGlfKammr885/X4cEHH8Sfbr8dNTU16Ns38HEnQO/bjzzSE5dfHrg/5+Rsxf/7f4NRXW1DRUU5Pv74qQad7c+ePR3Dhg3FzTefiFDs3KkvKIxHbH766WMAevtNnPgg8vMbVlRTUtbjwIF8pKUFBvhdLgecTkejlaPJk8dg9Oi/4qmnLsHMme/gp58m44cfnkNGxq9h9TO2erXOc1VVFSorK/H4iBG45pq+KC3Tfc/dcsuf8Nq4cQH777YdOxp0iAsAxcW55dD52QAAIABJREFUmDbtPV+eq6srsH9/YEsc/9+TmroCeXnZAZ+//vrDQYM7/pXtu+9ufNCA6mqd76lTx/qmbd661XfxkJYW2IJizBgdxHrkkXtw7rkJjaYbjNvtxtix5o2PLVtmBJ3P43GgquoAdu36oMFnS5Z8hZEjTw85ILBs2bdYvPhHZGXtaXrmIPbv34+VKxfhsquuajLI8euvgQOfVFQUIzc3pcF806e/BJvtIAoLd2PGjBeCppWVlY4TTgh9/bpcLt8+tm37dpxySsPzkcvlxK+/BgYl5s0bjYyMbzB5cmCr47q6agwf3h/nndew9dCOHQ0vJsaPPwXz55/uXU4dxowxHz+rri7z7aM//7wYKSmL4PF4YLPZMHbss/j3v//om/fjGQ33Cf9tvWFDDL766lzk5jbdh1Ra2vvYuXPaIeepqbEFXFy6XK6IPJoHAJWVDQOZEyeO8LaecGD37h1B9+u0tKV44olb8frrZl0pWHny0UfPYO6iwP6F/vHkk43mZ8cOPe+XX76O3bs346yzYnDxxSdj82Zz3QZbDgAUFBbi2x+Cj6r74ou34rrrTsbHHz+HYcMGYvjwY339OqakpGDAAIV+/RSuueZs3yBSubkNWyAatm0zz235+Zuwc2eqbyTX8eNfbDC/x+PBkyNHIn2nDgbX1FTj3/8+9IiH8+a9gjfeOB3Dh5+Kt99ufPT1pm7m1NXp+l5trdlpuNsd/DtFRfPgdFbCbg9eDvrbsWMbPB4P5s6dG3ZrPo/HE1J5+dRTqkEH7Q6Hw1df7z9gAPr93mxZ7Ha7ISKYMaPhMbZ9+5YGQT1/Rp+yzz8/EFlZgeVJ/ZZsjzxyO3r2jMfLL9+HTz9tfH9ujMPhwLC7g2//7Gy9r3/22YuorS3AO++0w0svJeCee5KRm7seEye+iJEjr/Lmy4O5cyehqKgI/fsn4C9/OQ6TJ5vdolRVleOHH8biP/+5HGeccbrvUUF//3fppejRo2vYvwHQ5eDXX4/DmjXmTQmXy4Xly6ejpKQQf/nLhXj22RtRWamPKafTgXHjXsNtt52Jb75pWN92Oh0oLMzD2LH3YsOG6Xj00SG+9WXsYyUlJaiuNgNJdXV1sNlsqK2txYQ5c+B0OjFt2vsN0jY0tu/l5eXggQeuwJQpr+Ojjx5EdbW+hpg37zucdZbCm28G77PW6K5iwoSnAQBff/0Zuh51FEQE69cvwfbtG7B69fdIT0/F1q0rUVRk1pMrKysxadIkpKY2PCc3XDd1vptDjz56NkaMuDlgv0xJ+RxDhnTAn/+sbw5/+umTePbZ4AMAGaqqGg4k8Mm0aViwILxRXmfM+BCLFr2LlSsDb8QZx6nTqQPEK1YsDhqcT0tbjWeeeRh2ey2++WbiIZfldtuxYMFLAdPKynbjP//phPz8NHz9dT/Mnj0cU6bo69cFC17E5s0rgqZ16aVxOP74zrjiiv4oKQk8F4oI/vGPCxt85/P/Nj44R4Ht0GUxANTUWNdP4hElyoNsvrutbf0F4BoAOwFkAhgZwvxyqNe4cdLoZyeddHGDaf36/f2Q6d166zQ5/vjbBYA88cTrvulZWdVy4ICIzSYy+PLLBYD8/veXy4Y1a2THDpEff5wfNL1u3foEvE9O7iBXXnml7/0PP8wUj0ek5uBBueyyq+ST8eNl9uxlsmjRRtm/X2TJku2SvmKFHH98n0Pm2/+VlHSy7/8uXU6Qq6+e0+i8EyaIHHPMqY1+PnjwnbJuXZZcdNEfBYDs3l0pw4ePlkmTfhQAEhsbK6+88rb87W/DZPv2LPnPf0aHlMc77nhCvv9+tQwdOlwAyJNPPidSVSXpa9ZIWtpuGTbsHt+8xx13nO//u+9+tMm0r7v6atm8uVjsdhHxeCRjzRrfZ/v2HRCx22XdrFnSv/9pvukTJ34t11x11SHTra31yAsvvCoP33+/TB43TtatXCkej17GpA8+EADy9tufyZYtIl9/8knI2ytwfzkz4P2jj34td989Jux0Bgy4WCZOFNm2rUSuvvp2WbJkvXzxxZcyZ85C+eijrwSAvPHGGJG8PDn99LMEgHTq1FUAyDVDhsioUe+EtJzu3Y+SMWM+871/7bVpUlXllp9/LpcJE34IO9+vvLJCnnxyjGzb5pFzzrnWu056yPDhjwsAGTPmv/Lssx/J5ZcPlqeffr9Z6/j999cGvL/88gdl3Lh5AkDOPPNqSUsTychwy7hxMyQ11dVoOiNGmL/75ZcXyfXX3y+9ep0sb765XmbNErnkkj/5Pj/ppHOalVfjtX69SNeuXQOmZa5bJ0uXmr/lq5dfFikvl927PY2mk5DQzrseV8kTT/zom/7441vlm29sMn78WklKaieXXDJE/v73Eb7P77zzaVmzplQWL65pNO1rr70z4H1amsimTRUybNgTMm/eFlm0yC1PP/1RwDxlZTaZMkUfn6NGjZOlS4uCpp2dLX7pVkl2tsiGDTaZNGmRjB79qcTHx0t2dpm88so7smXLQZk5c5u8+GLwMrmx16mn3nbIz/v3HyKffLJSFi/OlcpKEXG5xFFRccjvbNy4Q6qrXSJ5eVJcLCKlpSI7dsi0adPlxuuvl5x9+0S2bBGx2aSyUsTtcAR8f8GC1Cbz/dxzU+T++0vl/vtFrrvugRbtZwBkzpwK8XhE7GVlUlteLrJ1q0hWlkh2tkhpqdjtIjs2bPDNP2vWohYvE4B06tTD9//mzelis3kkZe1a+fjjBXLuuec1+r0RI1zyhz80LK+SkzvKhRc2XqZPmfKTDOjVq9n5HTq0xPd/nz7PyV13LT3k/P/7X4F8+eUW3/sVK0SmTl3se7927VbJ3rFDysrskpdXJOJyidjtYrM1Xsep/7r33jx5//1ceestj4wZIzJq1Kag8z311PqQ06ypEZk2Tdchtm7ZIlJcLDU1IlMnTfLbz3dKTY1TBl96acjpPvCAWb/q1KmzbN2aL2effYEAkJEjp8jQoQ9IWWGhlO/bJ47t2yW5Xbuwts+AAWfLE098IBecf36Dz2JjY8NKKzExKeB9ZqZIYaFITo5IZaXIBx9MEQDSt1cvWTx7towc+VrY+9N331XLBx/slepqj6Snu6W4uFq+/nq+nHPO5U1+96yz/iFDhrwd1vLOPnutPPJI4+U5ALnqKl0Pe/zxd8XjEanMy5O5c+fJC//+t3w1aZJIebk4HKLLtpoakZwcyc6ulF5+dbamXhde+GfZudMjNUVFct11fxUA0rNnX1m82DyPlX73nYhHv7/llmFy7rkXBKQxdeovAkDOP/8yWbhQJHvvXqnIzhapqRGXS2T58lrp3Nk8f44a9blkZoosXLhBMjPz5eOP5x0yjzvXrBGpqZFVq9bLT99/L7V5efLL1KlSkJMjkpkpFXv2yJ8vu0wWLlwnztLSsLe9la+yMpv8/HOVTP7yS/Hs2+ebvmTxYtm0ySE1NSJSXi4yY4bMmTVLAEhuWlrQtDp3Ptr3/5w56fLtt3PliSeC10f79OnXZN4GDrxYevQ4IWDaLbf8SwDI0KF3iBQWSnJysvQ94QTZvLlMhgwZKj169BQA8tgD4Z3bxoz5n9x5p0ceeGCGHH10w+unxx57Q2699fEm0xkwwNzX7rjDrPPdfPMzjX5n0yaH5OWVhJxXAPLyy4u9+/AtDT7r1++sZu0LDzzwkYjdro/PXbtk13yzTpSX55SPPpoq+flVIrt2ScWePdK/f38ZP2aMrJp36OPhtddy5fnnRR544D0BIL17nyWPPKLXzU03PSwzZog4HCKrVtXIt9/mh5Xn+PhOjX7Wvv1RzVoPAGT8+K/Es26djH7uOdmzaZMUFh667tac18032+WEE/R1ycCB50lrx1vayuu8c84RqaoK6QUgpbXzGzQW1doZCCmTQCyAPQD6AUgAsBnAaU1855A79fnn32X5gWK8+vQ5yff/Lbf8U2655Z/yxRfTAua54brrZMOG8mYv49//vl8eeyx4QT9s2IMR+23G669/fT2s+c84o2XBgsP1evXVj2X+/CXy1ZQpAdNnzpwrc2bMaDD/mDHvNZnm1KnfNJjmcrllw/rAC5bhw59r9d8PQAYPfkRuu21Yo58nJyfLz0HWRUtexxxzvDz33Eve9fAfy3/T2WdfGPH1dsopZ0vXrk2fzE8//aJGP7v22gdl0KDBluVp/XppMK19cnKDaf+fvfsOj6Jq2wB+n/SENFIIpJGQEHpHhJcmvSgtoCIoKCiKgL5iA0QFFAQFfdFPRERQEUEEEcSIikgRBAVFEKQERJqClFCkJ8/3x+wmu9nd7CaZyWbD/buuubI75ezJ7OzMmWdOkaws2bz5uOH7yN50881drN537nxX7utOnXpbFVbNU8uWreTBB5/PfX/ffaPspl2lSlru6woVKsn06fNt1pkw4eUS+T8TE1Pl6aeflYUffSS7HdycmKeUlKoSFBQkg/v2zZ3XrH793NetWrWS9e+9J+ndu8u0af8n5cqVs9q+d+8BLuWpSpUe0qPH96KU0uV/bNbM+gHV8AEDpHnjxrLnxx9lw4afdPmMG32aN2+PYWlXqdJKxo49IXXr3lbstNats76+TXnuObvrhYeHF+tzune3vbk0T/VrOH4Q6I6pXr2bJTW1mkyZ8o7s23dM17R79dL2Q2Ahg4pGTv7+gXLkiO3N8lOPPiojRz4pv/12TOTiRRl+7726febUqd9Zva9WrVruaz8/P4fbtW6tnWtjKlSQzz7+WDp06Gh3vZ4973E5L7d17CjjnnFcrrsrPT339ZQJrj1oNmrq1q27dOyo7YMBvXtbLevQobe0bas9MK+VkJA7v+Mtt5RI3pKTqxW4vPdteeerrl0dnw/0mFJTa7u0Xlqa4wc8pX0KDi4vO7ZulVdeeUsCA6wfFHTu3MO0n3vI7ImFeyiQlHSztGv3ivTq9ajd5WPGrJCbb24q0dGxbt8H5ikkJC9416BuXdmz56Dun9G1636pWPExARhks5waNWigPYRxYQKDbMXIJNAMwFcW70cDGO1kG7f/OO1NTZo0d3seijOlpTV0ex6MnB566KkS+ZyHHx5WqgrDnMrmNGyY49qMgwc/lPu6ZbNmEhvreq1XTpw4cSpo6tPnTrfngVPpnqpUqSqJFkGbsjRVqpTs9jxw4uQJU2Sk9nDa19ff7Xmxzld0iX1WQECqAAyyWU6NGjYUuXzZpQmlNMhWihuyWokDYDke7xHTPCtKqSFKqS1KqS3ly0eUWObs6dHjIbRu3cVm/uzZizBjxhw7WxTPtKlTczvjN1KdOs2LvG1amusd1xZWVGQkHn98NN5+e26Rtm/RohcAYObMvP6e7urdG6+//gaiorQOjsuXL4/vFy/GTTf9p0if8d3Kldj2xRfofuutmDHjTbudmnZo3RohQUFFSt9IVapog3DMeP11hIaG2ixfsmSlzTxHxox5EadPZ+PJJ2073ddLz54PG5a2K/z8/HNfP/30pALWzHPHHc/rno833xyV+7p1y5ZWy158cSp2//QTAGD9Dz/g2LGCR2JyJjW1TrG2Dw6OQJs2hRvl90bQtWtP3Noxr5/DZ0aNslmnY4cO+GHtWvzyy3GbZe5w/NAhrJ07F+9PnYoqiYmIjHDv9bgsS0mp6u4s2LV4sf0BMWIqFG7gGLOxY10b8MVTlCtXDrfd1gdHDx7E+P/a79fJFfHx1REdnYSAgAAdc2ecJx97DC2bNUPTps1w9OghHDqsFe0HDXoYsyZPNvzzK1a07QPy3nutB66pnJiIhATbfmBTU2tj+PBn8cQT4wr8jIEDH0dcnPXv8t3Xbfvt9PPzg7d36evsvIOprHDnnf1w9913F7hu506dSiJLZUbXrgWP3l4S93FF8efq1Rgx4jFD0n7kkdEICgoxdIT1oqhUKd7hsm7dRjtcVhSXL2ciOrqRrmmWCeyTzfgJQB8Asy3e3wPg/wraJjExybCIc0iI8ydvQ4e+LN27a/249euX10/YiRMiWVnZ4u3tLSEhYdKs2X+KlAcvLy8ZMSKvn7Gc7Gz55ZcDue+TklKL/X82bPi8DBu23GreuHEfF+ppw5AhYwWANGrUTObOtd/PCwCZNu19p2k9/fTM3NcrVmyR9HStavvqL76QMwcPyvnzWs3RZct+cDl/ERFxsmDBd/LNN3l9aL3wwkvy74ULIqdPS06OyIcfLpFhwx7R+hk6eFCOH7ftu8pek5dDh/6SZcsyJTg4WLp06aZl7sABObJvn826mzbtkbVr/5GrR4+KbNok6enFr/I+YMALhd4mJsb66es//1yX775bJ5cvi/z9t4hcvixXr16To1u2SFRU3lOe48cvS/bFi06f/PToMVL++SdHsrJEDh8Wh+vVq9dY2rZ1vdlk7dq3yKhRr8ijj06U+fMvy5gxec1909O15tODB4+Sw4ezZN68jTJz5ifF3r8A5JtvzkpqqnVzxqioivLjjxfl9ddnye7d2bJhwwGr5VWr1pcZM36VL774K3de+/Z3yUcfXch937q1VgskIUGf5k4bv/1WMnfuzH2fkbFGzp0TkawseXfsWJfTWbLkkvj4+ImfX4C88sqXopSXDByo1Zbr0qWfTJ+u9acXEREjM2Ysy90fs2f/LHPmrJH777ffrBOAzJ9/Wb79Nkf8/QOkdeuu4uennWc++uiQTJ5s3eR64MB7pXHjW+TUoUNy8OAVeeWVxfLJJ5scpv3ZZzvl3XdXyr59V2Xo0GcFgDz77BsyZIjW5L5Ro5tl2bINuuxry6lx43RRSomvr+NmSvmnvn37S1JSskycOEUyPvggt0+2WRMmyO+/7xa5elVWfP65TP5vXncBR/78U+TyZTl8WGR8Ib5PI6a927drTxct+mTLOXVKTp26IId++00uHTokOdeuycMPO+/XxtXpv/+dI88995qh/9eyZY6PL0dTrVoD5bnnDlrNa9bs7UKl8eGHR+Trry84XP7774dl05o18s0362TNmo1y5x13yDdffCHvvPOhzBkzxuXPGTLkPbnttqkCQKpWddxHWgdT37IFTVOmfGAzL+vAATlx4rxcOnlSvv66cE3TfXz85dNPRW69daDNsp9//kPmzFkhe/Ycl+XLz0jHjtZN3dq3aFFg2ikptSQuznG/UDt3/ispKdWLdMw8+OAEefTRt2XEiNdk3LjZ8u23mXLLLR3lf/+bJ+fO5cjRozlaJ0QHDkilihWL9BkzZ+6VhQu14sVbbxXcJ5K96aGHfnW6TlhYM6lbt3BdhHy7apW8+eZqadWqlWxbv15OnPhH9q1YoWXU1CfbwYPnZenChdKtfXs5cSJb5NChIu0D2/yGydmdO+XjMWNk52+/ycgHtD58vby8pFKlOJv1P/tsq3h5ecn8Dz+U7JMnc/tky7/etm0imZkiW7c6zuecOUtkxw6RZcus+1j798gRmTBqlKycNUtyrlyRTYsXy9n9++Wv1avl++93Fft/jo62/r9Gj36vwPV9fHxl/PjPZN++TFmyZGPu/JzsbMlct04AyHPPTZCL//4rc+Z8J4899qR8NHu2HJo1S7KvXpWfPv9cWv/nP7LDQdcHH3xgv1/Q7t37y65dF2T48Nds+ix0Nn3wwU4ZNGhe7vsffzwua9dq3RBMGDdOjmVmyh9/OO5btrBTbGxVad++izz//DwJDY0oUhpxcakSH5/XZ/Jnn4l89NF2WbcuR55//qvc+dOmzZUNG87IuXPXCv0ZCQlaF0UpKXktjWJiHHdL4mz6/PPrcuD333PfX/z5Z5Hdu2Xbtt1W6+1YsULGPfmk7N9/UPZv3myTzvLlp6RRo3Sred7eefePFSpo+X799blSrZrWvPb++4dIy5bdZNq01bp9j0WZFi36XN577wvp2rWn3eX9+zvvKqjwx1sb1mSzmBo1aqT1MevChFJak83tGXApk0VoLlq5snFVtS2DbD17jpU33zwmDzywQVq1yutzZvz4j2XsWK3Qv3TpWnnwwREy4Zln5MQJbRCE40eOyI4dV+XqVZFhw+x3xB4cbN2/k6+vryxc+LnI1aty/bpITo7Ic08/LW+9tVAkJ0eOHbskAOS//31WDh4UmTh6tNSoUU+GDHnDJu2KFa2DcKNGWfdV1KnTVBkyRGTWLJFRo9bnzp85c7Pcd9/rBe6fGjW6S3r607Jv31mZNUvrlPM//7lFFi/Wgg2tLAq9QUHl5JdfdspHHznu/Lly5ToyevRm2bRJZMOGc7JmzX45dEjk0KHzsmHDL1rHh1lZuUE2y+DNjh2HpW6tWvLYY89LWpptv1zJyQ3k4EGR1astt9mj7VxTkO38ee2eUS5fFjl4UE6cEKs0qqamyty5H1rNy8jYKlevivz8s7bZuXOSG2STixdl8eIlcvCPP+TX9etlxYq1cvKk1o+5nDghsmmTXL4sEhER6fRYbNFirowfnyNNmkwRAFK9ej9p2rSndOo0TDIysmXatL0CQB59dJZVB772ppUrRZYuvSYzZ16VzZv/kHnzfpTTp3P70c4NsuXkiMiRI3L6tEi9etpFPStLW/bHH9dl1CjHAdO7754oJ0+KTZDts8/2y6pVecfZJ5+skpzsbFny3nvy/NNPF5jvN99cLp9+qhV+d+0SWbRI5MknZ+cuX7fuqsyfv062br0q585p+/nwYZF582z7yitoUkpJrVrWBYaNG0UWLLgmc+dekebNOwsAWbx4l2zfrh03e/eK/PDDwdz1IyMryrp1IitXimzaJLJsWY68995uWbdO5NNPRZo1024Qlyw5K59/LpKRoR2bEyf+JnPnutYR7COPTJZXX/1W7rvv/6RatQYy5oknRC5ckH+OHBEAEhoSIufOSW6QTX78UR6+/34ZO/Z/EhWhFSTffXexTbqpqXXl889FZs8+Kx99dFbWrROZPFlk+fIceeSR12Xt2jPy00/nBIAMGTJJdu8WmTZtqaxefVjWrdP2+65dYjfPbdveJ4sWaf/rDz9ckF27rklGRqYsWLBOVq0SWbHiD6v1r13LkW3bROTCBTl2TPud7d1rnXZ0dLwsXvy9HDyYJTt2aMsPHhTZvv2avPvu17J3r8jevVny6KNPycGD5+XYMZGtW6/I9Om/SOXKydKr1xCn+zoysp5Uq9bbZn5UVJqsXJkt8+aJPPvsH/LVV6ckNbWWVKtWQw7s2yed2reX2a+8IvXr5nVM3KJFd2nVqpOcPn1Jzp7N0c45+QY+yMkR7aY8J0eyt22T2EqVpH//e3N/pIcPa+eZgpq9jx69WsaPXyBPPfWOREfXlzp1/itffZUjycm2XRl4e/tIcrLtQED5p7ffXiQLFvwpV65c1c5z+YJs5oEPJCtLO8ddvy7nzolcPHpUkpIcBzg6dXLtxj4jQ+tM/vp1kVdffVMAyMyZ38iff/4tTzyhnRvvuONuqVKljbRoUXAQMjIyVh544DnZsOGwZGRclm3bsuXKlRw5dMj+setoqlfvT3niCZFXX822mj9gwDXx909zKY3bb39cVq4UWb9e5PPPRb777m9Zs0bEx8dHAO28a762mHe75cAHR5ctc/oZjRvfK/37/yrz5omkp88QANK9+zgZN26LdOuW159U06bdZeTI9XLZolP0/FNsbKr07TtMdu8W+eOPv2XGjPfl2DHRrqemgQ/kwgXZskW71qWkaIMt/d9LL4ns3i3vv7/RbrpTpmTJp5+KfPZZ3nng8ceflwYNmsjJk7mHmKxeLfL77zkydcoU8ffXbuau7tsn77/zjsM8b9p0XrZsEdm40fr7jYiIkO7d75YDB0T2778uw4blBSz79nUtQLx5c458/bX2/W3fLjYDHxw7JrlBtrlFGPSoVq0W8umnV3ODbDt2XJdHHhkp69btkhdfXCQxMc77Nhoz5l+JitokPj6O+xNt1myH9O0rEhqqPZy65ZbpEhRUcNDhzOnTsmmT9tVLVpb2d/t2qyCb5cAHJ0+KyKFDMmOG4+8KgAQG5gWTwsMjZPOaNbJnz1+yfn1eUODI4cPaTl65UiQnR/7ds0fmz/9Gtm49YBVk++STLfL551skM1Pkiy+u5Zb7zEG2ZcuOWH22Ocj2998ix4+fk8aNW9vkb8mSb2XHDu1YfOLhh2XkI4/IypXfaemePKldBK9ezTsYtm+XEydEfrMTpMg/xcfbPpS//35tIJFx4+bL4sWnZMGCY7J0aY6sXZsjj4wY4TAtpZSsWqX9y+bAlL9/oDbj0CH588ABOXfuikhOjuzYIVYDH8j169r+NZ3L7f+uRNavPy6LF2+RZs20Mv/HHx+XzEzt96qVg/6SSpXi5c47h8qff2bJPfc84TC/6enDZd067Z7EPO/AAe13ZM6HXNAGN1qwYId88802yTl/XuTcOcmYMqXA/RoTkyZdumh9YvXseZ907bpBJk8+JBkZ2le2aZPIihUnZdo0baCMQYPGy/Tp82X7dnE6GMqnn56Qt9/W7s2a3HSTfPaZyI8/aueEyZPzHuzt2fNv7n62zpvzSh2rVh2RCRN+lsWLL8mXXx6WN944LP367ZfExKI9pM3I0Mrzn376rTw+aJB2zO7eLRcvigwd+oS8/fYimTNnoVaoOnFCrl8XuWYqX7ZundfH7ooVWTJnjoi/v9Y1zoQJ+2XkyLxBqsaOXWf6XR2WmTM3Sd267eXAgcPy44/W92RFnRo2LHr/5Bs3bpNDh7Tv/+8vv5QqSUnSu1s3+egj7Rw4alTxg4ABAcFW73v2/J5BNoupUaNG2vnIhQmlNMimjU1d+v0EoKpSKhnAUQB9AfQraAOllM281NR2yMz81s7awAsvnEd8/AXcd18lu8ujom7CyZNa0yrRAn0AgOjoJJQvXwmJiZVw/DiglBdEchAVFYv27XshPb0PYmPj0a5dK4TgPP65rG1XoUIFnLngCwDo1esRbN6cgS1bvrL6zAEDZiI2NgTPPXcrcnKuIyUlBZ073wbgWu464595Bn9dCAHPLqW7AAAgAElEQVQgCAgIwJ9/XoaPjx+uXQPGPPoo+j84CZMn2w6JfeedL2D69LsAAIGBYWjbth/Wrr0DP/yg5alGjZ64eFFbNy2tBR59dB1WrXoSSUk1ERHRBEA45s4dYJVmQkIamjXrj7S0YWjcOBIhIcitCh8TE4vY2GRMnDgDg/p3xYOPPI5y5UIwffpchIYC4eE18MEHn2DAgNtt8pqePgrJyU0AAOXKhSA0NAQAEBwcjLp16wP412abhQu34/z5nxEXF49f167FkUuRCAysj0mTelmtFxoanfv60YcewvSZM5GUlGyTniOrV2/GLTfXxodLllvNr1OnYYHbpaenQ0GAsDAkoDzsjXT/1lsLcOedHW0XmNSsuR5Vq7aAUkD9+k+hW7encPo00KYNcPmyVoO2UqWq2LVLcOgQMGzYYNSuHYSrV7Uq2ZMnf4BRo6y/Q29vH/j4AAkJSfD1TXL6/2dkfI9du/KqeHt7e+Pffx0PV92p0wNW7597bgamTx+NuLhk1KyZjAcffB7169dCy5btoJQg/bbbkN6zJ3rddTfOnIlC7961cfr0Kas02rTpht27kW/enfjttw14+eUpOH/eFzfd1BKXL1uv07v3HUhJuQN79+7HvfemOsxzhQrVERnZBFOnvoOMjN+wd+8XVtXazfts6tQl2L59DapUqWG1vWVzEF9fP6tlSikkJlbLff/II+9h+PDnUK5cKK7l/cwRF1cLERHA8uWXkZXlhfvuC0J2tu2Q59r/9RBEwhAb2xZDhw7DTTW130dkZCTuums4nry/l802b06div0nwzD8znb469Ah/OOb16SrVq2GeOaZdUhM9MGZM0BQUCgsWzQrpZCePgIhIUBAALBmzWUopf2fbdr0REAAcPJk/k+0dv361dzXgYHlTMdgCtLSUnDwIBAbm4RPPxWkp6vcz3RmyZLDSEwEQkOB8+fz5vv4+KB58w4AgNDQMIwfPwXXrwNXr2rfT5Uq9bF16wEcOAAsXTqrwM/o0mUlzp9fgz17lsDHJwDXr2sHWWxs/dxmH5GRSQgLA5Yu/Q1JSUBwYDZWLl8OnD6NNz/8MDet8eMXISXFHwEBgJ3R7G14eXnh0K5duOQTDiDbalnz5m2tmr6bvfTSLsTH10BKCpCdDVy9ej8uXwaUAkaM+B4ffXQrtmzJa5b3zjt/4vz5GHz55XisXPmC3XxMnrwc3bppv0FfXwAOjkt7AgMDHTaX8vLyRZs2o5GV9SQCAyfg5MmtOHp0L86cycxdZ8yYDxAe3s5quwceeBiPDX8Av+7yRUyMdk0GgNDQUAwZMg/nzwu+//5F1K17P/buXYzLl7Ostv/kk6MIDQUiIoBLl7TzqPlwGzXqDSxY8D/8+ef+Av+vyMg74e+faPo/vBAZ2RqnTq1FRERPeHn5oFy5FrhyZS8AoGfP2Vi+fChycq6hf/83cfToAaxZMw0AbPZNVFQMTp0CvvlmF/7557cC8wAA5QIDna5ToUJNREfXBQA0bjwQFy+eRZcu/0VgYABiYqri888nmtarjNTUFvD3P44nnhiHqVPHYdKklzFmzFO5ac2evQ/mVnYxMTHo23eAzXnX0i+/7MWuXVvRJDkBOHMG9eo1s7teYGAYAO08sHTpQRw7thO9e3fFk0+Os1lXKYXHH3sMd9x6K3Zv2QJfX18M6N8fvRMTEZyvaZuvrx+CgoJx1XT6SU5uiFatWmLYsP/hpobZ2JOp7X9vb288+eRE9O37PK5c2Yf9+09j4cL/FbhfR4z40aXzlNnAfv3wW+ZxfP/9V9i8+Qen6wcHh+OVV9bnnrvM+Zw8eRrOnQN8fGrglluaon37arh82bZrCjMfnwD4+d2MGjV2YMcO++Vfb+9yAICAgD5IS9uPBg2qICGhAubNuwvR0cm4cOEULl3SrvszZ85DdHQfhIf7203LmUGD7gcQiIcftm6mmJbWAWPGfI2MDGD9+vr4669fce+9j6FJ48Y4e70cwsIqYunSfTh2LAtxcXHAkSO52wYFBqJly/ZW163hwyehVq1GCArSzrfe3j7Q7nXzREfHYcyYaZg06XGbfIaEhCAwsJzN/LCw8NzXr4wbBwQH4xICgctnCvy/a9WogZMnBQf2/oBOt96GM2dO26zTr18Gli5thfPnK+HWW/+HI0dWoHXrQUhK6o+2bf1x4YK23sWL2jlr+vTpmPHWW7hu54JieR+jlMLatd8jKyuvKW1iYiKuXPe22SeuiI/XyjSRkRUQHV0BixatwFdfbUb58tZNxaOiKmLz5sM4exYICwMee+wVzJs31W6a4eFRua+nT1+JmjUdNztPSamN+HhAqX8BEXS5+WY82L8/3p4/3+76gwd/iJo1G6JTp9vRtm0zvPaadv63FBYWiVq1mmP7dkFWFpCYCJw7B/zf/63Aq68+hX37dtik+8orPyA8PBpZWcC2baeQluKHry1uQatVa4ZRo6agXr37EBgYlPs7/nPvXlROS0P37ukYMeIddOgQaZP2oEGfYsGCkXjuuQ8RExOHpKQ4+PkBMTHxOHNGK/fMnr0Lq1adwO7dz+Kffw4jKqojNm58BadOHXO47yy1atUWvWonWBVInn/+FeTkQPstndiXO9/Hxwdy+jT2ny6P1FTtvGcuA9Wo8R9s2/YtQkMr4erVvGtStWotkZEhiI0FatWKx7hx3yA+Pq+8+NVXR7Bnzzd45JH7CsxnmzYL8N132v1s8+ZLsHHj7ab78Nq563Tq9CnCwq6hShVvbNy4CuvWzSwwzXLlgnNfx0RGYv/27cD167gSVB7btwu+/HKPzTb16jXDr786P3ebBQWF4fLlC7nvK1VqjoMHXd78hpCd4/o1tDTyiCCbiFxXSg0H8BW0kUbniMjOwqbTtu2zaNduEE6fzsGhQ+uwefM7aNmyL65dawl//2CULx9sd7vOnR9AhQpvYtGiSADlAeRFROLja+XLq7asfPkY+Pr6IjbWcZtuS+YbAUuhoTFo2LAFXnjhKv7++1U8MqK703T8/f1tAjZeXnkF9dTUprjrrs9w4cK63HmvvXbC9CpvPR8f68J5ampL3HXXJly9ql1YmjW7xybIppQX+vR5Dpl590Bo3Lg1Jk9+BT163I8zZ4B77hmKihWu4IMPFiMnJ+/crZRCz5598Oyz0/DCC9YFmtat++HECRRKamod1K5dJzdQCAD+/rYFotDQvAv1q5Mm4aFHX4Gvry9cLVg0btwESl0ypB+F1q07YN26y2jVyravlUaNesPXt0Wh0vPy8sKmTZexZ8s7GDVxEkJDyxc7j4GBgQgJsT5WatWy7bNu6tQ1SExsjfzdxvTtOxRPPDEUe/dqhcKhQ8ch0rY8gdq1a+P334FrlpEnALVrd7Cbr6CgYDz99BxERloHWOyJjU1xuOyllw7A2zsRf/3lDV9fIC6uIb744jIyM4/i/Hnr7zwwMAitW3e1OuYA69+2r2/BNx6BgcGIja2L07blawBaX28+PkDFiqk4enS33XX8/QPs3tgqpTB69BuoU/EfONolMdHRiAkJwer9py2280JAQDn4+TnYyE4eXQkSWbIMshVk9OjJWLt2nfMVddar13QsXfqozfygoIqIj78T3t5d8MMPrfDXX9sBAL6+he8fycfHt9DbOApQtWrVEXFxlXH06J+589q0eRpxcTXsrm9Wp84tuUG28uUTEBERi3//BW69dQISElJx8uRZ7NixHJmZq3K3qVevVaHzbclRIMLHx9+03Aft2k1AdDRw8KAgJ2cH3nyzI/799zgqV64JpWz7WLKU/9yslMLtt/+LypX90a7dVAC/4rXXWruU1759h+POO+/CU/e1xzfbtjlcr1KlEVbvq1efgA0bWiMgoKpp+SRUqOCF8PBn0bBhAuLi+iIrKxNt2tTD2rULLfJu//tNTq6K5s2r2pxr8gsqZD9dfn5BuOWWUVqwFEBgYCjq1n0c27dPQ2BgSO56w4c/jb/+CsHAgQOtgmxF0bBhI6isf1xev1KlykhNrex0vYT4eCRY/P/edq7Rffta533KlK2oXx/IyrJZFYAWlEtKqoW//3b83QPAM89kIyyscGUCpRQef/x5vPDC8zh1CkhLC8GlSxccrv/aa5ucphkbm4Dt2y9i+fK1WLf6ZSzPsO3Xzvz78PWtiJo1V2HXrvY263h750WnAgKqWC1LTm6CHTu+zH1/xx13Y8MGoCjBGTNfX9tz4aVLeV/KY49tQ7162UhK8gKQ9yNISEhFSIhrn12tWn2X8nL//SPtBtkA2A2yhYaG21nTdTc1bow//jiF6tXj8Pff1sGQgIAwLFjwK6ZOBSIjgaSk6gDyzpX2fPTRGvzvf1OwcePnBX5u8+bNoZ3Siv69dehwJ7p1m4MqVazPW2FhYWjRoiMOFaPb1/DwvAfizZp1QmIinJ7/LE0fNw5N2w+HF3Zj4H3WQZvIyGR4eXmjZk37Qf6CtGjRGdWq1UPbtrbXIctzZnh4BAIDrR+GKaXw0ENPYdcu6+0SExNx4cK/uH7dH1u32i+t1anTEydO9EKNgi/pCA6ugCeffBve3sD33wPZ2TuRkTHbtX+umMxl32eeWYLjx3+Hl5fzhz6WYmLikJ1d3el6Varciays3bh06QfEx/dCaGgVnD2biaAg7f4uNDQWVar0QmwsUK8ekJTUG5mZG3DsmG1g1CwuLr7A4ysw0LZv6jff/AIjR3bGjz/+6PyfA+Dn5xn9aLqLCOxWQPEkpbi3OGsikiEiaSKSIiITna1vr+Du7e2LZs36oUGDu3H77bPw0ksXMHLkR6hRo+BO0ocNmwEvL1+88soptG69H+aLUN++b6Nq1aZ2t4mMrOjCf1VwfsuXj8td1r//40hNdVzbpiCWNxm+vv4ICYmxKrz7+PjZ5MHXt3AnQ8D6yZjlZ48c+YTV072CPPDASIwd+1qhP9sVOTnZNvMsa7J5eXlZPb0oyJIlm/HddxuttjV79tnvipFLa/ZuvL28fDB0qP1OpV3RNz0dO3b8YVOrSi9paQ3x8svWgRB/f30Gc7CsvTV48AQ88YSxnWEHBobavdGNiIhDWJj9p/75WQZC4uOL9hvO7/nnv8Uddzxrd5ke36vl/1yaOmZ++OGn8eqrX5T457Zu/YjDZUop+PmFITs7LwDs4+Na4cnynKtnoF4LJN1vNa9cuSgHa+fJsSjRKGX9vTdvPgAtW46Al5f1szl//8JfK1wRFBRjM08phdjYuggO1q6NrgRnzfvY8vrk4xMELy9vBASEoWrVVujX71eX81W+fCS+njDB7rJ+/bIwYMBOhIZaDxAUGdkKPXqsQGKiNtiLr28MWrV6BwEBiVBKwde3HKKj6wHQavCZOQqyucrXx/lzVG/vgoO7SmlpBATkXRsDAgJw660j4e9ftNpK7mDvPNar1/AipZWWVh+DBjkuhtp7aFp4ecdr5cp18OyzB5CRIUhPn4Lu3acgIaFaAdtaq1u3NXp16+Z0vdBQ+w/uvL0L+o0XPSjjiL1yz6VL1jXBvL29C1VTML/CfEf16t2MatVa2sy3H2QLK3KeLOUvr6amFm3ArcaNm2PMmPd0yJFz99zzBPz8gqwGfiqs7t0H2p0fFub8+lUQf39/1KnTFA3qWwdXO3UagJCQ4qXtqMwVGOja/YQ9QUFBpmPc9jht02Z4kY/9gQPHoVWrHpg7d6nhg6WYyzTlyoWhZk3798rOREfblgPM7rvvbYwY8TmUUmjUaBwefvgrq/0SE1MPw4ZlYMyYTJttR43ajn79xtpNd+7cn51e28LDK2HMY9pAEEOHPocvPv0UoaHlsemHH/DUU8sL3NYsMbF4g4XdCHJyXJtKK48JshWWvROQZeEV0Go2uXKi0qqRa4VRLy+f3MJ6VJRtDZi0NK1wXdiTq70TaXh4wU/oXWVZUO/de5zNPHvy12Sz58EHV+Wbo09hq169Jrqkk1+5craFH8sgW2HUq9cEN9+c99TLfDGpXr0hatW6pUhp2mPvxjs1tU2xb760tPPSCHShWVFR0waAgADbwmhRZGdrBc8GDTph4MCxub/N4srIsD8qY0CA7dOqwrL8DsePt99cobAiImLRo4ft0/V+/R4q1o2HmeUNqd61NN9+2/qJevfuD+Lee1/V9TP08tprX+KOO552ad3g4LxasUUJsunN/Ftp2rQPWrfui6ZNH3S6jbkmNuBagOeRR94rdlC3Y8eududXr97H4TYtWmhBrrg450FrV47fyMjaTtdxhZ9fGCIja9pdVqXKrfDycr6vzA+9AK1ptl6aN7etrdewYRc0bfpQgdulpQ2Al5cfWrWyHfnXx4UgXmmRvybb0KFrEBHh+AbOmX79xhQ3SwWyDAoPHDgNkZFaNxadOz+F9u0LX3vQlTONUrbBrcDAGvDxsT0OzeVpy1q7zz+/oND5ssdeQDQqSp8HVGaFua59/PEmjB1rW4PayCCb+fwNALNmrcfo0WuLnFZJ1ZjRo6wwceJ7eOihd23mW9ZkK478x9awYcV/qO8oqGj5YKKo7O3T6GjHrS+ciY6Ow9Spn6FLl55o3rxtcbLmlB4PGypXTsY339g2zQSAKlUao16922zmp6aau0KKRK1aXeDnZ//+ZsCA8XjnnQsYMCCv6f8HH5xFtWoNXMrbxGeeQf/+lzBixHh07dwZQOHKdI8++oHFO89uFmkEc002BtlKIXsnJmdPbAFgy5Y9GDUq72I6ceKHDte1dxPyxBNfYvXq/YW+ebKXX2dNy1xlPtFVrVoLNWveYvo8Z0E2558dE5O/qaw+QTbLi2DDhjfrkiYAVK/eDPfeO9dqXlhY0QvZlkrrsNsFsdzP69Y5b3pSGEYF2cx9i/Tt+5yuAYry5W0LcO3bP1SkJnz5We4LPZromtnLm16FactjQ59aGXnatLkNaWlpAIBBg57GE0/MRFSUa83qXZWQkKZLOs2adcagQZOt5nXs+Indde+552OEhWlNqYrSXFRv5poQiYl1MHr0AgQEhDjZwvoc7ugaYV7npZfmo21b+7UOCuPFF1/B/PnWheiXXlqJ1q0d1xRKSbkVU6eKSzde5uO3oPOFeZ2+fZ9zJcuG8vbOC7KlpzuuQVlYkyZZ30x26PAoxo7NcHqsli9fE4MGXUGlSlVslnlSkC3/NTolxbUmwoVVo4Ztc8ui0Ks8ZeZKGcXeuT4iwrYPTwCoXbsHqlZ9Cnfd9SrMD1hjYpw343VF/rzOmvUt7r77I13SNtPjumYZZKtZszESEpJ1+01YBtl8ff2K9UBRr3sJZ/QqK9g7V4eGRthZs/Dyfz96pGtETTaz/NfhgQO/Qtu2+lwX7AUHIyNda6HhCkfnnAULjmH5ctd7fEpOtl+es9dkEwBuumkcXn45CwEBBZe3vby0rlAqVtQC+ElJNQr9YMvbu+hlPcvmxOXKNS5yOmUZg2ylVHBwCJ56yroGgitBttTUNFSu3Cj3/a239ne4rr0LSmBgCBITbQujzlim5ecXgD59bDutLirzSdryIu0syOZKACP//69XodAy3UWLVuuSpllKinWV+5iYwn9X9pgvJkbWTDHT6zMsL4B16tTVJU17aQN6NhfVCp6WtT30YG+f6vUZRjW3tJe/4jTTsGR5rjAi/6+//gaqV2+AYcPsd6ZfXNOn63vesJSS0geTJu3Bww//aTU/JCQG1atrnXWXhpps5qafhbnxad48r/aY4yCblq6/vz6BRB8fH5tm1Dfd1EmX2rqA6/v4jTcE/fuP1+Uzi8McZEtMTNPt96yla70/s7Nd6wexMGkS8Pjj3+iSjjuCbPaEh3eyO9/b2we1a09BcHBeJ6p6/Wbz57VJk7YICtLvAZW9zygKyyDb8OGTsH79gWKnaWbddL9414n8v9PQ0Eh07uy8ZnNh6fWw2d41y15LlKIw4pyV/4HnvHnr0a3bg7qUIfPv09TUjrrt5/zXl7femotPPvnTwdqF56jsERlZCamp9mt8F4ajliZKeeUOluMKVx7EFUa1aoVv2l29+pfOV7oB6RlkU0p1VkrtUUplKqVG2Vnur5T62LR8s1Iqqbj5L7NBNgAYMcK68+H8zUUdcX4CE9N6+p2sLdNq3rwHOnd+Use0tf/HugmYHs0NjQmymfPp5eWFoCB9gjN5rE+iMTFFr3ZtyRNrsul5/DpLW6+abGZ6B9nya9jwP7jtNvudHReWUceGve9Pr8CHkc1FAaBjx4746KOf7XZwrQe9a9/lV7FiGsLCEm3mZ2dro84WNsg2bpzjGtNFZQ5IF2ZfxMWl4bbb/kVQUDi6d5/iYC3tPK9XU23A2POnUYHME198gfR029Gwi8t8brPXh2hx5L+51ON6bblvP/nkYLHTI0t5309SUr1ip5b/d9Chw1g0bDiowG369fsCYWGuD2yi1+/YyLJJ3mcUP68tW3bJfa1HrXdLljXZ9FCjRl5NmeXLT2LYsIJHVywK/R4AW3//iYkpiI6O0yVtI2rf5v+/GzVqgccem6nL/rA8TuPj9amhb5a/3zEvL29dj2Oj74sc1WQrrLx86nP8hoREYtiwwy6tu27dRrRv/xN8fe2M+HaDE9EGR3RlckZpnQy/CaALgJoA7lJK5Y/0DgZwRkRSAbwGwFEh2GWeFxkohPwnU1dqsgG2HT7nZy6cOluvMLp1K3jwheKwV5PN0Q1S3bo34aabXOvvw/bmTZ8gm/mEZ0RByzLPFSokIiJCr37vSq4mm16MrIWQ/9jQu3N0owZtMFu4cAOiomyDKEVh1H62d6y1atVZl7Qt85yeXvDw6aWREYW7Ll3m44UXCm5WXbfuQ6hYsToaNXKtGaX5OwwJKd6IdPaYa5wV9jzq4xOE118/gzp17HeUbr7+3ei1mKLLl0diYl7zuKAgfQrJ5ppsegXZVnz8MT75ZJ3V99Wr1xD06mV/8IaiqlhRn6aCpDHXZJo5cyfCwys4Wdu5/OfELl1eQM+etn1feXkFWbwu3G+8pGufFu8zin+NqF37ptz+m/QOsln//ou/P+bO/anYaThjRHNRb28ffP11pm7716jrVvPmzgcWKQrLfTpnjv2+yYoqf002vWvPGvU7Hjp0Orp0eVj3LpX0zG/+c2FEhP1BDpo2bYaICDYVtUfnPtmaAMgUkQMichXAQgA98q3TA8D7pteLAbRTxTwobrAgm2s35q4WFPQMAjVo0Bb336/1OaH3icl8ArE8oToKOH722Y9o3dq14K3t6HP5j9eisRcU1ItlQfODD/40rHmDJyjJmmx6H9NG12TTk9G1qsx27sxBgwZFG8EpP+sb8gG6pFmSjDi2q1fvh6pVC+4jMiwsCRMm/I6wMNeC9+bfhRHHiLkmhN7npqIG78oi841feHgljBixWZc0zeUUvWqy3NqpE26+uaXVb/qZZ94u8qA/JWnw4Bfx8svb3J0NtzDf8JZ0GaVy5bx+a119kKx34L0kylN6fYY5GFbaa7KVBCOai1oOxqMHy9rzzz6rz0AdADB5smsjShaWkb+F/A+r9d7XRqlbtxUefPBN3e4rzOnoO8K7MZVQbjSFCLJFKaW2WExD8iUVB8CyeuER0zy764jIdQBnARTr6annRQYKIX9TJFcLK85/uPo3FzWS+cQRHJxXtVaPAJblSWTJkr/w4IP69CNXUjXZjEm3JGqy6fMZ5gJxQIDeTXKtf0NduvTVPX0jgmytWunXD6IlI2v8zJmTd+E28imcp/G0oLcR+TXXhNH7uzTfUHtSp/dGMZcxWrd+AJGR+nQ9UFLNRT1Bp04DdWkqmV+5csXvkNx47gmyWSr8AF765NXYWvb6PtjIztbaKulfky0v4BEbm6xr2kbRa59aHqt6jSpqFhqadx/Urp3+ZVO9GVmrM39NthxXO7dyO2Mqoui5r/M/oMhfS1Cvmu9lWSFrsp0UkcYW0yw3Zx9AGQ+y5b8JcLUqrKtBNj2bixrpypVLAICQkLyOIL289A2yRUZW1O2my1zAMqImm1FBNk+7qQfy9kVkZEXd0zY/EUtNrY2XX9bvaaGZEUG2Jk306wfRkiceG554Q27JU4KERtZkMwdp9N8XnvWQyUjma56eATG9m4ua6R0EKAlGnYd+/vm4IenqKa92mD7lINdvIJWD187TNiLIYhS9PiNvMCZjarLNmrUH4eGecUNuRE22mTM36JKmWWCgvl2XeLL8fbKFhenfbYVe3nprce5ro1p76Rm8s40PWMcfhg/X97guq3RsLnoUQILF+3jTPLvrKKV8AIQBOFWc/Hve3V8h5K/JFhio7wlE/2Y45uCdvieQixfPAtC/JptRBSHzCc+IArbRQTYjnzoNG6bv6DP//nseABAREaNrukDRRjYsjJIakl4Pnhhk8/RaSp6yz41opmBWlIEPXJHXjM0z9rGRzNcoI4JsejcXi43Vp+PwkmRUIDcwUP/a23rTu7lo0YJsrvHE5qJ6ldWMai6aV2PYc4LjegfZ2rXrhfh4fWoIky1zTbauXZ/Eq6++j27derk5R4516dIb1app/dTrXaYx4v7NWXPRkupGxpPpOfABgJ8AVFVKJSul/AD0BZC/jfdyAOYOlfsAWC3F7KjQs++knLC8UZwxQ3DunL7pe0pNtosXtX88ODivJps+zUWN+f9Loiab3sEwowuFlSolQO82/eano7fckq5ruoBlv03G7Bcj+2TT+7gzuhPnZ5/dg4gIfYOOnl6TzdMKMEb8TozrO818HvKcQV6MYi5jmJuM6ZOmMTXZvLy8MGvWVoSEeE5fTzdybUkj+2Tr1m2ww/X8/JJyXxf2PKpfQNBzarKZf6dGlFcBzwqy6XVNMH83ntN80TNVqaKNVlqxYlX06TMApX3cNqMqopTEwAdUNHqdAkTkulJqOICvAHgDmCMiO5VSEwBsEZHlAN4FME8plQngNLRAXLF41p1IIZl/MB079tM1Xb0LPxYpA9D/BHL1qvHNRfVkbJ9syuqvXl1TLaUAABsOSURBVIysyfbJJ1lYtWp37nu9PiM1tSYObN2Kfv0e1yU9S0bXZDMqyPbaaxfw+utZhqRtlAoV0hAVpe/Ifp5eQPCU/JfEwAdG1WTT+1yXnm5Mn4hGMgejRUp/TTYASEtriNq1b9I9XT1NmjQ997Xev+OaNWvrml737mOt3terp8/gT5b0Ct6YyyiNG9+G0aNnO1yvXLnG8PXVWn24q0+2+Hh9Rva2R/8+2cxBNqMeOntOkE3vmmx6j3ZJ1nr0uBODB6/GLbfc7+6suCQxUeub0N9f35rIxvTJZv1byH8sl8QIyp5O59FFISIZIpImIikiMtE07zlTgA0icllEbheRVBFpIiIHivs/lOmabACwYEEWEhLKYft2/dP2lBu5Hj0eg8hfuOeeEfj9d22e3gMf6Ml88jG2Jpsx1Y2NUK5cGIzqRiK5cmWcyDTiZG9skzKjCrT+/uXg5zkDlxrG02uyeUpTRqOC/oCRAx8YU0u1Y8cn0bhxc/zyyzVd0zWSETXZzA/A9K7J5imGDHkEL730As6fP6n7Pvjmmw24ePKgbun16fMC1qxZgHPn9uOZZ/ahcuVU3dI20+v326ZlS6SkNME997zkdN2wsNo4efJ7FLZmkl7nhLi4BMyffxL9+0chMTFNlzTz07smm1H3A55Uk02vfRoVpQVZa9ZspEt6+YWHRyMr6x/d033ggf8iIqKC7ukaRSmFlJQ2pb4Gm9lbb83HG2+sRqVKybh4Ub90jXjY6axPNrYEcI2nV2Yt80G2cuXCoH/3Qp418EFwcHlMmvSO1cGqT5DNmJOE+cmgkaOLelJNNk8UHa0Vkm699R4354SKwtODbJ7SXNTIs0Xv3vfhk09mo27d9jqnbExNNgCoXv0/+Ef/ex/DmK+jOTl6NhfVmn43aaL39+Y5nn9+Nb7//j2EhkboejyEhoYiNiwFh0/rl6bRN0t6lYNCQkLwwgubEeRSJZDC/caNaN0RGhqJDz7YipgYfWtpm7Emm/702qfJyQ0wY8avaNasFi5d0iVJKwsXHkLVqoLDh/VNd/z415CdDZw/r2+6pAkLC8dNN+nfvY0RDzvznwuDgxORlbXH5jOpYAyy3YCMai6alnYLAKBnz2G6pmuPPs1FtZOE3lV3zbUCjCi0eHIwzJOqzpcvH4OffroCLy/PKSBSHk8PsnlK/s3nISN+2w0b/geffy6636QY1VzUaEbsYyMGPvDx8cP8+XtRuXI8rl7VLVnDfPrpNly5ssf5ioWQmFgHgwdP85AaFuZMGnN9Nqqvr4Lk/Vbc01zUrHr1hobdZHlKTTZ3fP9FpWft5ipV6sKoy7ifX4BhrUPI8xhRprEMOC8cMABfeb+KuXOjdEv/RmBuLurJPOfsXQrpfVEtXz4OCxcKKlYEMjN1TdqGXhfuUaNmISqqlS5pmeU9GTSuuahxI6OWxF2BR9x5wNfXT/cTZPnyEThzRtdqCGSHpzS3dEQpBU+ISXtaoArIay7qKbUFjWREc1EASEioioAAeESQrXr1ekhLq4cffnB3TtzDyEA5oJUz3XUuK+z5yVMebgD6XePeeOMrLFs2y7Bmgp7UXNQTr2dE5jKNnvdW5vLRiBHTcGeKN9buicy/hm6fVVaZRxf1ZAyyFYMn32ToFcDq2fMBHCh214DWqlSphjvvvA9du47UN2FYfmf6nuA8qZaZJ9u4cScuXTyGI0fdnRMi/XjW+cMza7IZkV8jarKRZzIyyGbAGBhOFO1/8aQysV55rV69AWrXfsvAGneeE7j0pO+fyCyvdZrOg0R9/TV+CO4A/DjdZpmnlZ/chTXZbkhGjS5ackpzPw/e3t547bU52L9f/7SN7Gjc9AkGpUsAEBNTEeXDYxhkozLBEwtantpc1Ajmmmx69slGnqVNmwXYu3cSoqJSDEnf29unxINsha+t6nllYk+pre1J51lP2adEltxTpvGc37U7Mch2A/Pkpzae1M+DEfQ+mZZETRTPqu1CRK7zpN82g2xmRjUXJc8RFdUQDRsuNqz/KPcELorWJ5snNRf15PJ7acV9ahyjRlolIK9Mw+O3NGGfbDeosvAkX4+BDzxR3nfneX2yVaxYHQBQt67+o+sQUckzuj8nI5SF659e2FyUjNK+/V1YtWqBWz67Ro0x2LChJ6KiqhdyS885J5T2Wldr1/6Kdet+1DXNJUv2Qyl/XdO0VNr3qafavfs0zp4NxNmz7s5J2ZSTY665W3LnL5afXMMg2w2paE/5SpMbtSZbQEAIBg8eiubN79M13ZK4SY6OTsHbb/+LCxc4LBKRPVFRMTh58ri7s+EyTwyy1avXD8eO/YyYmIQbvtBvvo6yuSjpbcyYDzB27Fu4eLHkPzsurgceekjK9AiMpT0gVKtWXcTE1NW1z+O4uCq4dg2GNT8u7fvUU4WHl8fly+7ORVlW8g8OGWRzrizUZOMZsRg8+UfiSX1n6EkphWnTZqBmzZsMS99I/v5BHn3cERlpxYpfMHPm9+7Ohss8McjWosVIrFx5CZGRxoym50maNv0PAKB9++FuzgmVNT4+PggODnN3Nlzy4INzkZJSFQEBQe7OSiGwHKU/7lPyPKydX3pdv+7aVFoZFmRTSo1TSh1VSm0zTV0tlo1WSmUqpfYopTpZzO9smpeplBplMT9ZKbXZNP9jpZSfUfl2Re/e36Fly0cRGBjuzmwUC08m+vKkm2SisqpChUqoW7e5u7PhMk8Msiml4OcX4O5slAoVK1bEwoWCmjXbuTsrRG7TtOkd2LZtr0fVZGIZWH+e9P0TmeWVvzjwQWlirsnmylRaGd1m8DURmWo5QylVE0BfALUAxAJYpZRKMy1+E0AHAEcA/KSUWi4iuwBMMaW1UCk1E8BgAG8ZnHeHKlSoj4YN/wdeoyk/FtyorJg8eSqSk+u7OxtlGs8XRERUFjDIRp6JzUVLq9IcQHOFOzrm6gFgoYhcAfCHUioTQBPTskwROQAASqmFAHoopX4H0BZAP9M67wMYBzcG2Yjy86SaKFTy5s9fjfj4GHdno1D++9/Hcfo0cOGCu3NyI+D5g4iIPBdHZyRPVL58LACUcCsIBtmcKQt9shkdZBuulBoAYAuAx0XkDIA4AJss1jlimgcAh/PNvxlAJIAsEbluZ30rSqkhAIYAQEJCol7/AxFRsTRr1gZBQcDBg+7OCZUmnthclIiIKD/WZCNPFB9fEy++uAutW6fhuOeMm3VD8PQgW7HOiEqpVUqp3+xMPaDVNEsBUB/AXwCm6ZDfAonILBFpLCKNIyOjjf44olzR0drxVr16QzfnhIg8Rd8+fQAAlStXd3NOiIiIio5N4MhTxcbWgLd3yQ0IyN+KcyKeP/BBsWqyiUh7V9ZTSr0DYIXp7VEACRaL403z4GD+KQDhSikfU202y/WJSoUaNWpiw4ZN8PZuyNpKROSSQQMGoE//+/H77764ds3duSEiujGw9rD+2FyUyFUMsrnihq7JVhClVCWLt70A/GZ6vRxAX6WUv1IqGUBVAD8C+AlAVdNIon7QBkdYLtqV8DsAfUzbDwSwzKh830iGDp2GpKRV7s5GmXHzzTfDx8fX3dkgIg/i68tzBhEReTY2FyVyDWuyOcfRRQv2slKqPrQenQ8CeBAARGSnUmoRgF0ArgMYJiLZAKCUGg7gKwDeAOaIyE5TWk8DWKiUehHALwDeNTDfN4zbbx+J9evdnQsiIiIiImN9+OFyzJ49HRUrJjhfmQqFgQMi0lNpDqC5wrAgm4jcU8CyiQAm2pmfASDDzvwDyBuBtEQ0abIb06eXXPtsIiIiIiIyRp069TFz5lzs2+funBDRjYsBaVd4epCNdXsdCAqqhuTkVHdng4iIiIiIqNTp0eN2d2eBSpFBgwajS5du7s5GqcZan86VheaiDLIRERERERFRocyaNR+nTpxwdzaolJg9ezYWLVru7myUagyyOVcWRhdlkI2IiIjKpOrV6wEAmjZt4eacEBGVPb6+voiIiHB3NoiojPH0mmxGDnxARERE5DaNGrXA4cPHEBJSCTNnujs3REREdGNjTTZXlOYAmisYZCMiIqIyq1KlSrhwwd25ICIiohsdm4s6Z+6TzZMxyEZEREREREREZCgG2VzBIBsREREREREREVExmAc+MJpSKgLAxwCSABwEcIeInLGzXjaAHaa3h0Sku7O0OfABEREREREREZGB2FzUOXNz0RIY+GAUgG9FpCqAb03v7bkkIvVNk9MAG8AgGxERERERERGR7rp3P2TxjkE2V5RQkK0HgPdNr98H0LPYKZowyEZEREREREREpLNy5RJyX7Mmm2sKEWSLUkptsZiGFOJjYkTkL9PrvwHEOFgvwJT2JqWUS4E49slGRERERERERERuVcjRRU+KSGNHC5VSqwBUtLPoGevPFFFKiYNkKovIUaVUFQCrlVI7RGR/QZlikI2IiIiIiIiIyFCsyeYKvUYXFZH2jpYppY4rpSqJyF9KqUoATjhI46jp7wGl1BoADQAUGGRjc1EiIiIiIiIiIgOxuahz5tFFXZmKaTmAgabXAwEsy7+CUqq8Usrf9DoKQHMAu5wlzCAbEREREREREZGhGGRzRQkNfDAZQAel1D4A7U3voZRqrJSabVqnBoAtSqlfAXwHYLKIOA2ysbkoERERERERERG5VSH7ZCvG58gpAO3szN8C4H7T640A6hQ2bQbZiIiIiIiIiIgMxOairimJIJuRGGQjIiIiIiIiIjIQg2zOlVRNNiMxyEZEREREREREZCgG2VzBIBsREREREREREVExmEcX9WQMshERERERERERGYjNRV3DmmxERERERERERFQABtmcKQt9snkVZ2Ol1O1KqZ1KqRylVON8y0YrpTKVUnuUUp0s5nc2zctUSo2ymJ+slNpsmv+xUsrPNN/f9D7TtDypOHkmIiIiIiIiIqLSJyfHtam0KlaQDcBvANIBrLOcqZSqCaAvgFoAOgOYoZTyVkp5A3gTQBcANQHcZVoXAKYAeE1EUgGcATDYNH8wgDOm+a+Z1iMiIiIiIiIi8ghsLuqaGzrIJiK/i8geO4t6AFgoIldE5A8AmQCamKZMETkgIlcBLATQQ2lHW1sAi03bvw+gp0Va75teLwbQTvHoJCIiIiIiIiKPwTCGM+aBD1yZSqvi1mRzJA7AYYv3R0zzHM2PBJAlItfzzbdKy7T8rGl9G0qpIUqpLUqpLadO/aPTv0JEREREREREVHSsK+ScuU82T67J5nTgA6XUKgAV7Sx6RkSW6Z+lohORWQBmAUCDBo3FzdkhIiIiIiIiIiIXleYAmiucBtlEpH0R0j0KIMHifbxpHhzMPwUgXCnlY6qtZrm+Oa0jSikfAGGm9YmIiIiIiIiIPABrsrnC04NsRjUXXQ6gr2lk0GQAVQH8COAnAFVNI4n6QRscYbmICIDvAPQxbT8QwDKLtAaaXvcBsNq0PhERERERERFRqcfmos6VheaixQqyKaV6KaWOAGgG4Aul1FcAICI7ASwCsAvASgDDRCTbVEttOICvAPwOYJFpXQB4GsBIpVQmtD7X3jXNfxdApGn+SACjipNnIiIiIiIiIqKSxCCbazw9yOa0uWhBRGQpgKUOlk0EMNHO/AwAGXbmH4A2+mj++ZcB3F6cfBIRERERERERUellHl3UkxUryEZERERERERERKSH0lxLzRUMshERERERERERkVuZ+2TzZAyyERERERERERGR2zHIRkREREREREREVAysyUZERERERERERKQDBtmIiIiIiIiIiIiKgaOLEhERERERERER6YA12YiIiIiIiIiIiIqBfbIRERERERERERHpgEE2IiIiIiIiIiKiYvL0IJuXuzNAREREREREREQ3NvPAB65MxaGUul0ptVMplaOUalzAep2VUnuUUplKqVGupM0gGxERERERERERuZW5TzZXpmL6DUA6gHWOVlBKeQN4E0AXADUB3KWUquksYTYXJSIiIiIiIiIityuJ5qIi8jsAKKUKWq0JgEwROWBadyGAHgB2FbQRg2xERERERERERORWhRxdNEoptcXi/SwRmaVjduIAHLZ4fwTAzc42YpCNiIiIiIiIiIjcrhBBtpMiUlB/aqsAVLSz6BkRWVaErLmEQTYiIiIiIiIiInI7vZqLikj7YiZxFECCxft407wCMchGRERERERERERuZR5dtJT4CUBVpVQytOBaXwD9nG3E0UWJiIiIiIiIiMitSmp0UaVUL6XUEQDNAHyhlPrKND9WKZWh5UWuAxgO4CsAvwNYJCI7naXNmmxEREREREREROR2JTS66FIAS+3MPwagq8X7DAAZhUmbQTYiIiIiIiIiInK7kgiyGYlBNiIiIiIiIiIicitzc1FPVqw+2ZRStyuldiqlcpRSjS3mJymlLimltpmmmRbLGimldiilMpVSryullGl+hFLqG6XUPtPf8qb5yrReplJqu1KqYXHyTEREREREREREpU9J9MlmpOIOfPAbgHQA6+ws2y8i9U3TQxbz3wLwAICqpqmzaf4oAN+KSFUA35reA0AXi3WHmLYnIiIiIiIiIqIywjy6qCtTaVWsIJuI/C4ie1xdXylVCUCoiGwSEQHwAYCepsU9ALxvev1+vvkfiGYTgHBTOkREREREREREVEbc6DXZCpKslPpFKbVWKdXSNC8OwBGLdY6Y5gFAjIj8ZXr9N4AYi20OO9jGilJqiFJqi1Jqy6lT/+jyTxARERERERERkbHMfbJ5cpDN6cAHSqlVACraWfSMiCxzsNlfABJF5JRSqhGAz5RStVzNlIiIUkpcXd9iu1kAZgFAgwaNC709ERERERERERG5R2kOoLnCaZBNRNoXNlERuQLgiun1VqXUfgBpAI4CiLdYNd40DwCOK6UqichfpuagJ0zzjwJIcLANERERERERERF5uBt+dFFHlFLRSilv0+sq0AYtOGBqDnpOKdXUNKroAADm2nDLAQw0vR6Yb/4A0yijTQGctWhWSkREREREREREZYCnD3zgtCZbQZRSvQC8ASAawBdKqW0i0glAKwATlFLXAOQAeEhETps2exjAewACAXxpmgBgMoBFSqnBAP4EcIdpfgaArgAyAVwEcF9x8kxERERERERERKVLWajJVqwgm4gsBbDUzvwlAJY42GYLgNp25p8C0M7OfAEwrDj5JCIiIiIiIiKi0u2GDrIREREREREREREV1w1fk42IiIiIiIiIiEgPDLIREREREREREREVE4NsRERERERERERExSBSukcOdQWDbERERERERERE5Fbsk42IiIiIiIiIiEgHDLIREREREREREREVE4NsRERERERERERExcDmokRERERERERERDpgkI2IiIiIiIiIiGz4+lbBtWsH3J0Nj1AWRhf1cncGiIiIiIiIiIjKouTkX/H3r7+6OxseIyfHtam0Yk02IiIiIiIiIiIDeHkFIyY62t3Z8Ajsk42IiIiIiIiIiEgHDLIREREREREREREVA2uyERERERERERER6cDTBz5QIuLuPBhCKXUewB5354PITaIAnHR3JojchMc/3ch4/NONjr8BupHx+PdMlUWEnbYBUEqthHYcu+KkiHQ2Mj9FUZaDbFtEpLG780HkDjz+6UbG459uZDz+6UbH3wDdyHj8E7mfl7szQERERERERERE5OkYZCMiIiIiIiIiIiqmshxkm+XuDBC5EY9/upHx+KcbGY9/utHxN0A3Mh7/RG5WZvtkIyIiIiIiIiIiKilluSYbERERERERERFRiWCQjYiIiIiIiIiIqJjKZJBNKdVZKbVHKZWplBrl7vwQGUEpdVAptUMptU0ptcU0L0Ip9Y1Sap/pb3nTfKWUet30m9iulGro3twTFY5Sao5S6oRS6jeLeYU+3pVSA03r71NKDXTH/0JUWA6O/3FKqaOma8A2pVRXi2WjTcf/HqVUJ4v5LB+Rx1FKJaj/b+9+QqwqwziOfx+0WliQEYhZkIQtooWVaFCEm+zPxtqELvpHUAuN2gVtitpIVNCqRSQolCKU5CIqg6BVZUpQKoSU0YgpMVFJUGi/FudMDIN3cOaOc+898/1s7rnvvQzvwHPu770P9z2n6rOqOlJVh6vqmXbcDFDnTVP/ZoA0pDp3TbaqWgR8D9wNjAEHgM1Jjgx0YtIcq6rjwJokv04aewUYT7KtDc+lSZ5rg/dp4H5gHfBGknWDmLc0G1V1F3AG2Jnk5nZsRvVeVVcBXwNrgAAHgduS/DaAf0m6YD3q/0XgTJJXp7z3JmAXsBa4BvgUuLF92fWRRk5VLQeWJzlUVVfQfHY/ADyGGaCOm6b+H8IMkIZSF3/JthY4luSHJP8Au4GNA56TNF82Ajva4x00ITwxvjONL4Ar29CWRkKSz4HxKcMzrfd7gP1JxtsvVfuBey/+7KX+9Kj/XjYCu5P8neRH4BjN2sj1kUZSkpNJDrXHfwJHgRWYAVoApqn/XswAacC62GRbAfw86fkY038QSaMqwCdVdbCqnmzHliU52R7/Aixrjz0v1EUzrXfPA3XN1nY73PaJrXJY/+qwqroeuAX4EjNAC8yU+gczQBpKXWyySQvFnUluBe4DtrTbif6XZi94t/aDSz1Y71qA3gRuAFYDJ4HXBjsd6eKqqsuB94Bnk/wx+TUzQF13nvo3A6Qh1cUm2wnguknPr23HpE5JcqJ9PA3spfkZ+KmJbaDt4+n27Z4X6qKZ1rvngTojyakk55L8C7xFkwFg/auDquoSmgbDO0neb4fNAC0I56t/M0AaXl1ssh0AVlXVyqq6FNgE7BvwnKQ5VVVL2oufUlVLgA3AdzS1PnG3rEeBD9rjfcAj7R23bgd+n7TFQhpVM633j4ENVbW03VaxoR2TRs6U62o+SJMB0NT/pqq6rKpWAquAr3B9pBFVVQW8DRxN8vqkl8wAdV6v+jcDpOG1eNATmGtJzlbVVprQXARsT3J4wNOS5toyYG+TuywG3k3yUVUdAPZU1RPATzR3HgL4kOYuW8eAv4DH53/K0uxV1S5gPXB1VY0BLwDbmEG9JxmvqpdpFpoALyW50IvJSwPTo/7XV9Vqmi1yx4GnAJIcrqo9wBHgLLAlybn277g+0ii6A3gY+LaqvmnHnscM0MLQq/43mwHScKrmEgaSJEmSJEmSZquL20UlSZIkSZKkeWWTTZIkSZIkSeqTTTZJkiRJkiSpTzbZJEmSJEmSpD7ZZJMkSZIkSZL6ZJNNkiRJkiRJ6pNNNkmSJEmSJKlP/wFXKWxXevROsQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "model = clinical_model\n", + "layer_name = \"conv1d_253\"\n", + "num_data = 5\n", + "\n", + "for example in val_data[:num_data]:\n", + " exp = grad_cam(layer_name, np.expand_dims(example,0), model)\n", + " idx = 0\n", + " for i,j in enumerate(reversed(example)):\n", + " if not j == 0:\n", + " idx = i\n", + " break\n", + " plt.figure(figsize=(24,4))\n", + " plt.imshow(exp,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", + " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", + " plt.plot(example,'k') \n", + " plt.xlim(0,len(example[:-idx]))\n", + " plt.colorbar()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "uNajgjR8Zmec", + "outputId": "c53e6718-44df-4003-af69-c973a676cb4a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################################\n", + "#################################################\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################################\n", + "#################################################\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################################\n", + "#################################################\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################################\n", + "#################################################\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#################################################\n", + "#################################################\n" + ] + } + ], + "source": [ + "\n", + "layer_name_murmur = \"conv1d_311\"\n", + "\n", + "layer_name_clinical = \"conv1d_253\"\n", + "num_data = 5\n", + " \n", + "for example in val_data[:num_data]:\n", + " exp_clinical = grad_cam(layer_name_clinical, np.expand_dims(example,0), clinical_model)\n", + " exp_murmur = grad_cam(layer_name_murmur, np.expand_dims(example,0), murmur_model)\n", + " idx = 0\n", + " for i,j in enumerate(reversed(example)):\n", + " if not j == 0:\n", + " idx = i\n", + " break\n", + " plt.figure(figsize=(24,4))\n", + " plt.title(\"Interpreted by outcome model\")\n", + " plt.imshow(exp_clinical,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", + " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", + " plt.plot(example,'k') \n", + " plt.xlim(0,len(example[:-idx]))\n", + " plt.colorbar()\n", + " plt.show()\n", + "\n", + " plt.figure(figsize=(24,4))\n", + " plt.title(\"Interpreted by murmur model\")\n", + " plt.imshow(exp_murmur,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", + " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", + " plt.plot(example,'k') \n", + " plt.xlim(0,len(example[:-idx]))\n", + " plt.colorbar()\n", + " plt.show()\n", + " print(\"#################################################\")\n", + " print(\"#################################################\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5Pc_vnj1HBkl", + "outputId": "033cee4e-657f-4a50-8dd0-8e8ff4020974" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finding data files...\n", + "Extracting features and labels from the Challenge data...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/942 [00:00 Date: Mon, 19 Sep 2022 14:03:47 +0200 Subject: [PATCH 02/51] updated notebook --- PTB_XL_experiments.ipynb | 429 +++- run_experiments_in_colab.ipynb | 3490 -------------------------------- 2 files changed, 366 insertions(+), 3553 deletions(-) delete mode 100644 run_experiments_in_colab.ipynb diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb index 99f9dc4..31abeea 100644 --- a/PTB_XL_experiments.ipynb +++ b/PTB_XL_experiments.ipynb @@ -2,14 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", - "outputId": "6f8b3e9c-ccd1-4d94-9edd-03621f2f1d83" + "outputId": "1f063c50-8a54-43bd-ae08-f4ac35625188" }, "outputs": [ { @@ -17,12 +17,36 @@ "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wget in /usr/local/lib/python3.7/dist-packages (3.2)\n" + "Requirement already satisfied: wget in /usr/local/lib/python3.7/dist-packages (3.2)\n", + "Collecting wfdb\n", + " Downloading wfdb-4.0.0-py3-none-any.whl (161 kB)\n", + "\u001b[K |████████████████████████████████| 161 kB 34.3 MB/s \n", + "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", + "Installing collected packages: wfdb\n", + "Successfully installed wfdb-4.0.0\n" ] } ], "source": [ - "!pip install wget" + "!pip install wget wfdb" ] }, { @@ -64,40 +88,28 @@ "id": "T0cGBrFsdJFb", "metadata": { "colab": { - "base_uri": "https://localhost:8080/", - "height": 445 + "base_uri": "https://localhost:8080/" }, "id": "T0cGBrFsdJFb", - "outputId": "2d48ff89-f4b5-4cf4-e110-a9163ab59f9f" + "outputId": "8c082799-0e73-4194-967f-e713c67eb0f3" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2022-08-28 09:36:19-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2022-09-19 09:55:46-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", - "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip.2’\n", + "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 11.6MB/s in 2m 26s \n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 11.9MB/s in 2m 30s \n", "\n", - "2022-08-28 09:38:46 (12.1 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip.2’ saved [1842722380/1842722380]\n", + "2022-09-19 09:58:18 (11.7 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", "\n" ] - }, - { - "output_type": "error", - "ename": "FileExistsError", - "evalue": "ignored", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileExistsError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./data/\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFileExistsError\u001b[0m: [Errno 17] File exists: './data/'" - ] } ], "source": [ @@ -112,7 +124,83 @@ }, { "cell_type": "code", + "source": [ + "!pip install GitPython\n", + "from git import Repo" + ], + "metadata": { + "id": "V-j1oLL4Li10", + "outputId": "85592370-6f11-4ac1-c768-53ae41bc148c", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "V-j1oLL4Li10", "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting GitPython\n", + " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", + "\u001b[K |████████████████████████████████| 181 kB 26.6 MB/s \n", + "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", + "\u001b[K |████████████████████████████████| 63 kB 1.9 MB/s \n", + "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", + "Collecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Installing collected packages: smmap, gitdb, GitPython\n", + "Successfully installed GitPython-3.1.27 gitdb-4.0.9 smmap-5.0.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", + "DEST_NAME = 'github_repo'" + ], + "metadata": { + "id": "aLEwloYTLpue" + }, + "id": "aLEwloYTLpue", + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" + ], + "metadata": { + "id": "wrApvEoJLPYq", + "outputId": "01270847-76dd-4744-8ead-e7695e6b7d37", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "wrApvEoJLPYq", + "execution_count": 7, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", "metadata": { "colab": { @@ -147,7 +235,222 @@ }, { "cell_type": "code", - "execution_count": 6, + "source": [ + "!pip install fastai==1.0.61" + ], + "metadata": { + "id": "fRteqX8GY5Nw", + "outputId": "ca36248d-cc59-41e8-a52d-ef34882725d9", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + } + }, + "id": "fRteqX8GY5Nw", + "execution_count": 101, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting fastai==1.0.61\n", + " Using cached fastai-1.0.61-py3-none-any.whl (239 kB)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", + "Requirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.0)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.7.3)\n", + "Requirement already satisfied: nvidia-ml-py3 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (7.352.0)\n", + "Requirement already satisfied: numexpr in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.8.3)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (0.13.1+cu113)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (6.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.23.0)\n", + "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.12.1+cu113)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (21.3)\n", + "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.21.6)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.2.2)\n", + "Requirement already satisfied: spacy>=2.0.18 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.4.1)\n", + "Requirement already satisfied: bottleneck in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", + "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (7.1.2)\n", + "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", + "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (8.1.0)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", + "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", + "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.9 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.10)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.11.3)\n", + "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", + "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", + "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.64.1)\n", + "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", + "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.6)\n", + "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", + "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", + "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", + "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.8)\n", + "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from catalogue<2.1.0,>=2.0.6->spacy>=2.0.18->fastai==1.0.61) (3.8.1)\n", + "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->fastai==1.0.61) (3.0.9)\n", + "Requirement already satisfied: smart-open<6.0.0,>=5.2.1 in /usr/local/lib/python3.7/dist-packages (from pathy>=0.3.5->spacy>=2.0.18->fastai==1.0.61) (5.2.1)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2022.6.15)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (1.25.11)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (3.0.4)\n", + "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /usr/local/lib/python3.7/dist-packages (from thinc<8.2.0,>=8.1.0->spacy>=2.0.18->fastai==1.0.61) (0.7.8)\n", + "Requirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.7/dist-packages (from typer<0.5.0,>=0.3.0->spacy>=2.0.18->fastai==1.0.61) (7.1.2)\n", + "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->spacy>=2.0.18->fastai==1.0.61) (2.0.1)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->fastai==1.0.61) (1.15.0)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->fastai==1.0.61) (2022.2.1)\n", + "Installing collected packages: fastai\n", + " Attempting uninstall: fastai\n", + " Found existing installation: fastai 2.7.9\n", + " Uninstalling fastai-2.7.9:\n", + " Successfully uninstalled fastai-2.7.9\n", + "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", + "fastbook 0.0.28 requires fastai>=2.6, but you have fastai 1.0.61 which is incompatible.\u001b[0m\n", + "Successfully installed fastai-1.0.61\n" + ] + }, + { + "output_type": "display_data", + "data": { + "application/vnd.colab-display-data+json": { + "pip_warning": { + "packages": [ + "fastai" + ] + } + } + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install fastprogress" + ], + "metadata": { + "id": "goTGyvV2fbtK", + "outputId": "eb453683-169e-478a-8cc0-3d095e4cdd16", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "goTGyvV2fbtK", + "execution_count": 94, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: fastprogress in /usr/local/lib/python3.7/dist-packages (1.0.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from fastprogress) (1.21.6)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install -r requirements.txt" + ], + "metadata": { + "id": "XYPnyQaRcBP1", + "outputId": "01092444-0ea3-45ca-8126-d224259c02f5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "XYPnyQaRcBP1", + "execution_count": 93, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "\u001b[31mERROR: Could not find a version that satisfies the requirement lame==3.100 (from versions: none)\u001b[0m\n", + "\u001b[31mERROR: No matching distribution found for lame==3.100\u001b[0m\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import fastai" + ], + "metadata": { + "id": "trF1gPYQY_lC" + }, + "id": "trF1gPYQY_lC", + "execution_count": 102, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from github_repo.code import *\n" + ], + "metadata": { + "id": "IpjW6eVLMGJQ" + }, + "id": "IpjW6eVLMGJQ", + "execution_count": 109, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "!python /content/github_repo/code/reproduce_results.py" + ], + "metadata": { + "id": "48KVqw_QMq2H", + "outputId": "d3540340-36f7-4788-dca0-68312cf6be14", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "id": "48KVqw_QMq2H", + "execution_count": 111, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "tcmalloc: large alloc 2096357376 bytes == 0x4c8a000 @ 0x7fce324b81e7 0x4b2150 0x5ac2ec 0x5e3d6d 0x58ee7f 0x590c9f 0x591039 0x4fb96a 0x4fc108 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6\n", + "tcmalloc: large alloc 2096357376 bytes == 0x81bc8000 @ 0x7fce324b81e7 0x4b2150 0x5ac2ec 0x4fc11a 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fce320b5c87 0x5b561a\n", + "tcmalloc: large alloc 2096357376 bytes == 0x4c8a000 @ 0x7fce324b81e7 0x7fce2fdc90ce 0x7fce2fe1fcf5 0x7fce2fe1fe08 0x7fce2feb20b9 0x7fce2feb4a25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fce320b5c87 0x5b561a\n", + "tcmalloc: large alloc 1674338304 bytes == 0xffc34000 @ 0x7fce324b81e7 0x7fce2fdc90ce 0x7fce2fe1fcf5 0x7fce2fe1fe08 0x7fce2feb20b9 0x7fce2feb4a25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fce320b5c87 0x5b561a\n", + "Traceback (most recent call last):\n", + " File \"/content/github_repo/code/reproduce_results.py\", line 61, in \n", + " main()\n", + " File \"/content/github_repo/code/reproduce_results.py\", line 42, in main\n", + " e.perform()\n", + " File \"/content/github_repo/code/experiments/scp_experiment.py\", line 101, in perform\n", + " from models.fastai_model import fastai_model\n", + " File \"/content/github_repo/code/models/fastai_model.py\", line 14, in \n", + " from models.resnet1d import resnet1d18,resnet1d34,resnet1d50,resnet1d101,resnet1d152,resnet1d_wang,resnet1d,wrn1d_22\n", + " File \"/content/github_repo/code/models/resnet1d.py\", line 7, in \n", + " from models.basic_conv1d import create_head1d\n", + " File \"/content/github_repo/code/models/basic_conv1d.py\", line 47, in \n", + " class AdaptiveConcatPool1d(nn.Module):\n", + " File \"/content/github_repo/code/models/basic_conv1d.py\", line 49, in AdaptiveConcatPool1d\n", + " def __init__(self, sz:Optional[int]=None):\n", + "NameError: name 'Optional' is not defined\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "1986c1d6-8c33-4e71-bd39-31c25cd57af6", "metadata": { "id": "1986c1d6-8c33-4e71-bd39-31c25cd57af6" @@ -162,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "9565781f-afb0-4649-b3a3-8e39dd598ae2", "metadata": { "colab": { @@ -207,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "c0514023-5537-4297-8865-b28ab6bf8581", "metadata": { "id": "c0514023-5537-4297-8865-b28ab6bf8581" @@ -660,7 +963,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "c4167b83-41cb-4a0a-aa4e-7a8a8790c021", "metadata": { "colab": { @@ -685,7 +988,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "2507b016-ab63-4263-9e34-6f52346dd468", "metadata": { "id": "2507b016-ab63-4263-9e34-6f52346dd468" @@ -697,7 +1000,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "84e05e6c-b826-4638-b950-d78889afa4e0", "metadata": { "id": "84e05e6c-b826-4638-b950-d78889afa4e0" @@ -710,7 +1013,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "95bc3349-5f35-4848-b1ad-ba57cce241c2", "metadata": { "id": "95bc3349-5f35-4848-b1ad-ba57cce241c2" @@ -737,7 +1040,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "58e05225-a5c1-48d0-9bfa-d412d5cbb9e9", "metadata": { "id": "58e05225-a5c1-48d0-9bfa-d412d5cbb9e9" @@ -755,7 +1058,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "14463a7d-5f9a-41b7-8dfe-bc120d0789da", "metadata": { "id": "14463a7d-5f9a-41b7-8dfe-bc120d0789da" @@ -773,7 +1076,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "f6f0c951-3995-419e-aa4a-d481dfeed7a3", "metadata": { "id": "f6f0c951-3995-419e-aa4a-d481dfeed7a3", @@ -789,7 +1092,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "b36fa309-6407-48b4-8dec-8377f3a59d84", "metadata": { "id": "b36fa309-6407-48b4-8dec-8377f3a59d84" @@ -801,7 +1104,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "6d733dc3-cf06-4429-8cc1-ade1866be56b", "metadata": { "id": "6d733dc3-cf06-4429-8cc1-ade1866be56b" @@ -816,7 +1119,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "8f6b6f0c-2246-4b01-8a9c-91ef2f739028", "metadata": { "colab": { @@ -847,7 +1150,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "43b4d221-2d87-44b9-9cb5-6b177a064dbd", "metadata": { "id": "43b4d221-2d87-44b9-9cb5-6b177a064dbd" @@ -859,7 +1162,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "9ac0d7b0-ab44-4306-ae1d-e6d7c9671c48", "metadata": { "colab": { @@ -900,7 +1203,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": null, "id": "3883b0d8-0d1f-4df7-aab0-3b177f728f1b", "metadata": { "colab": { @@ -927,7 +1230,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": null, "id": "42dde4c5-103e-4d1a-a4a5-6f8a288c025d", "metadata": { "colab": { @@ -954,7 +1257,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": null, "id": "4ccb2263-9522-4507-bf30-a53cb62a629c", "metadata": { "id": "4ccb2263-9522-4507-bf30-a53cb62a629c" @@ -966,7 +1269,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": null, "id": "c81e5f46-3c29-4869-97b6-8431c457f81c", "metadata": { "id": "c81e5f46-3c29-4869-97b6-8431c457f81c" @@ -978,7 +1281,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": null, "id": "3fcf47ba-3c66-4068-bb19-076f5edb9fff", "metadata": { "id": "3fcf47ba-3c66-4068-bb19-076f5edb9fff" @@ -997,7 +1300,7 @@ "id": "uKN4Lx0y4PYc" }, "id": "uKN4Lx0y4PYc", - "execution_count": 26, + "execution_count": null, "outputs": [] }, { @@ -1010,12 +1313,12 @@ "id": "COAefnPG4XM9" }, "id": "COAefnPG4XM9", - "execution_count": 27, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 76, + "execution_count": null, "id": "f51c4ea1-5024-4e12-bacc-ae66213fa316", "metadata": { "id": "f51c4ea1-5024-4e12-bacc-ae66213fa316" @@ -1027,7 +1330,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": null, "id": "c9dd1cf6-eb6b-4783-ba2e-6731c48637d6", "metadata": { "id": "c9dd1cf6-eb6b-4783-ba2e-6731c48637d6" @@ -1039,7 +1342,7 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": null, "id": "f13e051c-4edb-4dc1-a285-87a79473c045", "metadata": { "id": "f13e051c-4edb-4dc1-a285-87a79473c045" @@ -1052,7 +1355,7 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": null, "id": "7c37f38e-ae7b-4d5c-83f9-46dfa1cf2083", "metadata": { "id": "7c37f38e-ae7b-4d5c-83f9-46dfa1cf2083" @@ -1064,7 +1367,7 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": null, "id": "4102c5e9-6d74-4f5a-901f-51624bdb3219", "metadata": { "colab": { @@ -1092,7 +1395,7 @@ }, { "cell_type": "code", - "execution_count": 81, + "execution_count": null, "id": "b5faf7a9-8036-41b0-9414-8c48b617e402", "metadata": { "id": "b5faf7a9-8036-41b0-9414-8c48b617e402" @@ -1272,7 +1575,7 @@ "id": "sLVXZL7SgkOJ" }, "id": "sLVXZL7SgkOJ", - "execution_count": 89, + "execution_count": null, "outputs": [] }, { @@ -1285,12 +1588,12 @@ "id": "QEO-kyIs3A2z" }, "id": "QEO-kyIs3A2z", - "execution_count": 85, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "2a8d7913-4ba1-483d-b5d5-f3cb7b16a433", "metadata": { "id": "2a8d7913-4ba1-483d-b5d5-f3cb7b16a433" @@ -1310,7 +1613,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "id": "8782a0a1-63d1-4bae-9bfb-b06b3439ed60", "metadata": { "colab": { @@ -1334,7 +1637,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "id": "7de5a8ea-fc2b-4d25-822d-7cd1d3b579e0", "metadata": { "id": "7de5a8ea-fc2b-4d25-822d-7cd1d3b579e0" @@ -1376,7 +1679,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "id": "1f76d05e-fc5e-450f-b56e-ca2634d47a4a", "metadata": { "id": "1f76d05e-fc5e-450f-b56e-ca2634d47a4a" @@ -1407,12 +1710,12 @@ "id": "IjwhZio6Azxl" }, "id": "IjwhZio6Azxl", - "execution_count": 39, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 69, + "execution_count": null, "id": "173a2565-c5d4-41e8-a422-cedd293f2c1b", "metadata": { "colab": { @@ -1550,7 +1853,7 @@ "id": "XEoxcIU7KrqU" }, "id": "XEoxcIU7KrqU", - "execution_count": 138, + "execution_count": null, "outputs": [] }, { @@ -1568,7 +1871,7 @@ } }, "id": "JZv28B--LxD3", - "execution_count": 139, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1656,7 +1959,7 @@ "id": "GR7LtK8uM6uv" }, "id": "GR7LtK8uM6uv", - "execution_count": 72, + "execution_count": null, "outputs": [] }, { @@ -1674,7 +1977,7 @@ } }, "id": "sawQr7PPM_Um", - "execution_count": 73, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -1713,7 +2016,7 @@ } }, "id": "tvxhRKAF54kU", - "execution_count": 70, + "execution_count": null, "outputs": [ { "output_type": "stream", diff --git a/run_experiments_in_colab.ipynb b/run_experiments_in_colab.ipynb deleted file mode 100644 index 396550d..0000000 --- a/run_experiments_in_colab.ipynb +++ /dev/null @@ -1,3490 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "GRmi1FbhCDW0", - "outputId": "558dcb43-c029-4188-a28d-df1c660fd35a" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting GitPython\n", - " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", - "\u001b[K |████████████████████████████████| 181 kB 5.1 MB/s \n", - "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", - "Collecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", - "\u001b[K |████████████████████████████████| 63 kB 1.8 MB/s \n", - "\u001b[?25hCollecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Installing collected packages: smmap, gitdb, GitPython\n", - "Successfully installed GitPython-3.1.27 gitdb-4.0.9 smmap-5.0.0\n" - ] - } - ], - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "SdNtLojfCO2W" - }, - "outputs": [], - "source": [ - "access_token = \"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\"" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "BQL6lPD0CVgh" - }, - "outputs": [], - "source": [ - "HTTPS_REMOTE_URL = 'https://' + access_token + ':x-oauth-basic@github.com/Bsingstad/Heart-murmur-detection-2022-private'\n", - "DEST_NAME = 'heart_murmurs'\n", - "cloned_repo = Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "FBMgQeTjCkuf", - "outputId": "8bcd7a5d-3ccc-4d3d-8d18-10582d400ce4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting wget\n", - " Downloading wget-3.2.zip (10 kB)\n", - "Building wheels for collected packages: wget\n", - " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=edc1e747f83f30e3437bfd478b4f4acdfd92ff3786219f60cb63f01b300cd2a3\n", - " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", - "Successfully built wget\n", - "Installing collected packages: wget\n", - "Successfully installed wget-3.2\n" - ] - } - ], - "source": [ - "!pip install wget" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "bQuh1VhrC39v", - "outputId": "7fd17e03-5de0-4ed3-fc92-aabea959c7b8" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "kaggle.json\n", - "/bin/bash: -c: line 0: unexpected EOF while looking for matching `''\n", - "/bin/bash: -c: line 1: syntax error: unexpected end of file\n" - ] - } - ], - "source": [ - "!mkdir -p ~/.kaggle\n", - "!cp kaggle.json ~/.kaggle/\n", - "!ls ~/.kaggle\n", - "!chmod 600 /root/.kaggle/kaggle.json'" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "sW10TQKSC1MW", - "outputId": "c8396f9f-98d6-43e6-af61-0be5bf078d5f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /root/.kaggle/kaggle.json'\n", - "Downloading the-circor-digiscope-phonocardiogram-dataset-v2.zip to /content\n", - " 98% 441M/449M [00:04<00:00, 84.2MB/s]\n", - "100% 449M/449M [00:05<00:00, 93.6MB/s]\n" - ] - } - ], - "source": [ - "!kaggle datasets download -d bjoernjostein/the-circor-digiscope-phonocardiogram-dataset-v2" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "uiitcpLxDBWm" - }, - "outputs": [], - "source": [ - "import os, zipfile\n", - "try:\n", - " os.mkdir(\"/content/data/\")\n", - "except:\n", - " print(\"data folder allready exists\")" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "nKKUjHdSQqym" - }, - "outputs": [], - "source": [ - "import os, zipfile\n", - "\n", - "dir_name = \"/content/\"\n", - "target_dir = \"/content/data/\"\n", - "extension = \".zip\"\n", - " \n", - "os.chdir(dir_name) # change directory from working dir to dir with files\n", - "\n", - "for item in os.listdir(dir_name): # loop through items in dir\n", - " if item.endswith(extension): # check for \".zip\" extension\n", - " file_name = os.path.abspath(item) # get full path of files\n", - " zip_ref = zipfile.ZipFile(file_name) # create zipfile object\n", - " zip_ref.extractall(target_dir) # extract file to dir\n", - " zip_ref.close() # close file\n", - " os.remove(file_name) # delete zipped file" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "CWiDsltwE-rg" - }, - "outputs": [], - "source": [ - "os.mknod(\"/content/heart_murmurs/__init__.py\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "H4vxg6fhmoLP" - }, - "outputs": [], - "source": [ - "def replace_line(file_name, line_num, text):\n", - " lines = open(file_name, 'r').readlines()\n", - " lines[line_num] = text\n", - " out = open(file_name, 'w')\n", - " out.writelines(lines)\n", - " out.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "5QunscIlmr3y" - }, - "outputs": [], - "source": [ - "replace_line('/content/heart_murmurs/run_model.py',12,\"from .helper_code import * \\n\")\n", - "replace_line('/content/heart_murmurs/run_model.py',13,\"from .team_code import load_challenge_model, run_challenge_model \\n\")\n", - "replace_line('/content/heart_murmurs/cross_validate.py',15,\"from .helper_code import * \\n\")\n", - "replace_line('/content/heart_murmurs/evaluate_model.py',16,\"from .helper_code import load_patient_data, get_murmur, get_outcome, load_challenge_outputs, compare_strings \\n\")\n", - "replace_line('/content/heart_murmurs/cross_validate.py',16,\"from .team_code import base_model, load_challenge_model, build_murmur_model, build_clinical_model, scheduler, scheduler_2, get_murmur_locations, pad_array, calculating_class_weights \\n\")\n", - "replace_line('/content/heart_murmurs/team_code.py',11,\"from .helper_code import * \\n\")\n", - "replace_line('/content/heart_murmurs/train_model.py',11,\"from .helper_code import is_integer \\n\")\n", - "replace_line('/content/heart_murmurs/train_model.py',12,\"from .team_code import train_challenge_model \\n\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "id": "1o9J_FbaGCxu" - }, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload\n", - "%reload_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "eVbI2ZbZDyWA" - }, - "outputs": [], - "source": [ - "from heart_murmurs.helper_code import *\n", - "\n", - "# have to add a \".\" in from of the module imports (in the scrips:train_model, run_model and team_code )\n", - "from heart_murmurs.train_model import *\n", - "from heart_murmurs.run_model import *\n", - "from heart_murmurs.team_code import *\n", - "from heart_murmurs.evaluate_model import *\n", - "from heart_murmurs.cross_validate import *" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "id": "dST5oXOMKdtX" - }, - "outputs": [], - "source": [ - "try:\n", - " os.mkdir(\"/content/models/\")\n", - "except:\n", - " print(\"model folder allreadu exists\")" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "id": "AxvEca5vsn53" - }, - "outputs": [], - "source": [ - "try:\n", - " os.mkdir(\"/content/results/\")\n", - "except:\n", - " print(\"results folder allreadu exists\")" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": { - "id": "Q50bbXJ6jory" - }, - "outputs": [], - "source": [ - "FOLDS = 5" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3r7SoYdFslCZ", - "outputId": "365354a9-147a-4a82-c8a4-c969f91b5374" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 942/942 [00:00<00:00, 3230.05it/s]\n", - "100%|██████████| 628/628 [00:12<00:00, 51.97it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of signals in training data = 2156\n", - "Murmurs prevalence:\n", - "Present = 387, Unknown = 117, Absent = 1652\n", - "Outcomes prevalence:\n", - "Abnormal = 1039, Normal = 1117\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 314/314 [00:07<00:00, 39.59it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of signals in validation data = 1007\n", - "Murmurs prevalence:\n", - "Present = 229, Unknown = 39, Absent = 739\n", - "Outcomes prevalence:\n", - "Abnormal = 492, Normal = 515\n", - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train murmur model..\n", - "Epoch 1/25\n", - " 6/108 [>.............................] - ETA: 36s - loss: 1.4830 - categorical_accuracy: 0.7417 - auc_7: 0.8171WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1604s vs `on_train_batch_end` time: 0.1611s). Check your callbacks.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1604s vs `on_train_batch_end` time: 0.1611s). Check your callbacks.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "108/108 [==============================] - 51s 403ms/step - loss: 1.6262 - categorical_accuracy: 0.3660 - auc_7: 0.5727 - val_loss: 2.9565 - val_categorical_accuracy: 0.0497 - val_auc_7: 0.2538 - lr: 0.0010\n", - "Epoch 2/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.5068 - categorical_accuracy: 0.3590 - auc_7: 0.5908 - val_loss: 2.8850 - val_categorical_accuracy: 0.2284 - val_auc_7: 0.5457 - lr: 0.0010\n", - "Epoch 3/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.4657 - categorical_accuracy: 0.3738 - auc_7: 0.6130 - val_loss: 1.5429 - val_categorical_accuracy: 0.2105 - val_auc_7: 0.4581 - lr: 0.0010\n", - "Epoch 4/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.4445 - categorical_accuracy: 0.3465 - auc_7: 0.6043 - val_loss: 2.1160 - val_categorical_accuracy: 0.2175 - val_auc_7: 0.4308 - lr: 0.0010\n", - "Epoch 5/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.4504 - categorical_accuracy: 0.3724 - auc_7: 0.6230 - val_loss: 1.5270 - val_categorical_accuracy: 0.2254 - val_auc_7: 0.5707 - lr: 0.0010\n", - "Epoch 6/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.4461 - categorical_accuracy: 0.3780 - auc_7: 0.6280 - val_loss: 1.0965 - val_categorical_accuracy: 0.3644 - val_auc_7: 0.5888 - lr: 0.0010\n", - "Epoch 7/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.3835 - categorical_accuracy: 0.3970 - auc_7: 0.6477 - val_loss: 1.0574 - val_categorical_accuracy: 0.3307 - val_auc_7: 0.6113 - lr: 0.0010\n", - "Epoch 8/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.4098 - categorical_accuracy: 0.3975 - auc_7: 0.6342 - val_loss: 0.8962 - val_categorical_accuracy: 0.5770 - val_auc_7: 0.7556 - lr: 0.0010\n", - "Epoch 9/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 1.4223 - categorical_accuracy: 0.3641 - auc_7: 0.6296 - val_loss: 1.4460 - val_categorical_accuracy: 0.3555 - val_auc_7: 0.5726 - lr: 0.0010\n", - "Epoch 10/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 1.4148 - categorical_accuracy: 0.4003 - auc_7: 0.6378 - val_loss: 0.6591 - val_categorical_accuracy: 0.7219 - val_auc_7: 0.8664 - lr: 0.0010\n", - "Epoch 11/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.3702 - categorical_accuracy: 0.3966 - auc_7: 0.6429 - val_loss: 1.0389 - val_categorical_accuracy: 0.4826 - val_auc_7: 0.6712 - lr: 1.0000e-04\n", - "Epoch 12/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.3053 - categorical_accuracy: 0.4365 - auc_7: 0.6774 - val_loss: 1.0658 - val_categorical_accuracy: 0.4359 - val_auc_7: 0.6399 - lr: 1.0000e-04\n", - "Epoch 13/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.3054 - categorical_accuracy: 0.4332 - auc_7: 0.6760 - val_loss: 0.8949 - val_categorical_accuracy: 0.5720 - val_auc_7: 0.7495 - lr: 1.0000e-04\n", - "Epoch 14/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 1.2929 - categorical_accuracy: 0.4559 - auc_7: 0.6893 - val_loss: 0.9381 - val_categorical_accuracy: 0.5571 - val_auc_7: 0.7288 - lr: 1.0000e-04\n", - "Epoch 15/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 1.2780 - categorical_accuracy: 0.4494 - auc_7: 0.6880 - val_loss: 0.9859 - val_categorical_accuracy: 0.5084 - val_auc_7: 0.7010 - lr: 1.0000e-04\n", - "Epoch 16/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.2644 - categorical_accuracy: 0.4754 - auc_7: 0.7023 - val_loss: 0.9688 - val_categorical_accuracy: 0.5333 - val_auc_7: 0.7155 - lr: 1.0000e-05\n", - "Epoch 17/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.2584 - categorical_accuracy: 0.4842 - auc_7: 0.7121 - val_loss: 0.9519 - val_categorical_accuracy: 0.5472 - val_auc_7: 0.7266 - lr: 1.0000e-05\n", - "Epoch 18/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.2561 - categorical_accuracy: 0.4814 - auc_7: 0.7059 - val_loss: 0.9621 - val_categorical_accuracy: 0.5402 - val_auc_7: 0.7181 - lr: 1.0000e-05\n", - "Epoch 19/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.2434 - categorical_accuracy: 0.4745 - auc_7: 0.7107 - val_loss: 0.9222 - val_categorical_accuracy: 0.5591 - val_auc_7: 0.7424 - lr: 1.0000e-05\n", - "Epoch 20/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.2422 - categorical_accuracy: 0.4638 - auc_7: 0.7061 - val_loss: 0.9263 - val_categorical_accuracy: 0.5571 - val_auc_7: 0.7394 - lr: 1.0000e-05\n", - "Epoch 21/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 1.2430 - categorical_accuracy: 0.4754 - auc_7: 0.7060 - val_loss: 0.9270 - val_categorical_accuracy: 0.5571 - val_auc_7: 0.7392 - lr: 1.0000e-06\n", - "Epoch 22/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 1.2540 - categorical_accuracy: 0.4722 - auc_7: 0.7085 - val_loss: 0.9381 - val_categorical_accuracy: 0.5531 - val_auc_7: 0.7342 - lr: 1.0000e-06\n", - "Epoch 23/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 1.2484 - categorical_accuracy: 0.4754 - auc_7: 0.7080 - val_loss: 0.9323 - val_categorical_accuracy: 0.5541 - val_auc_7: 0.7374 - lr: 1.0000e-06\n", - "Epoch 24/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 1.2555 - categorical_accuracy: 0.4680 - auc_7: 0.7057 - val_loss: 0.9325 - val_categorical_accuracy: 0.5551 - val_auc_7: 0.7372 - lr: 1.0000e-06\n", - "Epoch 25/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 1.2460 - categorical_accuracy: 0.4685 - auc_7: 0.7069 - val_loss: 0.9290 - val_categorical_accuracy: 0.5531 - val_auc_7: 0.7378 - lr: 1.0000e-06\n", - "Train clinical model..\n", - "Epoch 1/25\n", - "108/108 [==============================] - 52s 408ms/step - loss: 0.6729 - binary_accuracy: 0.5297 - auc_6: 0.5388 - val_loss: 0.7240 - val_binary_accuracy: 0.4836 - val_auc_6: 0.5877 - lr: 0.0010\n", - "Epoch 2/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6669 - binary_accuracy: 0.5306 - auc_6: 0.5298 - val_loss: 0.6951 - val_binary_accuracy: 0.5382 - val_auc_6: 0.5979 - lr: 0.0010\n", - "Epoch 3/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6659 - binary_accuracy: 0.5325 - auc_6: 0.5443 - val_loss: 0.7135 - val_binary_accuracy: 0.5055 - val_auc_6: 0.3981 - lr: 0.0010\n", - "Epoch 4/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6634 - binary_accuracy: 0.5529 - auc_6: 0.5556 - val_loss: 0.7236 - val_binary_accuracy: 0.5313 - val_auc_6: 0.5772 - lr: 0.0010\n", - "Epoch 5/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6636 - binary_accuracy: 0.5413 - auc_6: 0.5512 - val_loss: 0.6917 - val_binary_accuracy: 0.5571 - val_auc_6: 0.5819 - lr: 0.0010\n", - "Epoch 6/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6668 - binary_accuracy: 0.5278 - auc_6: 0.5337 - val_loss: 0.9372 - val_binary_accuracy: 0.4886 - val_auc_6: 0.5862 - lr: 0.0010\n", - "Epoch 7/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6634 - binary_accuracy: 0.5422 - auc_6: 0.5481 - val_loss: 1.1713 - val_binary_accuracy: 0.5015 - val_auc_6: 0.4050 - lr: 0.0010\n", - "Epoch 8/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6605 - binary_accuracy: 0.5501 - auc_6: 0.5692 - val_loss: 0.7502 - val_binary_accuracy: 0.5074 - val_auc_6: 0.5920 - lr: 0.0010\n", - "Epoch 9/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6550 - binary_accuracy: 0.5659 - auc_6: 0.5885 - val_loss: 2.6182 - val_binary_accuracy: 0.5114 - val_auc_6: 0.4207 - lr: 0.0010\n", - "Epoch 10/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6519 - binary_accuracy: 0.5622 - auc_6: 0.5917 - val_loss: 0.7772 - val_binary_accuracy: 0.4846 - val_auc_6: 0.5799 - lr: 0.0010\n", - "Epoch 11/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 0.6389 - binary_accuracy: 0.6076 - auc_6: 0.6387 - val_loss: 0.7256 - val_binary_accuracy: 0.5065 - val_auc_6: 0.5516 - lr: 1.0000e-04\n", - "Epoch 12/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6359 - binary_accuracy: 0.6048 - auc_6: 0.6450 - val_loss: 0.7171 - val_binary_accuracy: 0.5174 - val_auc_6: 0.5591 - lr: 1.0000e-04\n", - "Epoch 13/25\n", - "108/108 [==============================] - 42s 390ms/step - loss: 0.6296 - binary_accuracy: 0.6160 - auc_6: 0.6552 - val_loss: 0.7183 - val_binary_accuracy: 0.5104 - val_auc_6: 0.5391 - lr: 1.0000e-04\n", - "Epoch 14/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6275 - binary_accuracy: 0.6224 - auc_6: 0.6595 - val_loss: 0.7256 - val_binary_accuracy: 0.5184 - val_auc_6: 0.5392 - lr: 1.0000e-04\n", - "Epoch 15/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6237 - binary_accuracy: 0.6252 - auc_6: 0.6666 - val_loss: 0.7595 - val_binary_accuracy: 0.5065 - val_auc_6: 0.5189 - lr: 1.0000e-04\n", - "Epoch 16/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6177 - binary_accuracy: 0.6248 - auc_6: 0.6785 - val_loss: 0.7494 - val_binary_accuracy: 0.5055 - val_auc_6: 0.5400 - lr: 1.0000e-05\n", - "Epoch 17/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6132 - binary_accuracy: 0.6405 - auc_6: 0.6854 - val_loss: 0.7500 - val_binary_accuracy: 0.5104 - val_auc_6: 0.5397 - lr: 1.0000e-05\n", - "Epoch 18/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6083 - binary_accuracy: 0.6322 - auc_6: 0.6921 - val_loss: 0.7560 - val_binary_accuracy: 0.5164 - val_auc_6: 0.5460 - lr: 1.0000e-05\n", - "Epoch 19/25\n", - "108/108 [==============================] - 42s 391ms/step - loss: 0.6124 - binary_accuracy: 0.6224 - auc_6: 0.6852 - val_loss: 0.7566 - val_binary_accuracy: 0.5124 - val_auc_6: 0.5442 - lr: 1.0000e-05\n", - "Epoch 20/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 0.6075 - binary_accuracy: 0.6331 - auc_6: 0.6944 - val_loss: 0.7579 - val_binary_accuracy: 0.5114 - val_auc_6: 0.5481 - lr: 1.0000e-05\n", - "Epoch 21/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 0.6095 - binary_accuracy: 0.6327 - auc_6: 0.6898 - val_loss: 0.7595 - val_binary_accuracy: 0.5124 - val_auc_6: 0.5475 - lr: 1.0000e-06\n", - "Epoch 22/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 0.6117 - binary_accuracy: 0.6266 - auc_6: 0.6853 - val_loss: 0.7594 - val_binary_accuracy: 0.5084 - val_auc_6: 0.5462 - lr: 1.0000e-06\n", - "Epoch 23/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 0.6100 - binary_accuracy: 0.6359 - auc_6: 0.6900 - val_loss: 0.7595 - val_binary_accuracy: 0.5074 - val_auc_6: 0.5459 - lr: 1.0000e-06\n", - "Epoch 24/25\n", - "108/108 [==============================] - 42s 392ms/step - loss: 0.6088 - binary_accuracy: 0.6410 - auc_6: 0.6932 - val_loss: 0.7603 - val_binary_accuracy: 0.5074 - val_auc_6: 0.5453 - lr: 1.0000e-06\n", - "Epoch 25/25\n", - "108/108 [==============================] - 42s 393ms/step - loss: 0.6085 - binary_accuracy: 0.6401 - auc_6: 0.6903 - val_loss: 0.7612 - val_binary_accuracy: 0.5094 - val_auc_6: 0.5451 - lr: 1.0000e-06\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 628/628 [00:13<00:00, 45.51it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of signals in training data = 2071\n", - "Murmurs prevalence:\n", - "Present = 445, Unknown = 96, Absent = 1530\n", - "Outcomes prevalence:\n", - "Abnormal = 999, Normal = 1072\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 314/314 [00:06<00:00, 46.08it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of signals in validation data = 1092\n", - "Murmurs prevalence:\n", - "Present = 171, Unknown = 60, Absent = 861\n", - "Outcomes prevalence:\n", - "Abnormal = 532, Normal = 560\n", - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train murmur model..\n", - "Epoch 1/25\n", - "104/104 [==============================] - 52s 416ms/step - loss: 1.6239 - categorical_accuracy: 0.3240 - auc_9: 0.5723 - val_loss: 2.0363 - val_categorical_accuracy: 0.1355 - val_auc_9: 0.2385 - lr: 0.0010\n", - "Epoch 2/25\n", - "104/104 [==============================] - 41s 397ms/step - loss: 1.5970 - categorical_accuracy: 0.3404 - auc_9: 0.5831 - val_loss: 1.0049 - val_categorical_accuracy: 0.2436 - val_auc_9: 0.5647 - lr: 0.0010\n", - "Epoch 3/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.5708 - categorical_accuracy: 0.3187 - auc_9: 0.5628 - val_loss: 1.1902 - val_categorical_accuracy: 0.3233 - val_auc_9: 0.4790 - lr: 0.0010\n", - "Epoch 4/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.5508 - categorical_accuracy: 0.4211 - auc_9: 0.6165 - val_loss: 1.5939 - val_categorical_accuracy: 0.1566 - val_auc_9: 0.5500 - lr: 0.0010\n", - "Epoch 5/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.5428 - categorical_accuracy: 0.3713 - auc_9: 0.5905 - val_loss: 0.7431 - val_categorical_accuracy: 0.6896 - val_auc_9: 0.8513 - lr: 0.0010\n", - "Epoch 6/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.5171 - categorical_accuracy: 0.3742 - auc_9: 0.5970 - val_loss: 2.0348 - val_categorical_accuracy: 0.1218 - val_auc_9: 0.1880 - lr: 0.0010\n", - "Epoch 7/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.5334 - categorical_accuracy: 0.3950 - auc_9: 0.6084 - val_loss: 0.6989 - val_categorical_accuracy: 0.7005 - val_auc_9: 0.8601 - lr: 0.0010\n", - "Epoch 8/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.5307 - categorical_accuracy: 0.3901 - auc_9: 0.6193 - val_loss: 0.9616 - val_categorical_accuracy: 0.4176 - val_auc_9: 0.6744 - lr: 0.0010\n", - "Epoch 9/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.5025 - categorical_accuracy: 0.3844 - auc_9: 0.6112 - val_loss: 1.1782 - val_categorical_accuracy: 0.1877 - val_auc_9: 0.5523 - lr: 0.0010\n", - "Epoch 10/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.4727 - categorical_accuracy: 0.4428 - auc_9: 0.6611 - val_loss: 1.1140 - val_categorical_accuracy: 0.3489 - val_auc_9: 0.6072 - lr: 0.0010\n", - "Epoch 11/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 1.4036 - categorical_accuracy: 0.4182 - auc_9: 0.6168 - val_loss: 0.8558 - val_categorical_accuracy: 0.5788 - val_auc_9: 0.7910 - lr: 1.0000e-04\n", - "Epoch 12/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.3689 - categorical_accuracy: 0.4906 - auc_9: 0.6943 - val_loss: 0.9171 - val_categorical_accuracy: 0.5110 - val_auc_9: 0.7215 - lr: 1.0000e-04\n", - "Epoch 13/25\n", - "104/104 [==============================] - 41s 397ms/step - loss: 1.3776 - categorical_accuracy: 0.4853 - auc_9: 0.6875 - val_loss: 0.9968 - val_categorical_accuracy: 0.4386 - val_auc_9: 0.6396 - lr: 1.0000e-04\n", - "Epoch 14/25\n", - "104/104 [==============================] - 41s 398ms/step - loss: 1.3549 - categorical_accuracy: 0.4766 - auc_9: 0.6846 - val_loss: 0.9546 - val_categorical_accuracy: 0.4753 - val_auc_9: 0.6817 - lr: 1.0000e-04\n", - "Epoch 15/25\n", - "104/104 [==============================] - 41s 398ms/step - loss: 1.3206 - categorical_accuracy: 0.4737 - auc_9: 0.6983 - val_loss: 0.9162 - val_categorical_accuracy: 0.4954 - val_auc_9: 0.7215 - lr: 1.0000e-04\n", - "Epoch 16/25\n", - "104/104 [==============================] - 41s 397ms/step - loss: 1.3220 - categorical_accuracy: 0.4631 - auc_9: 0.6802 - val_loss: 0.9933 - val_categorical_accuracy: 0.4451 - val_auc_9: 0.6454 - lr: 1.0000e-05\n", - "Epoch 17/25\n", - "104/104 [==============================] - 41s 398ms/step - loss: 1.3061 - categorical_accuracy: 0.4848 - auc_9: 0.6881 - val_loss: 0.9765 - val_categorical_accuracy: 0.4515 - val_auc_9: 0.6595 - lr: 1.0000e-05\n", - "Epoch 18/25\n", - "104/104 [==============================] - 41s 397ms/step - loss: 1.3168 - categorical_accuracy: 0.4698 - auc_9: 0.6891 - val_loss: 0.9848 - val_categorical_accuracy: 0.4505 - val_auc_9: 0.6492 - lr: 1.0000e-05\n", - "Epoch 19/25\n", - "104/104 [==============================] - 41s 397ms/step - loss: 1.3140 - categorical_accuracy: 0.4713 - auc_9: 0.6869 - val_loss: 0.9805 - val_categorical_accuracy: 0.4542 - val_auc_9: 0.6538 - lr: 1.0000e-05\n", - "Epoch 20/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.3247 - categorical_accuracy: 0.4843 - auc_9: 0.6969 - val_loss: 0.9690 - val_categorical_accuracy: 0.4707 - val_auc_9: 0.6685 - lr: 1.0000e-05\n", - "Epoch 21/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.3122 - categorical_accuracy: 0.4795 - auc_9: 0.6959 - val_loss: 0.9709 - val_categorical_accuracy: 0.4716 - val_auc_9: 0.6665 - lr: 1.0000e-06\n", - "Epoch 22/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.3132 - categorical_accuracy: 0.4761 - auc_9: 0.6986 - val_loss: 0.9604 - val_categorical_accuracy: 0.4707 - val_auc_9: 0.6746 - lr: 1.0000e-06\n", - "Epoch 23/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.3090 - categorical_accuracy: 0.4848 - auc_9: 0.6982 - val_loss: 0.9573 - val_categorical_accuracy: 0.4753 - val_auc_9: 0.6766 - lr: 1.0000e-06\n", - "Epoch 24/25\n", - "104/104 [==============================] - 41s 397ms/step - loss: 1.3064 - categorical_accuracy: 0.4848 - auc_9: 0.7000 - val_loss: 0.9575 - val_categorical_accuracy: 0.4762 - val_auc_9: 0.6756 - lr: 1.0000e-06\n", - "Epoch 25/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 1.3243 - categorical_accuracy: 0.4785 - auc_9: 0.6969 - val_loss: 0.9570 - val_categorical_accuracy: 0.4762 - val_auc_9: 0.6766 - lr: 1.0000e-06\n", - "Train clinical model..\n", - "Epoch 1/25\n", - " 6/104 [>.............................] - ETA: 34s - loss: 0.6821 - binary_accuracy: 0.5250 - auc_8: 0.5121WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1810s vs `on_train_batch_end` time: 0.1835s). Check your callbacks.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1810s vs `on_train_batch_end` time: 0.1835s). Check your callbacks.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "104/104 [==============================] - 50s 415ms/step - loss: 0.6684 - binary_accuracy: 0.5505 - auc_8: 0.5541 - val_loss: 1.2279 - val_binary_accuracy: 0.4872 - val_auc_8: 0.5403 - lr: 0.0010\n", - "Epoch 2/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 0.6620 - binary_accuracy: 0.5563 - auc_8: 0.5678 - val_loss: 0.9139 - val_binary_accuracy: 0.4725 - val_auc_8: 0.5194 - lr: 0.0010\n", - "Epoch 3/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6579 - binary_accuracy: 0.5577 - auc_8: 0.5850 - val_loss: 0.7536 - val_binary_accuracy: 0.4716 - val_auc_8: 0.4302 - lr: 0.0010\n", - "Epoch 4/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6544 - binary_accuracy: 0.5678 - auc_8: 0.5939 - val_loss: 0.7220 - val_binary_accuracy: 0.4753 - val_auc_8: 0.5015 - lr: 0.0010\n", - "Epoch 5/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6548 - binary_accuracy: 0.5606 - auc_8: 0.5905 - val_loss: 0.7249 - val_binary_accuracy: 0.5174 - val_auc_8: 0.4376 - lr: 0.0010\n", - "Epoch 6/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6527 - binary_accuracy: 0.5722 - auc_8: 0.6045 - val_loss: 0.9739 - val_binary_accuracy: 0.4844 - val_auc_8: 0.5369 - lr: 0.0010\n", - "Epoch 7/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6480 - binary_accuracy: 0.5847 - auc_8: 0.6178 - val_loss: 0.7457 - val_binary_accuracy: 0.4414 - val_auc_8: 0.4239 - lr: 0.0010\n", - "Epoch 8/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 0.6458 - binary_accuracy: 0.5939 - auc_8: 0.6219 - val_loss: 0.7250 - val_binary_accuracy: 0.4899 - val_auc_8: 0.5172 - lr: 0.0010\n", - "Epoch 9/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 0.6441 - binary_accuracy: 0.5958 - auc_8: 0.6239 - val_loss: 0.7319 - val_binary_accuracy: 0.5467 - val_auc_8: 0.5443 - lr: 0.0010\n", - "Epoch 10/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 0.6342 - binary_accuracy: 0.6026 - auc_8: 0.6472 - val_loss: 0.7365 - val_binary_accuracy: 0.5485 - val_auc_8: 0.5232 - lr: 0.0010\n", - "Epoch 11/25\n", - "104/104 [==============================] - 41s 396ms/step - loss: 0.6235 - binary_accuracy: 0.6142 - auc_8: 0.6633 - val_loss: 0.7103 - val_binary_accuracy: 0.5485 - val_auc_8: 0.5175 - lr: 1.0000e-04\n", - "Epoch 12/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6176 - binary_accuracy: 0.6205 - auc_8: 0.6683 - val_loss: 0.7142 - val_binary_accuracy: 0.5101 - val_auc_8: 0.5183 - lr: 1.0000e-04\n", - "Epoch 13/25\n", - "104/104 [==============================] - 41s 394ms/step - loss: 0.6123 - binary_accuracy: 0.6185 - auc_8: 0.6805 - val_loss: 0.7446 - val_binary_accuracy: 0.5211 - val_auc_8: 0.4713 - lr: 1.0000e-04\n", - "Epoch 14/25\n", - "104/104 [==============================] - 41s 394ms/step - loss: 0.6108 - binary_accuracy: 0.6205 - auc_8: 0.6793 - val_loss: 0.7322 - val_binary_accuracy: 0.4927 - val_auc_8: 0.4860 - lr: 1.0000e-04\n", - "Epoch 15/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6091 - binary_accuracy: 0.6475 - auc_8: 0.6934 - val_loss: 0.7267 - val_binary_accuracy: 0.5000 - val_auc_8: 0.5182 - lr: 1.0000e-04\n", - "Epoch 16/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6070 - binary_accuracy: 0.6282 - auc_8: 0.6868 - val_loss: 0.7297 - val_binary_accuracy: 0.4954 - val_auc_8: 0.5140 - lr: 1.0000e-05\n", - "Epoch 17/25\n", - "104/104 [==============================] - 41s 394ms/step - loss: 0.6035 - binary_accuracy: 0.6354 - auc_8: 0.6936 - val_loss: 0.7329 - val_binary_accuracy: 0.5000 - val_auc_8: 0.5099 - lr: 1.0000e-05\n", - "Epoch 18/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6008 - binary_accuracy: 0.6379 - auc_8: 0.6976 - val_loss: 0.7339 - val_binary_accuracy: 0.4963 - val_auc_8: 0.5134 - lr: 1.0000e-05\n", - "Epoch 19/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6014 - binary_accuracy: 0.6379 - auc_8: 0.6972 - val_loss: 0.7344 - val_binary_accuracy: 0.4954 - val_auc_8: 0.5130 - lr: 1.0000e-05\n", - "Epoch 20/25\n", - "104/104 [==============================] - 41s 394ms/step - loss: 0.6047 - binary_accuracy: 0.6345 - auc_8: 0.6933 - val_loss: 0.7351 - val_binary_accuracy: 0.4973 - val_auc_8: 0.5103 - lr: 1.0000e-05\n", - "Epoch 21/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.5993 - binary_accuracy: 0.6441 - auc_8: 0.6963 - val_loss: 0.7357 - val_binary_accuracy: 0.4927 - val_auc_8: 0.5130 - lr: 1.0000e-06\n", - "Epoch 22/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.5953 - binary_accuracy: 0.6383 - auc_8: 0.7075 - val_loss: 0.7364 - val_binary_accuracy: 0.4936 - val_auc_8: 0.5144 - lr: 1.0000e-06\n", - "Epoch 23/25\n", - "104/104 [==============================] - 41s 394ms/step - loss: 0.5985 - binary_accuracy: 0.6403 - auc_8: 0.7032 - val_loss: 0.7367 - val_binary_accuracy: 0.4936 - val_auc_8: 0.5153 - lr: 1.0000e-06\n", - "Epoch 24/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6015 - binary_accuracy: 0.6364 - auc_8: 0.6960 - val_loss: 0.7372 - val_binary_accuracy: 0.4927 - val_auc_8: 0.5148 - lr: 1.0000e-06\n", - "Epoch 25/25\n", - "104/104 [==============================] - 41s 395ms/step - loss: 0.6004 - binary_accuracy: 0.6345 - auc_8: 0.7007 - val_loss: 0.7378 - val_binary_accuracy: 0.4936 - val_auc_8: 0.5158 - lr: 1.0000e-06\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 628/628 [00:14<00:00, 44.24it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of signals in training data = 2099\n", - "Murmurs prevalence:\n", - "Present = 400, Unknown = 99, Absent = 1600\n", - "Outcomes prevalence:\n", - "Abnormal = 1024, Normal = 1075\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 314/314 [00:05<00:00, 58.96it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of signals in validation data = 1064\n", - "Murmurs prevalence:\n", - "Present = 216, Unknown = 57, Absent = 791\n", - "Outcomes prevalence:\n", - "Abnormal = 507, Normal = 557\n", - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "INFO:tensorflow:Using MirroredStrategy with devices ('/job:localhost/replica:0/task:0/device:GPU:0',)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Train murmur model..\n", - "Epoch 1/25\n", - "105/105 [==============================] - 52s 414ms/step - loss: 1.5981 - categorical_accuracy: 0.2868 - auc_11: 0.5379 - val_loss: 4.5277 - val_categorical_accuracy: 0.2030 - val_auc_11: 0.4515 - lr: 0.0010\n", - "Epoch 2/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 1.5531 - categorical_accuracy: 0.3497 - auc_11: 0.5882 - val_loss: 1.1515 - val_categorical_accuracy: 0.4370 - val_auc_11: 0.6274 - lr: 0.0010\n", - "Epoch 3/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 1.5174 - categorical_accuracy: 0.3830 - auc_11: 0.6183 - val_loss: 0.9403 - val_categorical_accuracy: 0.4408 - val_auc_11: 0.6853 - lr: 0.0010\n", - "Epoch 4/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 1.4992 - categorical_accuracy: 0.3516 - auc_11: 0.5977 - val_loss: 0.9956 - val_categorical_accuracy: 0.4192 - val_auc_11: 0.6410 - lr: 0.0010\n", - "Epoch 5/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.5212 - categorical_accuracy: 0.4021 - auc_11: 0.6134 - val_loss: 0.7423 - val_categorical_accuracy: 0.7171 - val_auc_11: 0.8661 - lr: 0.0010\n", - "Epoch 6/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.4868 - categorical_accuracy: 0.3973 - auc_11: 0.6100 - val_loss: 1.6311 - val_categorical_accuracy: 0.2030 - val_auc_11: 0.3977 - lr: 0.0010\n", - "Epoch 7/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.4703 - categorical_accuracy: 0.4035 - auc_11: 0.6276 - val_loss: 0.8243 - val_categorical_accuracy: 0.5658 - val_auc_11: 0.7791 - lr: 0.0010\n", - "Epoch 8/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.4549 - categorical_accuracy: 0.4283 - auc_11: 0.6340 - val_loss: 1.3670 - val_categorical_accuracy: 0.1955 - val_auc_11: 0.3281 - lr: 0.0010\n", - "Epoch 9/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.4594 - categorical_accuracy: 0.4397 - auc_11: 0.6428 - val_loss: 1.1310 - val_categorical_accuracy: 0.2594 - val_auc_11: 0.5038 - lr: 0.0010\n", - "Epoch 10/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.4303 - categorical_accuracy: 0.4440 - auc_11: 0.6547 - val_loss: 1.2338 - val_categorical_accuracy: 0.3017 - val_auc_11: 0.5414 - lr: 0.0010\n", - "Epoch 11/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.4038 - categorical_accuracy: 0.4421 - auc_11: 0.6640 - val_loss: 1.0267 - val_categorical_accuracy: 0.3581 - val_auc_11: 0.5829 - lr: 1.0000e-04\n", - "Epoch 12/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.3647 - categorical_accuracy: 0.4555 - auc_11: 0.6787 - val_loss: 1.0040 - val_categorical_accuracy: 0.4041 - val_auc_11: 0.6243 - lr: 1.0000e-04\n", - "Epoch 13/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.3585 - categorical_accuracy: 0.4831 - auc_11: 0.6959 - val_loss: 1.1098 - val_categorical_accuracy: 0.2942 - val_auc_11: 0.5121 - lr: 1.0000e-04\n", - "Epoch 14/25\n", - "105/105 [==============================] - 42s 399ms/step - loss: 1.3221 - categorical_accuracy: 0.4697 - auc_11: 0.6911 - val_loss: 1.0959 - val_categorical_accuracy: 0.3083 - val_auc_11: 0.5334 - lr: 1.0000e-04\n", - "Epoch 15/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.3035 - categorical_accuracy: 0.4697 - auc_11: 0.6977 - val_loss: 1.0014 - val_categorical_accuracy: 0.4126 - val_auc_11: 0.6331 - lr: 1.0000e-04\n", - "Epoch 16/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 1.3085 - categorical_accuracy: 0.4864 - auc_11: 0.6990 - val_loss: 1.0763 - val_categorical_accuracy: 0.3365 - val_auc_11: 0.5620 - lr: 1.0000e-05\n", - "Epoch 17/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.2881 - categorical_accuracy: 0.4840 - auc_11: 0.7008 - val_loss: 1.0906 - val_categorical_accuracy: 0.3195 - val_auc_11: 0.5500 - lr: 1.0000e-05\n", - "Epoch 18/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 1.3003 - categorical_accuracy: 0.4931 - auc_11: 0.7030 - val_loss: 1.0964 - val_categorical_accuracy: 0.3083 - val_auc_11: 0.5442 - lr: 1.0000e-05\n", - "Epoch 19/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.2887 - categorical_accuracy: 0.4931 - auc_11: 0.7088 - val_loss: 1.0794 - val_categorical_accuracy: 0.3242 - val_auc_11: 0.5582 - lr: 1.0000e-05\n", - "Epoch 20/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 1.2946 - categorical_accuracy: 0.4802 - auc_11: 0.7036 - val_loss: 1.0894 - val_categorical_accuracy: 0.3177 - val_auc_11: 0.5496 - lr: 1.0000e-05\n", - "Epoch 21/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 1.3203 - categorical_accuracy: 0.4855 - auc_11: 0.7036 - val_loss: 1.0868 - val_categorical_accuracy: 0.3195 - val_auc_11: 0.5523 - lr: 1.0000e-06\n", - "Epoch 22/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.2649 - categorical_accuracy: 0.5021 - auc_11: 0.7121 - val_loss: 1.0910 - val_categorical_accuracy: 0.3177 - val_auc_11: 0.5486 - lr: 1.0000e-06\n", - "Epoch 23/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 1.2818 - categorical_accuracy: 0.4855 - auc_11: 0.7051 - val_loss: 1.0860 - val_categorical_accuracy: 0.3224 - val_auc_11: 0.5525 - lr: 1.0000e-06\n", - "Epoch 24/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 1.2849 - categorical_accuracy: 0.4836 - auc_11: 0.7044 - val_loss: 1.0844 - val_categorical_accuracy: 0.3224 - val_auc_11: 0.5534 - lr: 1.0000e-06\n", - "Epoch 25/25\n", - "105/105 [==============================] - 41s 396ms/step - loss: 1.2809 - categorical_accuracy: 0.4945 - auc_11: 0.7080 - val_loss: 1.0886 - val_categorical_accuracy: 0.3186 - val_auc_11: 0.5500 - lr: 1.0000e-06\n", - "Train clinical model..\n", - "Epoch 1/25\n", - " 6/105 [>.............................] - ETA: 35s - loss: 0.7209 - binary_accuracy: 0.5667 - auc_10: 0.6085WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1134s vs `on_train_batch_end` time: 0.2422s). Check your callbacks.\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:tensorflow:Callback method `on_train_batch_end` is slow compared to the batch time (batch time: 0.1134s vs `on_train_batch_end` time: 0.2422s). Check your callbacks.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "105/105 [==============================] - 52s 415ms/step - loss: 0.6777 - binary_accuracy: 0.5331 - auc_10: 0.5455 - val_loss: 0.8218 - val_binary_accuracy: 0.4793 - val_auc_10: 0.5143 - lr: 0.0010\n", - "Epoch 2/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6652 - binary_accuracy: 0.5536 - auc_10: 0.5721 - val_loss: 0.7275 - val_binary_accuracy: 0.5235 - val_auc_10: 0.4612 - lr: 0.0010\n", - "Epoch 3/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6626 - binary_accuracy: 0.5665 - auc_10: 0.5709 - val_loss: 0.7038 - val_binary_accuracy: 0.5273 - val_auc_10: 0.5408 - lr: 0.0010\n", - "Epoch 4/25\n", - "105/105 [==============================] - 42s 398ms/step - loss: 0.6671 - binary_accuracy: 0.5598 - auc_10: 0.5650 - val_loss: 0.7770 - val_binary_accuracy: 0.5254 - val_auc_10: 0.5363 - lr: 0.0010\n", - "Epoch 5/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6595 - binary_accuracy: 0.5703 - auc_10: 0.5966 - val_loss: 0.9834 - val_binary_accuracy: 0.4765 - val_auc_10: 0.5259 - lr: 0.0010\n", - "Epoch 6/25\n", - "105/105 [==============================] - 41s 394ms/step - loss: 0.6695 - binary_accuracy: 0.5426 - auc_10: 0.5605 - val_loss: 0.7601 - val_binary_accuracy: 0.4878 - val_auc_10: 0.5445 - lr: 0.0010\n", - "Epoch 7/25\n", - "105/105 [==============================] - 41s 394ms/step - loss: 0.6670 - binary_accuracy: 0.5574 - auc_10: 0.5801 - val_loss: 0.6990 - val_binary_accuracy: 0.5244 - val_auc_10: 0.4958 - lr: 0.0010\n", - "Epoch 8/25\n", - "105/105 [==============================] - 41s 394ms/step - loss: 0.6607 - binary_accuracy: 0.5722 - auc_10: 0.5850 - val_loss: 0.7105 - val_binary_accuracy: 0.5282 - val_auc_10: 0.5130 - lr: 0.0010\n", - "Epoch 9/25\n", - "105/105 [==============================] - 41s 394ms/step - loss: 0.6618 - binary_accuracy: 0.5598 - auc_10: 0.5810 - val_loss: 0.7216 - val_binary_accuracy: 0.5122 - val_auc_10: 0.5323 - lr: 0.0010\n", - "Epoch 10/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6551 - binary_accuracy: 0.5717 - auc_10: 0.6010 - val_loss: 0.6912 - val_binary_accuracy: 0.5442 - val_auc_10: 0.5369 - lr: 0.0010\n", - "Epoch 11/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6506 - binary_accuracy: 0.5841 - auc_10: 0.6166 - val_loss: 0.6840 - val_binary_accuracy: 0.5432 - val_auc_10: 0.5540 - lr: 1.0000e-04\n", - "Epoch 12/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6461 - binary_accuracy: 0.5998 - auc_10: 0.6309 - val_loss: 0.6928 - val_binary_accuracy: 0.5414 - val_auc_10: 0.5468 - lr: 1.0000e-04\n", - "Epoch 13/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6420 - binary_accuracy: 0.5927 - auc_10: 0.6335 - val_loss: 0.6976 - val_binary_accuracy: 0.5282 - val_auc_10: 0.5488 - lr: 1.0000e-04\n", - "Epoch 14/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6437 - binary_accuracy: 0.6017 - auc_10: 0.6265 - val_loss: 0.6947 - val_binary_accuracy: 0.5338 - val_auc_10: 0.5519 - lr: 1.0000e-04\n", - "Epoch 15/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6367 - binary_accuracy: 0.6012 - auc_10: 0.6371 - val_loss: 0.6957 - val_binary_accuracy: 0.5470 - val_auc_10: 0.5509 - lr: 1.0000e-04\n", - "Epoch 16/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6360 - binary_accuracy: 0.5979 - auc_10: 0.6367 - val_loss: 0.6909 - val_binary_accuracy: 0.5517 - val_auc_10: 0.5559 - lr: 1.0000e-05\n", - "Epoch 17/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6345 - binary_accuracy: 0.6112 - auc_10: 0.6455 - val_loss: 0.6912 - val_binary_accuracy: 0.5508 - val_auc_10: 0.5580 - lr: 1.0000e-05\n", - "Epoch 18/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6358 - binary_accuracy: 0.5979 - auc_10: 0.6417 - val_loss: 0.6905 - val_binary_accuracy: 0.5564 - val_auc_10: 0.5574 - lr: 1.0000e-05\n", - "Epoch 19/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6361 - binary_accuracy: 0.6074 - auc_10: 0.6366 - val_loss: 0.6912 - val_binary_accuracy: 0.5517 - val_auc_10: 0.5572 - lr: 1.0000e-05\n", - "Epoch 20/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 0.6359 - binary_accuracy: 0.6031 - auc_10: 0.6436 - val_loss: 0.6921 - val_binary_accuracy: 0.5517 - val_auc_10: 0.5569 - lr: 1.0000e-05\n", - "Epoch 21/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6350 - binary_accuracy: 0.6041 - auc_10: 0.6441 - val_loss: 0.6932 - val_binary_accuracy: 0.5451 - val_auc_10: 0.5568 - lr: 1.0000e-06\n", - "Epoch 22/25\n", - "105/105 [==============================] - 42s 397ms/step - loss: 0.6308 - binary_accuracy: 0.6155 - auc_10: 0.6519 - val_loss: 0.6940 - val_binary_accuracy: 0.5442 - val_auc_10: 0.5565 - lr: 1.0000e-06\n", - "Epoch 23/25\n", - "105/105 [==============================] - 42s 396ms/step - loss: 0.6329 - binary_accuracy: 0.6017 - auc_10: 0.6483 - val_loss: 0.6937 - val_binary_accuracy: 0.5432 - val_auc_10: 0.5558 - lr: 1.0000e-06\n", - "Epoch 24/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6352 - binary_accuracy: 0.6060 - auc_10: 0.6465 - val_loss: 0.6939 - val_binary_accuracy: 0.5442 - val_auc_10: 0.5558 - lr: 1.0000e-06\n", - "Epoch 25/25\n", - "105/105 [==============================] - 41s 395ms/step - loss: 0.6334 - binary_accuracy: 0.6084 - auc_10: 0.6482 - val_loss: 0.6943 - val_binary_accuracy: 0.5432 - val_auc_10: 0.5563 - lr: 1.0000e-06\n" - ] - } - ], - "source": [ - "murmur_model, clinical_model, murmur_probas, outcome_probas, murmur_trues, outcome_trues, murmur_history, clinical_history, val_data, val_patient_labels, val_murmur_patient_clf_cv, val_outcome_patient_clf_cv = cv_challenge_model(data_folder=\"/content/data/training_data/training_data/\", result_folder=\"/content/results/\", n_epochs_1=25,n_epochs_2=25, n_folds=FOLDS, pre_train=False)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "pFbjdVFpQgeY" - }, - "source": [ - "## Training curves\n" - ] - }, - { - "cell_type": "code", - "execution_count": 96, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "hWmccCPkLb66", - "outputId": "515d8e90-abb6-46c8-8700-2aaf8340aeeb" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "for key_idx in range(len(murmur_history[0].history.keys())):\n", - " plt.figure()\n", - " for cv_idx in range(len(murmur_history)):\n", - " plt.title(list(murmur_history[cv_idx].history.keys())[key_idx])\n", - " plt.plot(murmur_history[cv_idx].history[list(murmur_history[cv_idx].history.keys())[key_idx]], label=\"fold {}\".format(cv_idx))\n", - " plt.legend()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 95, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "GzMoaudkNwTu", - "outputId": "80c23f43-c736-4d01-cc3a-18c998583e74" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAAEICAYAAABfz4NwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd1zV1f/A8ddhyZClgLLBLQqi4k5zpLgz82duTcv2+FaWNs22fc3yq5ZlapmmpVbuvU1RyY3iYOMAQUBkc8/vj8/VUFEQLlzGeT4e9wH3M87nfArv+37OeB8hpURRFEVRTIxdAUVRFKViUAFBURRFAVRAUBRFUfRUQFAURVEAFRAURVEUPRUQFEVRFEAFBEVRFEVPBQRFURQFUAFBUcqcEMJCCLFCCBElhJBCiK537BdCiC+EEEn61xdCCGGk6irVmAoIilI+9gKjgMuF7JsIDAJaAAHAAOCZ8quaomhUQFCqLSHEZCHEBSHEdSFEmBDiMf32qUKIXwoc56P/Zm+mf19LCLFQCHFRCHFNCPHn/a4jpcyRUn4tpdwL5BdyyFhghpQyTkoZD8wAxhnqPhWluMyMXQFFMaILQGe0b+3/B/wihGhQjPMWA+lAM/3PjqWsRzPgWIH3x/TbFKVcqYCgVFtSyt8LvF0uhJgCtL3fOUIIV6APUFtKeU2/eVcpq1ITSC3wPhWoKYQQUmWfVMqRajJSqi0hxBghxFEhRIoQIgVoDjgVcZonkFwgGBhCOmBX4L0dkK6CgVLeVEBQqiUhhDfwA/Ai2rd9B+AkIIAbgHWBw+sW+D0WqCWEcDBgdU6hdSjf1EK/TVHKlQoISnVlA0ggEUAI8STaEwLAUaCLEMJLCGEPTLl5kpTyErABmCuEcBRCmAshuhR1MSFEDSGEpf6thRDCssDQ0p+B14QQ7kIIN+B1YFHpb1FRHowKCEq1JKUMQxvNsx+4AvgD+/T7tgDLgeNAKLD2jtNHA7nAGSABeLUYlwwHMgF3YJP+d2/9vnnAGuAE2lPKOv02RSlXQjVTKoqiKKCeEBRFURQ9FRAUxQCEEG8LIdILeW0wdt0UpbhUk5GiKIoCVLKJaU5OTtLHx8fY1VAURalUQkNDr0opnYs6rlIFBB8fHw4fPmzsaiiKolQqQojo4hyn+hAURVEUQAUERVEURU8FBEVRFAWoZH0IhcnNzSUuLo6srCxjV6XcWVpa4uHhgbm5ubGroihKFVDpA0JcXBy2trb4+PhQnVYdlFKSlJREXFwcvr6+xq6OoihVQKVvMsrKyqJ27drVKhgACCGoXbt2tXwyUhSlbFT6gABUu2BwU3W9b0VRykaVCAiKoiillnYJDnwLyRHGronRqIBgALNmzaJp06aMHDnynscsWrSIF198sdB9NWvWLHT7xo0bady4MQ0aNODzzz83SF0VRSlESgws7A0bJ8OslrCgD/zzM2SlGbtm5arSdypXBHPnzmXr1q14eHgYrMz8/HxeeOEFtmzZgoeHB23atGHgwIH4+fkZ7BqKogDXomDRAMhKheHLISEMji6F1S/B+jfBbyC0GA6+D4NJ1f4OXbXvrhw8++yzRERE0KdPH2bOnElycjKDBg0iICCA9u3bc/z48bvOiYyMpEOHDvj7+/Puu+8WWu7Bgwdp0KAB9erVw8LCgmHDhvHXX3+V9e0oSvWSdAEW9oPsNBj7FzTuDZ1fgxcPwVPbIHA4hG+ExYPga3/Y9pF2ThVVpZ4QPlxzirCLhn3E83Oz44MBze65/7vvvmPjxo3s2LEDJycnXnrpJVq2bMmff/7J9u3bGTNmDEePHr3tnFdeeYXnnnuOMWPGMGfOnELLjY+Px9PT89Z7Dw8PQkJCDHNTiqLA1XPw0wDIy4axa8A14N99QoBHkPYK/gzC12tPDXu/gj3/Bc92EDgCmj0GlvbGuwcDU08IBrZ3715Gjx4NQPfu3UlKSiIt7fYgtW/fPoYPHw5w61hFUcpRwhlY1A90eTBu3e3B4E7mltB8MIxaAf8Jg57TtOalNa/AfxtpPzOSy6/uZahYTwhCiN7AN4ApMF9K+fkd+2cC3fRvrQEXKaWDft9Y4Ga7yMdSyp/021ujLSRuBawHXpGlXJzhft/kK5qihoy6u7sTGxt7631cXBzu7u5lXS1FqfqunIKfBoKJqRYMnBsX/1w7V+j0CnR8GS4egSOLIfQnOLMOen8OzR/Xni4qqSKfEIQQpsAcoA/gBwwXQtzWsyml/I+UMlBKGQj8D1ilP7cW8AHQDmgLfCCEcNSf9i3wNNBQ/+ptkDsyss6dO7NkyRIAdu7ciZOTE3Z2drcd06lTJ5YtWwZw69g7tWnThnPnzhEZGUlOTg7Lli1j4MCBZVt5RanqLh2HRf3B1ALGrX+wYFCQEODeCvrPhGd2gb0HrJwAS5+AlNiiz39Q2dcNX2YhitNk1BY4L6WMkFLmAMuAR+9z/HDgV/3vwcAWKWWylPIasAXoLYRwBeyklAf0TwU/A4NKfBcVyNSpUwkNDSUgIIDJkyfz008/3XXMN998w5w5c/D39yc+Pr7QcszMzJg9ezbBwcE0bdqUoUOH0qxZ5XkCUpQK5+IRrc/AwgaeXAdODQxTbl1/rQM6+FOI2gNz28OB70CXX7pypYSYA7DyKfiyIaQW/llhSEUuoSmEGAL0llI+pX8/GmgnpbxrUL0Qwhs4AHhIKfOFEG8AllLKj/X73wMygZ3A51LKR/TbOwNvSSn7368uQUFB8s4Fck6fPk3Tpk2Lc69VUnW/f0UplrjDsHgwWNnD2LXg6F0217kWDeteg/NbwT0IBs6COg/4RS7nBhz/DQ79CFdOQA07rQO706tak1UJCCFCpZRBRR1n6FFGw4AVUspShsZ/CSEmAhMBvLy8DFWsoijVRcwB+GUI2DjBuLVa805ZcfSGkSvgxArY+BbM66J9kHeZpHVO38/Vc1oQOLoUslOhTnPo/zX4/x/UKHzyqqEVJyDEA54F3nvotxVmGPDCHed2vePcnfrtHndsL7RMKeX3wPegPSEUo76KopQHKeHycTi7SRutY26tf1mBhXWB99b691ZgbqPfb6N16pa1qL2wZKj2zXrsGrBzK/trCgEB/wf1u8Pmd7RhqmF/woBZ4NPp9mPz8+DsBjg0HyJ2gok5+D0KbZ/WhraWcwd1cQLCIaChEMIX7UN7GDDizoOEEE0AR2B/gc2bgE8LdCT3AqZIKZOFEGlCiPZACDAGrTNaUZSKLumC9g34xO+QdA4QwAN+VzO3hkbB2qicBj2L/vZcEhG7tE5eR28Ysxps6xj+GvdjUxse+077hr/2P7CoL7QeB498CPk52uik0IWQFg927tD9XWg1Fmq6lG89CygyIEgp84QQL6J9uJsCC6SUp4QQ04DDUsrV+kOHAcsKDh3Vf/B/hBZUAKZJKW8O2H2ef4edbtC/FEWpiFLj4dQqLRBcOgoI8O4EHZ6Hpo+ClSPkZUFuhv6VqbWF52b+uy0n49/fky7A6dVw6g+wsIUmfaHZYO1btZlFyeqYmwnRf0PEDu3b9uUT4NIMxvwFNZ0N+V/jwTToAc/vhx2fwoG5ELZaGzWky4V63aDPdGjUG0yNP0+4yE7likR1Kt+tut+/UoYykrWmjhMrIXofIME1EPyHaB/e9qWcF5OfB1G74eQqLThkpYKlAzTtrz05+HS5/4ekTgeXj8EFfQCIOQD52Vqzi1d7qPcwBE0A61qlq6chXTwCO78ARx9oMwGcGpbLZY3VqawoSmWWna6laTixAi5s0/oGajeErlO0D2lDDdUE7cO+fnft1e8r7Zv9yVVw6i848gtYO4HfQFLrDeCNg9YkpOcxzs+EPjZnsIzeBZG7IVPf4ODSTGt3r9cNvDtofRQVkVtLGLHM2LW4JxUQDGDWrFl8++23tGrV6p4TzRYtWsThw4eZPXv2Xftq1qxJenr6XdvHjx/P2rVrcXFx4eTJkwavt1KJJEfAn89Dk37Q9pmSN6vci5RwbBlseQ9uJIKdB7R/XnsaqBtQ9p2bZhZan0KjYMjNgvNb4OQqdEd/xf7wAj6RjuSZWuK2+xIAqWZO6Hy74+gfrGUhLe/+gRJIzchlz/lEDkQkUdfOkg71axPg4YC5acXJIKQCggGURfprgHHjxvHiiy8yZswYg5arVDLZ6bBspDYsMWa/1hnZ+zNo2NMw5V8+Cevf0Mr2aANDFmr9A8VI9ZyTp2Pr6Su0861F7Zo1DFMfc0toOoA1Oa15//hA+tU4wSSPMJwtJHGOE/k1qT4/hpuTdUIScM2eEVnZDAzMw9qiYn2c6XSSUxfT2BmewK6zifwTcw2dBGsLUzJytJH51hamtPZ2pEP92nSoVxt/d3vMjBggKtZ/wUqoYPrr8ePHM3bsWMaPH09ERATW1tZ8//33BATcnjgrMjKSESNGkJ6ezqOP3nvSd5cuXYiKiirjO1AqNCnhz+cg8QyMWqm1u2+cDEuGaB2RwZ9C7folKzsrDXZ+BiHzwMoBBs6GwJHFzvm/51wiH6w+RUTiDeytzHmzd2OGt/HCxKR0TxP5Osl/N4fz7c4LBHnX4ZVRfbG31YKNBzAJmJiZyx//xLH0YAyTV53gk3WnGdTSnRHtvGjqanff8stSSkYOu89dZWd4ArvPXuVqejYA/u72vNCtAQ83cibQ04G0rDxCIpLYH5HEgYgkpm8MB8DGwpQ2vrXoUK827evVppmbXbkGiKoVEDZM1kYWGFJdf+hz79XKyir9taIAsGeG1uHa62OtrR2gXlcI+Q52TYc57bSRPl0mQQ3b4pUppdZHsPkdSE+AoCeh+3vF7nyNu5bBx2tPs/HUZbxrW/PlkABW/hPHO3+c5LfDcXwyqDnN3UuWEjo1M5dXlh1hZ3giI9p5MXVAMyzM7v5AtLcyZ1wnX8Z29OFw9DWWhsSw/HAsiw9E08rLgRHtvOkf4IqlednOddDpJCfiU9kZnsjOswkci01BJ8HB2pwuDZ3p2tiZzg2dcba9/emplo0Fffxd6eOvzTy+mp7NgYgk9l/QAsTO8EQAbGuY0da3Fu3r1WZwK3fDPYXdQ9UKCBXA3r17WblyJXD/9Nc3jxk9ejRvvfVWuddTqQTOboLtH2vj2DsUyBRjZgGdXoaAJ2Dbh7DvG639/5GpEDDs/t/wE07Dujcgei+4tYLhy7QkbcWQlZvP97sjmLPjPCZCMCm4MRMe8sXS3JQhrT346+hFPl53moGz9zK6vTev9WqMvZV5sW/3fMJ1Jv4cSkxyBh8Pas6o9kWnlxBC0ManFm18avF+fz9W/hPH0pAY3vj9GNPWnGJwKw+eaONp8KeGhOtZ/H5Yu1Z8SqY2F83DgZe6N+Thxs608HDA9AGelJxq1qB/gBv9A7SJcwlpWfqnh2QORCSx7UwCvZvXpbZB7+JuVSsg3OebfEVTVPprpZq7ek5LalbXX5vhWtjfi20dGDRXG1q54U2taenQj9q4do/Wtx+bfR12faEtIl/DVkuJ0GpMsWYLSynZdjqBaWvDiEnOoF+AK+/0bYqbg9WtY4QQDGrpTrcmLny1OZzFB6JZd+Iy7/ZryqOBbkX+vW8Nu8Kry49Sw8yEpU+3p63vgw8VdbSx4KnO9ZjwkC8HIpJZejCGpSExLPo7ihYe9jzRxouBgW7UrFGyjz0pJfsjklgSEsOmk5fJ00k6NajNG8GN6NLQ2aDf3l3sLHk00J1HA7WhvVfSsnCxLdunA6hqAaECuJn++r333isy/fWoUaPuOSpJqcay0mDZCDA1h2FLtLQP9+PRGiZsgePLYesHML+71hfQ4wNt1uupVbDpHbh+SQsCPaZqs2iLIfLqDaatOcWO8EQautRk6VPt6NjA6Z7H21uZ8+GjzRnS2pN3/zzBq8uPsuxQDB8Pak4Dl7ubtKSUzNlxnhlbztLMzY55o4NwLxBoSkIIoXXS1q/NtRs5/HEknmWHYnj7jxN8vC6M/gGuPNHGi1ZeDsX6YpaSkcPKf+JZEhJ9q79kXEcfRrTzop5z+eQYqmNXBjO5C6ECgoFNnTqV8ePHExAQgLW19T3TX48YMYIvvvjivp3Kw4cPZ+fOnVy9ehUPDw8+/PBDJkyYUJbVV4xNp4M/ntFm8o75CxyKmdDRxERb/7dpf9j9JezXz4h1aQpxB8G1BQxdDJ5tilVcRk4es7efZ/6eSCzMTHi3X1PGdvQp9hBJfw97Vj3fiWWHYvhiwxn6fLOHpzrX46XuDW6NBrqRncekFcdYf+Iyjwa68fngAKwsDNvm72hjwfiHfHmykw9HY1NYfiiW1ccu8tvhOBq61OSJNp4MbuVBLZvbh/FKKTkam8IvB2JYe/wi2Xk6Wnk58NXQFvT1L/u+CWNRM5Uruep+/1XOjs9g1+das0+7Z0peTtIF2PS2tiBM59cgaHyxm4fWn7jMx+vCuJSaxeBW7kzu0wQX25J/Q72ans3nG86wIjQOdwcrPhjgR1NXO57++TBnr1xncp8mPN25Xrk1o6Zn57Hu+EWWHYrlSEwKFqYm9GpWh2FtvGjhac+aY5f45UA0YZfSsLEwZVBLd0a288bPzXijl0qruDOVVUCo5Kr7/Vcpp9fC8pFac8+jc8o90+X5hOu8/9cp/r6QhJ+rHdMebUaQj+HSPhyMTOa9P08SfuU6FmYmWJqZ8L8RrXi4kfHyDIVfvs7yQ7GsOhJHSkYuJgJ0Epq62jGqvRePBrqXuM+hIlEBoZqo7vdfZSScgfk9wKkRPLmhbLJ/3kNGTh6ztp3nx70RWJmbMim4MSPaeT/QKJniys3XsXBfJPvOJzF1YDN8nSpGioms3Hw2h13hRFwKffxdaelZvP6FykLlMlKUyiIzRetENreGJ34pt2AgpWTTqctMWxPGxdQshrT2YHKfJjiV4Vh3c1MTJnapz8QuJZxMV0YszU0Z2MKNgS3KYb2ECkwFBEUxJl2+Nrw0JUa/mlcpM4gWU9TVG3yw+hS7zibSpK4ts4a3NGjzkFI5qYCgKMa04xMtkVv/mVrK5jKWlZvP3J0X+G7XBSxMTXi/vx9jOngbNX+OUnGogKAopZV4FsL0i7DYuWsve3ewLCJ9w6k/tNQUrcdpo4DK2PYzV5i6WptcNrCFG+/0a1pu49uVykEFBAMoi/TXsbGxjBkzhitXriCEYOLEibzyyitlUn+lFK6eg4V9IOPq3fssbLXAcDNA2Hn8+x6ppbP2bKcNMS1Dcdcy+HBNGFvCrlDf2abIyWVK9aUCggGURfprMzMzZsyYQatWrbh+/TqtW7emZ8+e+Pn5GewaSimlxMLPg7ThoS8c1DqF0+IhNU7/M/7f95ePa+sMFGTrCkN/BrOy6cTNydPxw54I/rf9HALBW72bMOEh30KTxSkKqIBQamWV/trV1RVXVy0Toq2tLU2bNiU+Pl4FhIoiPREWD9JyBI1bC86Nte0Onvc+Jy/730Bx/RJ4dQDbumVSvZw8Hc/+Esr2Mwn0blaX9wb4lTolhFL1FSsgCCF6A98ApsB8KeVdWeSEEEOBqYAEjkkpRwghugEzCxzWBBgmpfxTCLEIeBhI1e8bJ6W8PU/0A/ri4BecST5TmiLu0qRWE95qe+9spOWR/joqKoojR47Qrl27Ut+PYgBZqfDLYO2DffQf4BpQ9DmgPQnUqqe9ylBevo5Xlh1h+5kEPnmsOSPbFZ01VFEAinx2FEKYAnOAPoAfMFwI4XfHMQ2BKUAnKWUz4FUAKeUOKWWglDIQ6A5kAJsLnDrp5v7SBoOKYu/evYwePRq4f/rr4cOHA9w69l7S09N5/PHH+frrr+9KkqcYQW4mLB0GCWHwxGJt/d4KJF8neeP3Y2w4eZn3+/upYKA8kOI8IbQFzkspIwCEEMuAR4GwAsc8DcyRUl4DkFImFFLOEGCDlDKjdFW+t/t9k69oijMLMjc3l8cff5yRI0cyePDgcqiVcl/5ufDbWG2pycfnG24JSwORUvLunyf48+hFJgU3ZvxDvsauklLJFKd3yR2ILfA+Tr+toEZAIyHEPiHEAX0T052GAb/ese0TIcRxIcRMIUShPWtCiIlCiMNCiMOJiYmFHVKh3Ex/DRSZ/hq456gkKSUTJkygadOmvPbaa2VbaaVoOp223sC5TdD/K23x+QpESsmHa8L49WAsL3VvwAvdGhi7SkolZKjhBmZAQ6ArMBz4QQjhcHOnEMIV8Ac2FThnClqfQhugFlDo13sp5fdSyiApZZCzs/GSYBXX1KlTCQ0NJSAggMmTJ98z/fWcOXPw9/cnPj6+0HL27dvH4sWL2b59O4GBgQQGBrJ+/fqyrr5SGClhwyQ48bu2xkA5zBl4EFJKpm8KZ9HfUUx4yJfXejYydpWUSqrI5HZCiA7AVCllsP79FAAp5WcFjvkOCJFSLtS/3wZMllIe0r9/BWgmpZx4j2t0Bd6QUva/X11Ucru7Vff7LxfbP9bWGOj4MvScVu5ZSIvyv23nmLHlLCPbefHxoOZVKimbYhjFTW5XnCeEQ0BDIYSvEMICreln9R3H/In2dIAQwgmtCSmiwP7h3NFcpH9qQGh/vYOAk8Woi6KUr79na8Gg5egKGQzm74lgxpazDG7lzkePqmCglE6RncpSyjwhxItozT2mwAIp5SkhxDTgsJRytX5fLyFEGJCPNnooCUAI4QN4ArvuKHqJEMIZEMBR4FnD3JKiGMg/i2HzO+D3KAz4psIFg8UHovl43Wn6+bsy/fEATMogXbVSvRRrHoKUcj2w/o5t7xf4XQKv6V93nhvF3Z3QSCm7P2Bd71e/avnNqDKtZVHphK2GNS9DvW4w+IdirTZWnlaExvHenyd5pKkLM58IVMnpFIOo9H9FlpaWJCUlVbsPRyklSUlJWFqq5GQGd2EHrJwA7q219QnKKLVESa09fpE3Vxyjc0MnZo9opVJRKAZT6VNXeHh4EBcXR2UYkmpolpaWBs2fVO2lXYJDP8CBb6F2Qxj5O9Soaexa3WZL2BVeXXaUIO9azBvdusou9q4YR6UPCObm5vj6qgk4SilcPAoH5sLJVaDLgyb9oN8MsHI0ds1us/tsIi8s+Ydm7vb8OC4Ia4tK/89XqWDUX5RSPeny4exG2D8XoveCuQ20mQDtninzXEMPKi9fx8J9Ufx3czj1XWry85NtsbU0N3a1lCpIBQSleslOh6NLtGaha5Fg7wk9P4JWY8DKoejzy9mRmGu8/cdJTl9Ko0cTF6YPCcDeWgUDpWyogKBUD6lxEDIPQn+C7FTwaAM93oemA8G04v0zSM3M5ctNZ1gSEkMdW0u+G9Wa4GZ1quVoOqX8VLx/CYpiSJdPwN6ZcOpP7b3fQGj/Ani2MW697kFKyepjF/lo7WmSb2TzZEdfXuvViJo11D9VpeypvzKl6kq6AD8Ga3MI2j+n9Q84eBm7VvcUdfUG7/11kj3nrhLgYc+iJ9vQ3L2IdZkVxYBUQFCqpvxcbS6BqTk897e2lnEFlZ2Xz/e7IvjfjvNYmJrw4cBmjGrvjamaeayUMxUQlKpp52dw8Yi2ZnEFDgYHIpJ4548TXEi8QT9/V94f4EcdOzXZUDEOFRCUqidqH+z5SktI51f4mtXGlnwjh0/Xn2ZFaByetaxY+GQbujV2MXa1lGpOBQSlaslMgVUToZYv9L5r6W+j0ukkByKS+D00jg0nL5GXL3m+a31e6t4QKws141gxPhUQlKpDSlj7H0i/DBM2V5i0E7HJGawIjWPlP3HEXcvE1tKMIa09GNfRhwYutsaunqLcogKCUnUcXw6nVkH397TEdEaUmZPPxlOX+P1wHH9fSEIIeKiBE5OCGxPcrK7KQaRUSCogKFVDciSsewO8O8FD/zFKFaSUHIlN4ffDsaw9donr2Xl41bLm9Z6NGNzaA3cHK6PUS1GKSwUEpfLLz4NVT4MwgcfmlfvaBamZufx6MIbfD8dyIfEGVuam9PV35f+CPGjrU0stXKNUGiogKJXf7i8h7hAMWQAOnuV66bhrGYxZcJCIxBsEeTvyxeP16BfgpmYWK5WS+qtVKreYENg9HVoMh+aPl+ulwy6mMW7hQTJz8/n16fZ0qF+7XK+vKIamAoJSeWWlwaqntIylfaaX66X/vnCVZ34OxaaGGSue7Ujjumq0kFL5FWvtPSFEbyFEuBDivBBi8j2OGSqECBNCnBJCLC2wPV8IcVT/Wl1gu68QIkRf5nIhhEXpb0epVtZPgtR4eHw+WNqV22XXHr/IuAWHqGtvyarnVTCoKvZf3M/Uv6ey+sJqUrNTjV0doyjyCUEIYQrMAXoCccAhIcRqKWVYgWMaAlOATlLKa0KIglMuM6WUgYUU/QUwU0q5TAjxHTAB+LYU96JUJydWwPFl0HUKeLYtt8su2BvJR+vCCPJ25IcxQThYq+8xlV1GbgZfhX7F8vDlmJuYs/LcSsyEGW1d29LDqwfdvbrjZOVk7GqWC1HU4vRCiA7AVCllsP79FAAp5WcFjpkOnJVSzi/k/HQpZc07tgkgEagrpcy78xr3EhQUJA8fPly8O1OqrpQY+PYhcGkC49aXy3oGOp3ki01nmLcrguBmdfhmWEs1l6AKOJpwlHf2vkPs9VhG+Y3ipZYvcf7aebbEbGFb9DZirscgELR0ackj3o/Qw6sHbjXdjF3tByaECJVSBhV1XHH+JbkDsQXexwHt7jimkf6i+wBTtA/3jfp9lkKIw0Ae8LmU8k+gNpAipcwrUGahGciEEBOBiQBeXhU3dbFSTnT5sOoZkDoY/H25BIOcPB1vrTzOH0fiGdXeiw8HNleZSCu5nPwc5h6dy8JTC6lrXZcfg3+kTV1tjQx/Z3/8nf35T6v/cC7lHNuit7E1ZivTD01n+qHp+NX24xGvR3jE+xF87avWeu6G+tdkBjQEugIewG4hhL+UMgXwllLGCyHqAduFECeAYjfQSSm/B74H7QnBQPVVKqu9X0HM3/DY9+DoU+aXS8/O47lfQtlz7ipv9GrEC90aqFXLKrnw5HDe3vs2Z6+dZXDDwUwKmkRNi7vTnAghaOTYiEaOjXgu8Dli0mLYFrONrdFbmXVkFrOOzKK+fX3au7XH184XX3tffOx9cLZyLvXfiJSSpKwkotOiiUmLIeZ6DE/5P4WNuU2pymTGI0YAACAASURBVC1KcQJCPFBwcLeHfltBcUCIlDIXiBRCnEULEIeklPEAUsoIIcROoCWwEnAQQpjpnxIKK1NRbhcXCjs+g+ZDIGBomV8u8Xo2Ty46yOlL15n+eABD25TvHAfFsPJ0eSw8uZC5x+biUMOB2d1n87Dnw8U+38vOiyebP8mTzZ/k8o3LbI/ZzraYbaw6t4rMvMxbx9mY2+Bt542PnQ8+9j742vvia+eLl50XVmb/zla/+aEfez321gd/dFo0sddjibkew43cG7eONRNm9PHtQyPHRob5j3EPxelDMAPOAj3QPrQPASOklKcKHNMbGC6lHCuEcAKOAIGADsiQUmbrt+8HHpVShgkhfgdWFuhUPi6lnHu/uqg+hGpMSlgQrPUfPH8ArBzK9HJRV28wZsFBEq5nMXdkK7o3qVOm11PKVlRqFO/se4fjiccJ9gnm3Xbv4mBpmL8hndSRkJFAZGokUWlRRKVG3fp58cbF2451tXHFy86LtOy0uz70TYUp7jXd8bLzwtvOG09bT7ztvPG29ca1pitmJiVv0DFYH4K+0/dFYBNa/8ACKeUpIcQ04LCUcrV+Xy8hRBiQD0ySUiYJIToC84QQOrQhrp8XGJ30FrBMCPExWgD5sQT3qVQXkbshNgT6/rfMg8Gx2BTGLzqETkp+fbo9Lb0cy/R6Fcn+i/tJyU6hs3vnQptRKhud1PHrmV/5OvRrLEwtmN5lOn18+xj0GibChLo2dalrU5cObh1u25eZl0lMWgyRaZG3AkVsWiy1rGoR6BKIt503XrZaAHCt6Yq5iblB6/aginxCqEjUE0I1tqg/XD0HrxwD87JZUSwrN58f90Yye/t5ate04OfxbannXPk/FIsjJz+HLw99ybLwZQCYm5jTya0TPX160tWzK3YW5TfPw1AupV/ivX3vEXI5hE7unZjWcRou1tVzESJDjjJSFOOK3g9ReyD40zIJBjqdZNWReGZsDudSahaPNHXh08f8cakmS1leTL/I6ztf52TSScb4jaG7V3e2Rm9lS/QWdsbtxMzEjPau7enl3Ytunt0M1tTyII4lHuNYwjEy8jK0V67+lVfgp/73zLxMMnIzyMrPwsrMivc7vM+QhkPUYIBiUE8ISsW3eDBcOgavHgcLw46y2HMukU/Xn+H0pTQCPOx5u29T2terPjmJdsftZsqeKeikjo86fcQj3o/c2qeTOk5ePcmW6C1sid5CfHo8psKUtnXb0sunF929ulPLslaZ1i85K5kZh2ew+sKtJAdYmFhgbW6NtZm19vPm72b//m5jboONuQ196/XF01YNBijuE4IKCErFFhcK87tDjw+g82sGK/bM5TQ+W3+GXWcT8XC0YlJwYwYEuFWbVNX5unzmHJ3DDyd+oLFjY77q+hVedvee5yOlJCw5jC1RW9gcvZnY67GYCBPa1GlDT++e9KnXx6DNSjqpY9W5VcwMnUlGXgbjmo1jtN9obC1sjd7OXhmpgKBUDUuHQcx++M9JqFH6nEGXU7P4aks4K0LjsLU056XuDRjdwZsaZtVn1vHVzKtM3j2ZkMshDG44mCltp2BpVvzmMSklZ6+dZXP0ZjZHbSYqLQprM2sGNxzMKL9RuNcsdI5psYUnh/PRgY84lniMoDpBvNv+Xeo71C9VmdWdCghK5XfpOMzrDF3fhq5vlaqo9Ow85u26wA97ItDpYGxHb17o1qDa5SI6fPkwb+5+k7ScNN5p9w6PNXysVOVJKTmdfJrFYYvZGLkRHTp6efdibLOxNHdq/kBl3ci9wdyjc1lyegn2Nex5Peh1BtQboNr+DUAFBKXy+20MXNgBr54o8VDT3Hwdyw7F8s3Ws1xNz2FgCzcmBTfGs5a1gStbsUkpWXRqEd/88w0eth7MeHgGjWs1Nug1Lt+4zNLTS/n97O+k56bTyqUVY5uNpatnV0zEvRMrSynZFrONzw9+zpWMKwxpNIRXW72KfQ17g9avOlMBQancEs7A3PbQ+XXo8V6Jixn9Ywh7zl2lnW8t3u7blBae5T9CxtjSctJ4d++77IjdQU/vnkzrOK1M5xjcyL3BqnOr+CXsFy7euIi3nTdj/MYwoP6A22bqAsRdj+PTkE/ZE7+HRo6NeK/9ewS6FJYcWSkNFRCUym3lU3BmvfZ0YFOyUT9X07MJ+ngrzz5cn7d6N670TQ8X0y+SmZeJhakFNUxrUMO0xq3f7/UNPCwpjNd2vsaVG1d4Peh1RjYdWW7/HfJ0eWyN3spPp37iZNJJHGo48ETjJxjWZBj2FvYsOrWIecfnYSpMeSHwBUY0HVGq2bjKval5CErllXQBTq6EDi+UOBgAHIpMBqBXszqVPhgsOrmIGaEz7rnfzMQMS1PLu4JFVGoUjpaOLOy9sNy/eZuZmNHbtzfBPsGEXgnlp7Cf+P749yw8uRAnKycu3rhIT++evNnmTera1C3XuimFUwFBqXj2fAWmFtDhpVIVExKZjJW5Kc3dKm9btJSSWUdmMf/EfHp596KnT09y8nPIzs++9TM7L1v7WWDbzZ/+Tv683OrlMp8vcD9CCILqBhFUN4io1CgWhy3m7LWzvNP+Hbp4dDFavZS7qYCgVCzXorWV0No8BbalSyh3MDKZVt4OWJgVa6XYCkcndXwa8inLw5czpNEQ3m33LqYmlXt4rI+9D+91KHmfkFK2Kue/FKXq2jsThAl0fLlUxaRm5nL6chptfcp+1nF6TjrJWckGLTNXl8uUPVNYHr6c8c3H83779yt9MFAqPvWEoFQcqfFwdAkEjgT70k1uCo1ORkpo62vYphIpJdFp0RxLPMbRxKMcSzzG+WvnMRWmjGk2hmcCnsHavHRDWrPysnh91+vsjtvNq61eZYL/BAPVXlHuTwUEpeL4e5a2NOZD/yl1USGRyZibClp6lW6YaUZuBqeSTnE0QfvwP5Z4jJTsFABszW0JcA6gp1dP4tPjWXByARsjN5aqbTw9J50Xt7/IP1f+4b327zG0cdkvBKQoN6mAoFQM169A6CIIGAaO3qUu7mBkMi08HLA0f7BmFp3UsS1mGwcvHeRY4jHOXjtLvswHoJ59Pbp5dqOFcwtaOLegnkO924Z7DmowiI8PfMwL217gEa9HeKvtWw80eiY5K5lntzzLuWvn+KLLFwbP268oRVEBQakY9v8P8nMMksAuIyePE3GpTOxS74HP/f7498w5OgdrM2v8nf15yv8pWji3IMA5oMiZs0F1g/h9wO/8FPYT847N4+8//y72+PrLNy4zcctELqZf5Jvu36jRN4pRqICgGN+NJDi0AJo/DrVLn8TsSEwKeTpJuwdMY707bjdzj85lYP2BTOs4rUSduOam5jzl/xS9fXrzacinfHn4S1ZfWM37Hd4nwDmg0HOi06J5evPTXM+5zrye82hdp/UDX1dRDEGNMlKM78BcyM2Azm8YpLiQiCRMBLT2Lv7Sl9Fp0UzePZkmtZrwXvv3Sj2ix8PWgzk95vBV16+4lnWNUetH8dH+j0jNTr3tuDPJZxizYQzZ+dn8GPyjCgaKUamAoBhXZgoc/B78BoJLE4MUGRKZTHN3e2rWKN4DcEZuBq/ueBVTE1O+7vb1A6WCvh8hBD29e7L6sdWMbDqSFedWMPDPgayNWIuUkiMJRxi/cTwWphYs6r0Iv9p+BrmuopRUsQKCEKK3ECJcCHFeCDH5HscMFUKECSFOCSGW6rcFCiH267cdF0I8UeD4RUKISCHEUf1LZbSqjkLmQXaawZ4OsvPyORKbQluf4g03lVLy/t/vE5EawfQu03Gr6WaQehRkY27DW23fYlm/ZbjZuDFlzxTGbRzHxM0TqW1Vm597/4yvva/Br6soD6rIr1BCCFNgDtATiAMOCSFWSynDChzTEJgCdJJSXhNC3FzJOgMYI6U8J4RwA0KFEJuklCn6/ZOklCsMeUNKJZJ9XWsuatQHXAtvX39Qx+NSycnTFXv+waJTi9gUtYnXWr9GB7cOBqnDvTSt3ZRf+v7CirMr+Oafb/Cx9+G7R76jtlX1WbJTqdiK80zdFjgvpYwAEEIsAx4Fwgoc8zQwR0p5DUBKmaD/efbmAVLKi0KIBMAZSEFRDs2HrBR4eJLBijyoT2jXphhPCPsv7ufrf74m2CeYcc3GGawO92NqYsoTTZ5gQP0BmJuYY26qloNUKo7iNBm5A7EF3sfptxXUCGgkhNgnhDgghOh9ZyFCiLaABXChwOZP9E1JM4UQNQq7uBBiohDisBDicGJiYjGqq1RoOp2Wryh8I/w9G+r3AHfDdaSGRCbTuI4tjjb3XwktPj2eSbsnUc++HtM6Tiv3bKjW5tYqGCgVjqGGnZoBDYGugAewWwjhf7NpSAjhCiwGxkopdfpzpgCX0YLE98BbwLQ7C5ZSfq/fT1BQUOVZvKG6kxKuX4aEMEg4DYmntZ8JZyD3hnaMmRV0e9tgl8zL1xEalczgVh73PS4rL4v/7PgPOp2Ob7p9U+pUE4pSVRQnIMQDngXee+i3FRQHhEgpc4FIIcRZtABxSAhhB6wD3pFSHrh5gpTykv7XbCHEQsAwvYpK+ZMS4v+Bi//8GwASTmvNQTfZOINLU2g1GpybgIufNqrI0nCpqcMupXEjJ/++/QdSSqbtn8aZ5DPM7jEbLzsvg11fUSq74gSEQ0BDIYQvWiAYBoy445g/geHAQiGEE1oTUoQQwgL4A/j5zs5jIYSrlPKS0J7VBwEnS3crSrlLPAsnfoMTv8O1KG2bpb32Yd/sMf2HflPtZeNU5tW52X9wv4Cw9MxS1kSs4YXAF9RsYEW5Q5EBQUqZJ4R4EdgEmAILpJSnhBDTgMNSytX6fb2EEGFAPtrooSQhxCigC1BbCDFOX+Q4KeVRYIkQwhkQwFHgWUPfnFIGrl/WVjM7/htcOqqlqvZ9GB5+S/tp5wZGWp0sJDIZn9rW1LErfB5B6JVQ/nvov3T17MrEgInlXDtFqfjUmspK0bKvw+k1WhCI3KVlJHUNhIChWroJW+Mvf6jTSVp9vIVefnWYPqTFXfsv37jME2ufwM7CjqX9lmJrYWuEWiqKcag1lZXSycuBC9u0IBC+AfIywcEbOr8O/kPBuZGxa3ibcwnppGTk0tb37jH9Ofk5vL7zdbLyslgYvFAFA0W5BxUQlLuF/gRbp0JmMljVgpYjtSDg2dZozUFFORiZBEC7QvoPPg35lONXjzOz60zqOTx4BlRFqS5UQFBuF74B1rwC3h21ZSzrdwez+4/prwhCIpNxtbfEw9Hqtu0rzq5g5bmVPOX/FI94P2Kk2ilK5aACgvKvS8dgxQRwC4SRK8CicozPl1JyMDKZDvVr3zbBLDw5nM9CPqOjW0deDHzRiDVUlMpBZTtVNGkXYekwsHKA4csqTTAAiErKIOF69m3DTTNyM3hj1xvY17Dns86fqQXqFaUY1BOCAjk34NdhWtbR8RsrxKihB1FY/8HnBz8nOi2aH3r9QC3L4iW6U5TqTgWE6k6XDyufhssntCeDuv7GrtEDC4lMpraNBfWdawKwIXIDf5z/g6f9n6adazsj105RKg8VEKq7rR9A+DroMx0aBRu7NiVyMDKZtr61EEIQdz2Oafun0cK5Bc8FPmfsqilKpaL6EKqzwwvh7/9B24nQ7hlj16ZE4lMyibuWSVvfWuTqcnlr91sIBF90+QJzE5VNVFEehHpCqK4u7IB1r0ODnhD8mbFrU2KHCuQvmn1kNsevHmfGwzNwr3lnhnZFUYqinhCqo4Qz8NtYLevokAVgWnm/F4REJmNracY13SkWnFzAkEZD6OXTy9jVUpRKSQWE6iY9EZYOBbMaMGI5WNoZu0alcjAyiUAfU97d9zYNHBrwZps3jV0lRam0Ku9XQ+XB5WbBshGQngBPrgMHz6LPqcCupmdzIfE6lh6/k56bzg+9fsDKzKroExVFKZR6QqgupIS/noe4gzB4nkGXrTSWQ5HJmNfaS0zWESYFTaKhY0NjV0lRKjUVEKqLnZ9p6xg8MhX8HjV2bQxi47lD1HDZRDfP7gxtPNTY1VGUSk8FhOrg2HLY9QW0HAWdXjV2bQwiPSed3SlfY4E9H3WadlsOI0VRSkYFhKou5gCsfhF8OkO/mRU2ffWDkFLywb5p5JpcJdj5dexrGG5dZkWpzlRAqMpS42D5KLD3gKE/V4o01sWx+sJqNsdsIOfqIwxs0snY1VGUKkMFhKoqJ0MbUZSbpeUosq4aCd6iUqP4JOQTXMybIa91p6WXg7GrpChVRrECghCitxAiXAhxXggx+R7HDBVChAkhTgkhlhbYPlYIcU7/Gltge2shxAl9mbOEagQ2HClh9Utw6Tg8Ph+cGxu7RgaRk5/Dm7vfpIZpDaxSRtHCoxaW5iqttaIYSpEBQQhhCswB+gB+wHAhhN8dxzQEpgCdpJTNgFf122sBHwDtgLbAB0IIR/1p3wJPAw31r96GuCEF2Pc1nFwBPd6DxlXnP+vco3M5nXyad9pO5UycyW3rHyiKUnrFeUJoC5yXUkZIKXOAZcCd4xafBuZIKa8BSCkT9NuDgS1SymT9vi1AbyGEK2AnpTwgpZTAz8AgA9yPcnYzbP0Qmg2Gh14zdm0MJjYtlp/DfmZg/YHUzG9Bnk6qgKAoBlacgOAOxBZ4H6ffVlAjoJEQYp8Q4oAQoncR57rrf79fmQAIISYKIQ4LIQ4nJiYWo7rVWOJZWDlBW9Pg0TlVYkTRTV+FfoWZiRmvtHqFg5FJmAho7e1Y9ImKohSboTqVzdCafboCw4EfhBAG6e2TUn4vpQySUgY5OzsbosiqKTMFlg0HUwsYtrRSLYFZlEOXD7E1ZitP+T+Fi7ULIZHJNHOzx9ZSpbdWFEMqTkCIBwomvfHQbysoDlgtpcyVUkYCZ9ECxL3Ojdf/fr8ylULk6fLQWtkK0OVrTwbXouCJxZU+R1FB+bp8ph+ajquNK2P8xpCdl8+R2BTVXKQoZaA4AeEQ0FAI4SuEsACGAavvOOZPtKcDhBBOaE1IEcAmoJcQwlHfmdwL2CSlvASkCSHa60cXjQH+MsQNVWXZ+dkErwzm57Cfb9+xdSqc3wp9vwTvjkapW1n568JfnEk+w2utX8PSzJLjcank5OlUQFCUMlBkQJBS5gEvon24nwZ+k1KeEkJME0IM1B+2CUgSQoQBO4BJUsokKWUy8BFaUDkETNNvA3gemA+cBy4AGwx4X1XSztidJGQk8NeFArHz+G/w9ywImgBB441XuTKQnpPOrH9mEegcSLCPtrznwZsL4viogKAohlas9NdSyvXA+ju2vV/gdwm8pn/dee4CYEEh2w8DzR+wvlWLlKDLA9PitYWvjVgLwLlr54hNi8XzeqI238C7E/T5oixrahTzT8wnKSuJ2T1m38pVFBKZTOM6tjjaVI1Z14pSkaiZysaSHAHzusCn7vDLEDg0X0s1cQ/Xsq6xN24vPb17ArDt3J+wbCTYuGhpKYoZVCqLuOtxt4aZNnfSvjfk5esIjUpWzUWKUkZUQDCG8A0wryukxEDLkZB0XlvfeGYz+PYh2P4xxIWCTnfrlE1Rm8iTeTwT8AxNHBux7fhCyEqBYUvAxsl491JGbg4zfbnly7e2hV1K40ZOvgoIilJG1Ipp5UmXDzs+gT0zwLWF9s3e0UdrOrp6Ds5ugPCN2v7dX2rf/hv1gkZ9WHPhLxo6NqSxYyO6Z2bzrcjhar8vcHINMPZdGdzhy4fZEr2FFwJfoI5NHXQ6yYn4VH7cGwmgAoKilBEVEMrLjava0NCIndBqDPT5EswttX1CgHMj7dXpFchI1kYNhW+AsDXEnFjGcU83XhNOsOYVepw/wFwPV7ZbWVLVloW5OczUxaoO9jmP8PKvR9hzLpFrGbkAPBroRh07SyPXUlGqJhUQykPcYfhtjBYUBs6GVqPvf7x1LQgYqr3yc1m7+x1EzAb6pF6DiJ9o2KgPnpZpbI/ZXmVWCsvOyyc06hoLjv/G6eunyYwfxpR/wnGqWYNujV3o0siZhxo64VSzhrGrqihVlgoIZUlKrbN44xSwc4UJm8Et8MGKMDFj7bWTtHVtR90xP0BKNMLWjR5H/8cvp3/hes51bC1sy+gGylZ00g12nElg97mr7L+QRGZ+BjXr/4K1ST2e7TCUhxu54Odqh4lJ1UnBoSgVmQoIZSXnBqz9DxxfDg17wWPzSrQmwbHEY8Rej2ViwEStacnRB4AeXj1YdGoRe+L20LdeXwNXvuztDE9g/KJD6CR417ZmSGsP0q3XsPXSdeb3/Y4A54bGrqKiVDsqIJSFq+fht9GQcBq6vQOd3wCTkg3oWhuxFktTy1vDTW8KcA7AycqJbTHbKl1AyM7LZ+rqU/g42bBgbBt8nGy4mH6RAX+soH+9/gQ4V72OckWpDFRAMLTTa+DP58HEDEathAY9SlxUbn4uG6M20s2rGzbmNrftMxEmdPPsxrqIdWTnZ1PDtPK0rc/fE0lUUgY/j2+Lj5N2XzNDZ2IiTHil1StGrp2iVF9qHoKh6PJhy/vaGsa1G8Azu0oVDAD2xu8lNTuV/vX6F7q/h1cPMvIyOHDxQKmuYwjJWclk5mUWedyl1Exmbz9PL786dGmkZa89knCEjVEbebL5k9S1qVvWVVUU5R7UE4Kh7JoO+77R8gn1/hzMSv+NfU3EGmpZ1qKjW+EJ69rWbYutuS3bYrbxsOfDpb7eg5JScvDyQZacXsLO2J1YmVnR3as7fX370t6tPeYmd8+e/nT9GfKl5L3+2qJ7Oqnji4Nf4GLtwrhm48r5DhRFKUgFBEO4fAL2/Bf8h0L/mQYpMi0njV2xu/i/xv+HmUnh/5vMTc3p7NGZnbE7ydPl3fM4Q8vMy2RdxDqWnF7C+ZTzONRw4MnmT5Kancrm6M2sjViLYw1Hevn0oo9vH1q6tMREmBASkcSaYxd5uXsDPGtp6zWsjVjLqaRTfPrQp1ibV501HBSlMlIBobTyc7U+A6taBk0wtyVqCzm6HAbUG3Df47p7dWd95HqOJByhTd02Brt+YS6mX2RZ+DJWnl1JWk4ajR0bM63jNPr49sHSTJss9na7t9kXv48NkRv46/xfLA9fTl2buvT27s26A3Vxc6jLc10bAJCRm8E3od/g7+RPv3r9yrTuiqIUTQWE0tr3NVw+DkMXl2hY6b2siViDj50PfrX97ntcZ/fOWJhYsD1me5kEBCklh68cZunppWyP3Q5ofRcjm46klUurW1lIb7IwtaCbVze6eXUjIzeDHbE7WB+5np/DFqOzy8fFxYufTp+jr29fVl9YTUJmAjO6zsBEqO4sRTE2FRBKI+G01nfQ7DHwG1j08cV0Mf0ioVdCeanlS3d94N7J2tyaDm4d2BazjTfbvFnk8cWVlZfFhsgNLDm9hPBr4djXsOfJZk/yROMncK3pWqwyrM2t6VevHx3q9KTrV+twczuLq/1p5hydw5yjczARJvTx7UOgy4NN1lMUpWyogFBS+XlaU1ENW+j7X4MWvS5iHUCxm1F6ePVgV9wuTiefLvKJojg2RW3i4wMfk5KdQkPHhnzY8UP6+va91Sz0oL7cFM6NzBr8r//zNKpjy+Ubl9kYuZGjiUd5rfVdS2goimIkKiCU1IE5cPEfePxHg6afllKyJmINrVxa4V7TvVjnPOz5MCbChG0x20odEJKzkvnw7w/xsPXgq65fEVQnqFRPHSfjU1l2KIYnO/rSqI6WYqOuTV3GNR9XqnoqimJ4quG2JK6eg+2fQJP+0PxxgxYdlhxGZGok/esXPvegMLUsa9HKpRXbY7aX+vqz/plFZl4mn3f+nDZ125QqGEgp+WD1KWrbWPBqT5WKQlEqOhUQHpQuH/56AcytoN9XWn4hA1p7YS3mJub08u71QOf18OrB+ZTzRKdFl/jaYUlhrDq3iuFNh1PPoV6Jy7npjyPxhEZf483gJthZVq0V3RSlKipWQBBC9BZChAshzgshJheyf5wQIlEIcVT/ekq/vVuBbUeFEFlCiEH6fYuEEJEF9lWOnsWQeRAbog0xta1j0KLzdHlsiNxAV8+u2Newf6Bzu3t1ByjxU4KUks8Pfo6jpSPPtni2RGUUdD0rl882nKGFpwNDWnuUujxFUcpekQFBCGEKzAH6AH7AcCFEYQ3Vy6WUgfrXfAAp5Y6b24DuQAawucA5kwqcc7TUd1PWki7AtmnQMBgCnjB48QcuHSApK6lEY/LdarrRtFZTtsVsK9G1N0Ru4EjCEV5u+TJ2FnYlKqOg/20/T+L1bD4c2Eylr1aUSqI4TwhtgfNSyggpZQ6wDHi0BNcaAmyQUmaU4Fzj0+lg9cvaYvYDvjZ4UxHAmgtrsK9hTxf3LiU6v4dXD44lHiMxI/GBzsvIzWBG6Aya1mrKoAaDSnTtgs4npLNgbyRDgzwI9HQodXmKopSP4gQEdyC2wPs4/bY7PS6EOC6EWCGE8Cxk/zDg1zu2faI/Z6YQotDkP0KIiUKIw0KIw4mJD/ZBZ1CHf4TovRD8Cdi5Gbz4G7k32B6znWDvYMxNS9be3sNLS6a3I3bHA503/8R8EjISmNJuCqYmpiW69k1SSqatDcPKwpQ3ezcpVVmKopQvQ3UqrwF8pJQBwBbgp4I7hRCugD+wqcDmKUAToA1QC3irsIKllN9LKYOklEHOzs4Gqu4DuhYNWz6A+t2hZRHLX5bQtv9v787jqqzyB45/voKoCIgLIAoq4RKaW5C0OOZoVi5ZauOSTTlmZhM5U9NMNdU0v5pm0pbJss2xGkXNyKXcMk1ttUVAcgFRXFERUCRSlPX8/rgX50oIF7hw4d7v+/Xy5eU8z3Oec3xe3i/Pec5zvkc2cb7kPLeEV75URWXC/cPp7Ne5WsNG6T+ns2D3AkaEjaB/YP8an7vMxuRMvtybzUM3dNd0l0o1Mva8h3AMsP2NP8RadoEx5pTNj/OB2eXqGA+sNMYU2RyTYf1YICLvAY/Y2+i6VlBSqyIqnAAAFO9JREFUwLRPp3Gm6AxB3oEEHN9BoJ83QVfcRODRLwj0DiTQO5A2zds4bMmFNfvXEOITQt+AvjWuQ0QY0mkIsbtjySvMs+tZwEvxL+HRxIOHIh+q8XnLnC8q4dm1yXQL9OG313SudX1KqfplT0DYBnQTkTAsgWAicIftDiISbPMFPxpIKVfHJCx3BL84RiwT3W8DdtWg/XWi7C3a6OBock/vZ29xLqf8vCnd8fpF+3mKJ+282xHoHUiQdxChvqGM7zHe7hfKymTlZ/H9ie+Z3md6rZeeGNppKO/teo8vj355yTwKZb7L+I5NRzYxs/9Mh+QhmPflAdJzzrFkWjRNPXRGs1KNTZUBwRhTLCIxWIZ7PIB3jTG7ReQZIN4YswqYKSKjgWIgB5hSdryIdMFyh/FFuaoXi0gAIEASUPu5jg5gjGFxymLCW4XznwFPI29cAx36UTx5BacKTpOVn2X5cy7rwufM/Ez25+5nS/oWFiYvZFy3cUzvM51A70C7zvnJwU8oNaVVfoHbo3e73gS0CGDzkc2V1ldUWsSsH2YR4hPCXb3uqvV5j+We443P0xjRuz3XdnXcm9tKqfpj19IVxph1wLpyZX+z+fw45e4AbLYdooKH0MaYIdVpaH1Jyk4iJSeFp65+ClnzEJgSGP0anp5eBHkGEdTy0u8eZJ7NZN6OeSzfu5yP0j5i0uWTmHrFVFo3b13pOVfvX02fdn3o7Ff7YZYm0oQhnYawav8qzhefv+T6Q3GpcaTlpvHKr19xSPrNf6613BQ+MbL2aykppZxD7+vLWZKyBF8vX0adyYe0jTD0aWgTZtexQS2DeOqap1g1ZhU3dbmJhckLuXn5zczdPpe8wrwKj9l7ei+pp1Mdmg9gSOgQzhWf49vj31a4Ped8Dq8nvc7VwVczJLT2cTnh8GnW7sxgxvXhdPRvUev6lFLOoQHBxomzJ9h4eCNjQ4bgveFv0OkaGDC92vWE+oby3MDnWDl6JQM7DuTtHW8zfPlw5u+cT37Rxa9hrDmwBk/xZHjYcEd1g6vaX3UhtWZF5m6fS35RPo8NeKzWzyyMMTz/SQoBvs2YPqj2y10opZxHA4KNuNQ4Sk0pE39cBx6eMOYtaFLzf6LL/C/jpcEvETcqjn6B/ZiTOIfhK4YTmxxLQUkBJaUlrD2wloEdB1Y5rFQdTT2aMih0EF8c/YLi0uKLtu3J2cOyvcuYePlEwv3Da32uz1Ky2HboNH+8oRveXrp4rlKNmQYEq4KSApbt/ZDraUFIzhGYsAhad3FI3RFtI3h96OvEDo+lm383Zm+bzYgVI5i9bTZZ+VmMDHd8+sihnYaSW5BLYmbihTJjDP/6/l/4N/Pn/r731/ocxSWlzFq/h8vatWR8VEXvIiqlGhMNCFbrD67ndEEukzMOwi1zoPO1Dj9Hv8B+zL9pPvNvnE/7lu1ZsmcJPk19GBwy2OHnuq7DdTTzaHYh7SVYEt8kZiXy4JUPVnvxvIosTzxKWtYZ/nJzD51mqpQL0Ht8rFNN4+cQXlhIdP/p0H9ynZ4vOjiaRe0XsfX4VjybeNY4E1llylJrbj6ymUevepRzxed4Mf5FItpEMLbr2FrXf66whJc37uXKTv7c1Kv27zAopZxPAwKQlPQOKQXZPNW8MzLs/+rlnCLCdR2vq9NzDO00lM/TPyc5J5ktR7aQmZ/JrEGzar1eEcC73xwkM6+A1yZd6bA8zkop59KAkL2XJd+/gG9zL0aNXQQO+LJsKAaHDMZDPIhNjuWzw58xvMtwIoMia13v6bOFvPX5fm6ICGRAWBsHtFQp1RC498Bvfg4nlo5nY/OmjO06Bu+W9r1Z3Fj4N/cnMiiStQfWIggPRzkmof3cLWmcLSzmUV3NVCmX4r4BoaQI4u4izvxEqTRhYt/qv2/QGJRlUpvWe5pD1itKz8kn9tvD/CYylG5BvrWuTynVcLjnkJExsO4RCg5/xbLwy7m+wwBCfF0zzeOYrmMAuL377Q6p76UNqYjAH4d1c0h9SqmGwz3vEL5/GxL+y/r+4zhdks/kiLqdVeRM3k29mRwx2SHrFe069hMfJR1n6sAwglvpEhVKuRr3Cwj7NsKnj2N6jGSx/Ex4q3Ci20c7u1WNwqz1e/D3bsqM62v/hrNSquFxr4CQlQIf/g6CepE0KIaUnD3cEXGHTpu0w9f7TvLVvpPE/LorrVrULMWnUqphc5+AcPYULJkAXt4waSlL0lZaVjV1QA6Cmko4nMPSH46Qd76o6p2dqLTU8K9PUujo30IzoSnlwtzjoXJxIXxwJ5zJhCnrOOHpycbDG7kz4k68m3o7pUlf7M3m3oXxFBaX8vfVuxlxRTATrgplQFibBnfHsnrHcXYfz+PfE/rSzNN13tNQSl3M9QOCMbD2ITiyFca9AyGRxCW+alnV9PKJTmnS56lZTI9NoGuAD0+OimDtjgxWJR1nxfZjhFkXihsX2ZFAX8cvaVFdBcUlvLghlYhgP27tW73UoEqpxsX1A4IIdOgPrTpB79spKClg+b7lXB96vVOmmm5JzeK+hQl0C/Jh0T3RtG7pxbXh7XhyZE/W7czgg23pzFq/hxc3pDLk8kAmRIUyuEcAnk5aPG7xd0dIzznHgqm9adKkYd25KKUcy66AICI3A3Ow5FSeb4x5vtz2KcALwDFr0VxjzHzrthJgp7X8iDFmtLU8DFgKtAUSgN8aYwpr1ZtLuWrahY/rD64n53yOU6aabtmTxX2xlmCweFo0/t5eF7a18PJgXGQI4yJD2J99hrj4dJYnHGVjciaBvs24PTKE8VGhdGnXst7am3e+iNc27+O6rm0Z1E3zJCvl6sQYU/kOIh7AXmAYcBTYBkwyxiTb7DMFiDLGxFRw/BljjE8F5XHACmPMUhF5C/jRGPNmZW2Jiooy8fHxVffqEowxTFgzgcKSQlbeurJex+o3pWRy/6JEure33BnYBoNLKSopZfOeLD7Yls7nqVmUGrj6sjY8fUsvIoL96rzNL36aytwtaayOGUjvkNovl62Ucg4RSTDGRFW1nz3jEAOANGPMAetv8EuBW2vZOAGGAMusRQuA22pTpz2SspNIyUmp96mmm1IymbEogR7tfVl8z9V2BQOAph5NuKlXe96dchVbHxvKIzd2Jy3rDA8sTuR8UUmdtjkz7zzzvz7ALX07aDBQyk3YExA6Auk2Px+1lpU3TkR2iMgyEbFNn9VcROJF5DsRKfvSbwvkGmPK8jteqk5EZLr1+Pjs7Gw7mntpS1KW1PtU08+SLcEgItiPRdOiaeVdszn87Vs1J2ZIN16Z0J8DJ88yZ9M+B7f0Yq98tpeSUsOfb+xRp+dRSjUcjnpSuRroYozpA2zE8ht/mc7WW5U7gFdEpFqvuRpj5hljoowxUQEBATVu4ImzJ9h4eCNju46tt6mmG3af4P7FCfQM9iP2nmiHvNA1sFs7xkeFMO/LA+w69pMDWvlLaVln+GBbOpOjO9OprXOm5Sql6p89AeEYYPsbfwj/e3gMgDHmlDGmwPrjfCDSZtsx698HgM+B/sApwF9Eyh5q/6JOR4tLjavXqaaf7j7BA0sS6dmhFbHTHBMMyjwxsidtW3rx52U7KCopdVi9YHlu8deVO/H28uTBIV0dWrdSqmGzJyBsA7qJSJiIeAETgVW2O4hIsM2Po4EUa3lrEWlm/dwOuA5INpYn2VuAsiU47wY+rk1HKlPfU03X7zrBA4sT6dWhFbH3DMCvuWOXemjVoinP3nYFKRl5zPvygEPrfv6TPfxwMIdnb+tFW5/aL4inlGo8qgwI1nH+GOBTLF/0ccaY3SLyjIiMtu42U0R2i8iPwExgirU8Aoi3lm8BnreZnfQo8LCIpGF5pvCOozpVXn1ONV2/K4OYJYn0DqmbYFDmpl7tGdknmDmf7SMt62eH1Lnqx+O88/VBplzbhTH9XXM5cKXUpVU57bQhqem007s/uZufCn6q86mmn+zMIOb97fQNacWCqQPwraNgUCb75wKG/fsLLmvXkg9nXItHLV4c23MijzGvb6VXBz+W3Hs1Xp7us8yVUq7OkdNOG71Xh7zKrEGz6jQYbEnNIub97fQL9WfhPdF1HgwAAnyb8fQtPUk8ksvCbw/VuJ6fzhUxIzYBn+aevDH5Sg0GSrkpt/if36pZK3q0qbvpk4dPneUP72+ne5AvC6YOwKdZ/a0Iclu/jgzuEcDs9amk5+RX+/jSUsPDHyRx9PQ53px8JYF+zl8/SSnlHG4REOpSfmEx98UmICK8fWdkvQYDABHhuTG9aSLw+IqdVHcI8LXNaWzak8VTo3oS1aVNHbVSKdUYaECoBWMMj6/YSWrmz8yZ2M9pc/Y7+rfgsRERfJ12kg8Tjtp93JY9WbyyaS9j+3fkLs1zoJTb04BQC+99c4iPk47zp2HdGdwj0KltmTygEwPC2vCPNclk5Z2vcv/Dp87yh6Xbuby9H8+N6d3gcjAopeqfWwSE4pLSag+lVOW7A6d4bl0Kw3oG8fvBzn+Bq0kT4fmxvSkoLuXJj3ZV2t9zhSUXDXO18NKkN0opNwkI/1ibwoPvb+dsQXHVO9vhxE/niVmSSOc23rw8vm+DyRNwWYAPDw3rzobkTNbtPFHhPpZhrh1OH+ZSSjU8Lh8QjDEE+TVn3c4MxrzxDQdPnq1VfQXFJdy/OIFzhSW8/dvIepleWh3TBobRu2Mrnl61i9Nnf5leYsHWQ3yUdJyHb3D+MJdSqmFx+YAgItw/OJyFU6PJ/rmA0a99zWfJmTWu75nVyWw/ksuLv+lLtyBfB7bUMTw9mjBrXB9y84t4dk3yRdt+OJjDP9amcENEEA/82vnDXEqphsXlA0KZgd3asfrBgXRp15JpC+N5aUMqJaXVe64Qty2dxd8fYcb14QzvHVz1AU7Ss4Mf9w8OZ8X2Y2xJzQIs+Q1+vziR0DbevDyh4QxzKaUaDrcJCAAhrb35cMY1jI8K4bXNaUz97zZy8+3L2rnjaC5PfryLgV3b8ciN3eu4pbUXM6QrXQN9eGLFTk6fLeT3ixPJLyzmrTsj62x9JaVU4+ZWAQGgeVMPZo3rwz/H9Gbr/pPcMvdrdh+vPK/AqTMFzIhNIMCnGa9O6u+0hPfV0czT0s+MvPMMn/MVCYdPM/v2PvRo3/CGuZRSDUPD/2arAyLCHdGdiLvvGoqKDWPf2MryS7zQVVxSysyl2zl5tpC37oykTUv70l82BJGdW/O7a8M4kXeee38Vxqg+HZzdJKVUA1a/6yw0MP07tWbNzIHELEnkTx/+yI9Hc3lyZM+LFnd7YUMq36Sd4oXb+zTK3MKPDu/BteFtGdyj5tnmlFLuwS3vEGy182nGonuiufdXYSz89jCT/vMdmdY3fdfuyODtLw5w59Wd+E1UaBU1NUzNPD24oWdQoxjmUko5l35LYJmq+cTInsy9oz8pGXmMfPVr4ral8+dlP9K/kz9/G9XL2U1USqk6pwHBxqg+Hfjogevwbe7JX5bvwNvLkzcnR2p+AKWUW3DrZwgV6R7ky8cx1zF3cxojewfTvpXmB1BKuQcNCBXwa96Uv46IcHYzlFKqXtk1FiIiN4tIqoikichjFWyfIiLZIpJk/TPNWt5PRL4Vkd0iskNEJtgc818ROWhzTD/HdUsppVR1VXmHICIewOvAMOAosE1EVhljksvt+oExJqZcWT5wlzFmn4h0ABJE5FNjTK51+5+NMctq2QellFIOYM8dwgAgzRhzwBhTCCwFbrWncmPMXmPMPuvn40AWoBPilVKqAbInIHQE0m1+PmotK2+cdVhomYj8YtK+iAwAvID9NsXPWY/5t4g0q+jkIjJdROJFJD47O9uO5iqllKoJR82nXA10Mcb0ATYCC2w3ikgwEAv8zhhTai1+HLgcuApoAzxaUcXGmHnGmChjTFRAgN5cKKVUXbEnIBwDbH/jD7GWXWCMOWWMKbD+OB+ILNsmIn7AWuAJY8x3NsdkGIsC4D0sQ1NKKaWcxJ6AsA3oJiJhIuIFTARW2e5gvQMoMxpIsZZ7ASuBheUfHpcdI5bs7rcBu2raCaWUUrVX5SwjY0yxiMQAnwIewLvGmN0i8gwQb4xZBcwUkdFAMZADTLEePh4YBLQVkbKyKcaYJGCxiAQAAiQBMxzXLaWUUtUlxlQva5gziUg2cLiGh7cDTjqwOY2JO/cd3Lv/7tx3cO/+2/a9szGmyoewjSog1IaIxBtjopzdDmdw576De/ffnfsO7t3/mvRdV21TSikFaEBQSill5U4BYZ6zG+BE7tx3cO/+u3Pfwb37X+2+u80zBKWUUpVzpzsEpZRSldCAoJRSCnCTgFBVPgdXJiKHRGSnNedEvLPbU9dE5F0RyRKRXTZlbURko4jss/7d2pltrCuX6PvfReSYTd6REc5sY10RkVAR2SIiydb8K3+wlrv8ta+k79W+9i7/DMGaz2EvNvkcgEkV5HNwSSJyCIgyxrjFyzkiMgg4g2W5lCusZbOBHGPM89ZfCFobYypcTLExu0Tf/w6cMca86My21TXrUjjBxphEEfEFErAsiTMFF7/2lfR9PNW89u5wh1DjfA6q8THGfIll+RRbt/K/FXgXYPnP4nIu0Xe3YF0sM9H6+Wcs66l1xA2ufSV9rzZ3CAj25nNwVQbYICIJIjLd2Y1xkiBjTIb18wkgyJmNcYIYa96Rd11xyKQ8EekC9Ae+x82ufbm+QzWvvTsEBHc30BhzJTAceMA6rOC2jGWM1LXHSS/2JhAO9AMygJec25y6JSI+wHLgj8aYPNttrn7tK+h7ta+9OwSEKvM5uDJjzDHr31lYliJ3x7wTmTbLrQdjSeXqFowxmcaYEmtiqv/gwtdfRJpi+UJcbIxZYS12i2tfUd9rcu3dISBUmc/BVYlIS+tDJkSkJXAj7pl3YhVwt/Xz3cDHTmxLvSqXq2QMLnr9rXlV3gFSjDEv22xy+Wt/qb7X5Nq7/CwjAOt0q1f4Xz6H55zcpHohIpdhuSsAS+6LJa7edxF5HxiMZenfTOBp4CMgDuiEZfn08cYYl3v4eom+D8YyZGCAQ8B9NmPqLkNEBgJfATuBsjS9f8Uylu7S176Svk+imtfeLQKCUkqpqrnDkJFSSik7aEBQSikFaEBQSillpQFBKaUUoAFBKaWUlQYEpZRSgAYEpZRSVv8PBN3rx7aHoK4AAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEICAYAAABYoZ8gAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3gbVdaH3yu5yFXuJXFNcboTYqdBKr2HtrQAGyCEhaXXZQsLfFvpSwm9BLK00AlZQoCYkACpdoqTuMYljh33Klfpfn+M5Mi2bEuW3OJ5n8eP5Jl7Z+7I1pk7557zO0JKiYqKiorKyEEz2ANQUVFRURlYVMOvoqKiMsJQDb+KiorKCEM1/CoqKiojDNXwq6ioqIwwVMOvoqKiMsJQDb/KgCOEWCyEOGJHuzwhxOnd7FsghMhw/ehUVE583AZ7ACoqfUFK+RMwYbDHoaIyHFFn/CoqVgiFYfm9EEKoEzkVuxiW/+AqQwMhxINCiI87bfuPEOI5IcT1QoiDQog6IUSuEOLmPp5mlhDigBCiSgjxlhBCZz5PB3eR2S10nxBirxCiRgjxoVXbQCHEOiFEmfk464QQUVZ9U4QQfxdCbAUMwL1CiF2druseIcQXvXwe5wkhUoUQtUKIQiHEI532zxdC/CyEqDbvX27e7iWEeEoIkW8e+xbzti4uMWv3lxDiESHEx0KINUKIWmC5EGK2EOIX8zmKhRAvCCE8rPpPEUJsFEJUCiGOCSH+KISIEEIYhBDBVu1mmj8vd7v+SirDCtXwqzjDB8C5Qgg/ACGEFrgceA8oBc4H/IHrgWeEEDP7cI5lwFnAWCAB+HMPbS8HzgbigURguXm7BngLiAVigEbghU59rwVWAn7Ac0C8EGJSp/3v9DLWBuA6IAA4D7hFCHERgBAiFvgf8DwQCswA0sz9ngSSgJOBIOABwNTLuSwsBT42n/O/gBG4GwgB5gGnAbeax+AHfAd8A4wCxgHfSylLgBSUz8/6ej+QUrbaOQ6V4YSUUv1Rf/r8A2wBrjO/PwPI6abd58Cd5veLgSN2HDsP+J3V7+dajt/5GOa211j9/jjwcjfHnQFUWf2eAjzWqc1LwN/N76cAVYCng5/Ns8Az5vcPAZ/ZaKNBuRFNt7Gvy+dkvs7Tze8fATb3Moa7LOcFrgJSu2l3BbDV/F4LlACzB/v/S/3pnx91xq/iLO+hGBSAq82/I4Q4Rwjxq9mlUI1itEP6cPxCq/f5KDPV7iixem8AfM1j8RZCvGJ2pdQCm4EA8xOKrfMArAauFkIIlNnvR1LK5p4GKoSYI4TYZHaR1AC/4/g1RwM5NrqFALpu9tlDh3ELIRLMrqwS87X+w44xAHwBTBZCxKPcwGuklNv7OCaVIY5q+FWcZS2w2Owzvxh4TwjhCXyC4sIIl1IGAOsB0YfjR1u9jwGO9uEY96JEAM2RUvoDC83brcfTQaZWSvkr0AIsQLmhvWvHed4DvgSipZR64GWrcxSiuKs6Uw40dbOvAfC2/GK+UYV2atNZXvcl4BAw3nytf+w0hjG2Bi6lbAI+Aq5BudHZc70qwxTV8Ks4hZSyDMVV8hZwWEp5EPAAPIEyoE0IcQ5wZh9P8XshRJQQIgj4E/BhH47hh+JOqTYf56929nsHZS2gVUq5xc7zVEopm4QQs1FuGBb+C5wuhLhcCOEmhAgWQsyQUpqAN4GnhRCjhBBaIcQ8880zE9CZF43dUdY3PO0YQy1QL4SYCNxitW8dECmEuEsI4SmE8BNCzOl0vcuBC1EN/wmNavhVXMF7wOnmV6SUdcAdKDPIKhQD+KUTx/4WyEVxU/ytD8d4FvBCmV3/irK4aQ/vAlOBNXa2vxV4TAhRBzyMcv0ASCkLUNxd9wKVKAu708277wP2ATvM+/4NaKSUNeZjvg4UoTwB9Jb4dh/K510HvIbVjdL8dzkDuADFLZYFLLHavxVlUXm3lDLfzmtWGYYIKdVCLCoqthBCeKFEJ82UUmYN9ngGAiHED8B7UsrXB3ssKv2HmvChotI9twA7RpDRnwXMRAkRVTmBUQ2/yqAhhIgBDnSze7LZPTIoCCHyUBZFL+q0PR0lH6AzN0sp/zsAQ+sXhBCrUa71TrNLSOUERnX1qKioqIww1MVdFRUVlRHGkHP1hISEyLi4uMEehoqKisqwYteuXeVSys55HjYZcoY/Li6OnTt3DvYwVFRUVIYVQgi7Q3DtcvUIIc4WQmQIIbKFEH+wsX+5OU09zfyzwmpfjBDiW6EoNR4QQsTZOzgVFRUVFdfT64zfnCb+IkrixxFghxDiSyll52iMD6WUt9k4xDsoYlcbhRC+2K86qKKioqLSD9gz458NZEspc6WULShSvHbF+QohJgNuUsqNAFLKeimloc+jVVFRUVFxGnsM/2g6KgAeMW/rzKVCKYLxsRDCIqyVgKKP8qm5QMUTnRQRARBCrBRC7BRC7CwrK3P4IlRUVFRU7MdV4ZxfAXFSykRgI4qkLSiupAUo+iGzUJQBl3fuLKV8VUqZLKVMDg21a1FaRUVFRaWP2GP4i+gojRtl3taOlLLCSqv8dZRqQqA8HaSZ3URtKMU4+lKFSUVFRUXFRdhj+HcA44UQ8ebanVfSSWlRCBFp9euFwEGrvgFCCMs0/lS6T9FXUVFRURkAejX85pn6bcAGFIP+kZQyXQjxmBDiQnOzO4QQ6UKIPShyvMvNfY0obp7vhRD7ULRPXnP9ZZxY1De38dHOQlQ5DRUVlf5gyGn1JCcny5GewPXyjzn863+H2HDXQiZE+A32cFRUaGhtoLCukIlBEwd7KCrdIITYJaVMtqetqtUzBNl0qBSAozWNgzwSFRU4VHmIy7+6nN989Rse2PwA5Y3lgz0kFSdRDf8Qo7aplV35VQAcq2ka5NGojGSklHyc+THLvl5Gk7GJayZdw3f537H086V8lvWZ6oocxqiGf4ixNaucNpPyhSpWDb/KIGFoNfCnLX/i0V8eJTkimbUXrOXB2Q/y8QUfMy5gHA///DA3fnsjeTV5gz1UlT6gGv4hRkpGGX46N4J9PChRDb/KIJBTncPVX1/Nutx13DrjVladtoogXRAAYwLG8NbZb/HXeX/lUMUhLv3yUl7Z8wqtxtZBHrWKI6iGfwghpWRTRikLx4cSFehFca1q+FUGlnW567jq66uoaq7i1TNf5Zbpt6DVdEy21wgNlyVcxhcXfcGSmCW8kPYCv/nqN6SVpg3SqFUcRTX8Q4gDxbWU1jWzaEIo4f461cevMmA0G5t59JdHeeinh5gUNIm1F6xlbuTcHvuEeofy5KIneeHUF2hoa+C6/13H3379G3UtauXGoY5q+IcQKRmKTtHihFAi9TqK1agelQGgoLaAa9Zfw8eZH3PD1Bt446w3CPMOs7v/ouhFfLH0C5ZNWsbazLVc9PlFfJ//fT+OWMVZhlwhlpFMSkYpU0f7E+avI0LvRW1TGw3Nbfh4qn8mle4pqi+iurma0T6j0XvqEULY3Xdj/kYe3vowGqHhhVNfYFH0oj6NwdvdmwdnP8h5Y87jkZ8f4a6Uuzg1+lQun3A5GmH//NJd4870sOm4a9z7NA4V+1AtyhChxtDK7oJqblk0FoBIvQ6Aktomxob6DubQVIYoTW1NvLL3Fd7e/zZtsg0AH3cfRvmOYrTvaEb7jmaUzyhG+5nf+47C38MfgFZjK0/vepo1B9cwNXgqTy5+ktG+tkR3HWNqyFTeP/991hxYw6q0VfxQ+IPDx5gXOY9nljyDj7uP0+NRsY1q+IcIP2WXYTRJlkxUZI3C/RXDf6xGNfwqXfm1+Ff+75f/o6CugKVjl7I4ejFH649ytOEoRXVFFNUXsb14O4a2juUv/Dz8GO07mmZjM4drDnP1xKu5L/k+3LWum2G7a9y5fur1nD/mfArrCnvvYMXByoM8seMJln+znFWnrSLUW1Xr7Q9Uwz9E2HSojABvd2ZEBwLHZ/xqLL+KNdVN1Tyx8wm+zPmSGL8YXj/zdeZEzrHZVkpJTXMNRQ1FFNUVcbT+KEX1Re2uoScXPclZcWf121hDvUMdNtwzw2cS4xfDvT/eyzXrr+Gl019iTMCYfhrhyEU1/EMAk0nyY2YZC8aHotUo/tkIK1ePioqUknW563hixxPUtdRx07SbWJm4Ep2brts+QggCdAEE6AKYEjxlAEfrHAuiFvDWWW9x6/e3cu3/ruWF017gpLCTBntYJxRqVM8QIP1oLeX1zSyZcHx2pHPXEuDtriZxqVBYV8jvvvsdf9zyR6L9o/nwgg+5Y+YdPRr94c6UkCmsOXcNgbpAVmxYwXf53w32kE4o1Bn/ECAlQxFlW5jQ8bE4wl83clw99WWQvwXytkLBr9BU41h/Dx+45hPQO79AOVRoM7Xx7oF3WZW2Cq1Gyx/n/JHLEy7vklB1ohLtF82757zL7T/czj0p9/Dg7AdZNmnZYA/rhEA1/EOATRmlTI/SE+Lr2WF7pF5HSe0JGstfVwJ5WyB/q/Janqlsd/eB6NkQMc3+Y7Ua4MDncPhHmHF1/4x3gNlfvp9Hf3mUQ5WHODX6VB6a8xARPhGDPawBJ1AXyGtnvsYfNv+Bf23/F8cajnFX0l0OhYiqdEU1/INMVUMLqYXV3HHq+C77IvRe7CtycOY7VKk5oszmLbP6yhxlu4cfxM6DGcsgbj5ETgdHI0xMRvjnt1C8d9gbfkOrgedTn+e9Q+8Rogvh2cXPclrsaYM9rEHFy82Lpxc/zT+3/5O30t+ixFDC3075Gx5aj8Ee2rBFNfyDzOasMqSExRO6Rj9E+Osor2+hpc2Eh9swneGkfwbfPQJVecrvOj3EnAzJ10PsKRCRCFon/w01WgifCiV7nR3toPPYr4+xPnc9l0+4nDtn3omfh1qIB0Cr0fKnOX8i0ieSZ3c/S0VjBc8seaY9L0HFMVTDP8ikZJQR5ONBYlRAl32WkM5jtU1EB3kP9NBcQ9r70NIAZ/0T4k5RDHR/+KgjE2HPh2AygWZ43iT3lu3l69yvuWnaTdwx847BHs6QQwjBjdNuJMw7jIe3Psxv//dbXjr9pRHpAnOW4fkNOUGwhHEuSjgexmnNCRHSWZ0P0XNg3q2KG6e/FiYjp0NLHVQd7p/j9zNSSp7Y8QQhXiGsmLZisIczpLlg7AWsOn0VxQ3FXLP+GrKqsgZ7SMMOdcY/iOwtqqGyocWmmwdOgCQuKaEqH8ad3v/nikhUXov3QPDY/j+fi9mQv4G0sjQePflRvN2H6dPdADJv1DzePvttbv3uVi798lLCfcIVeQrf0Yz2U6QqovyiGOU7inDvcNw0qqmzRv00BpFNh0oRAhaOt234w/XHZRuGJfWl0NYIAbEOddtevJ3Kpsp2zZkgXVDvwmNhk0Djrvj5p17ixKAHnmZjM8/uepYJgRNYOnbpYA9n2DAxaCLvnfcen2Z9SlF9EUfqjrDj2A7W5a5DcrwspFZoifCJaNcrGuU7iijfqPb/r1CvUJeEyEopqW2ppaheyZKubq4m3Du8/UY0lPIuVMM/iKRkljEjOoBAH9vRCX6ebvh4aIfvjL86X3kNtN/wN7U1cct3t9BiamnfptPq2r+kHb60fqOPK1K6eULYRGXGP8xYc2ANRfVFvHbmayMmRt9VRPhEcOuMWztsazW2UtJQwpH6Ix1kKo7WH2Vr0VbKGss6tHfTuDHKZ1RHcTur9yFeIe0Tj/qW+g7Hs7y3/F7fWt/tWEO8Qro9R6RP5IBGKamGf5Aor29m75Fq7j49ods2QggihnMsvyWSJzDO7i7pFem0mFp4aPZDjPYd3eVLtqdsD7UttR36+Lj7EOUbxQy9N7NK05nVWEGQV7DrrqMfKW8s57V9r7E4anGvhU9U7MNd6060fzTR/tE29zcbmymuL+5itIvqi9hUuInKpsoO7T21noR5h1HTXNPlf8/LzavdeCeHJ3cw5npPPccMx5Rz1BW1C+jtK9vHxryN7YqqAAJBqHcosyJm8a8F/3L9h9IJ1fAPEpszlTDOJRN6LngRqfcavjP+KvOMPyDG7i6ppakAnBt/LgG6rpFOAHUtdV1mcodrDvNVTS4fBnjCR4sZFzCOWRGzmB0xm+Tw5G6PNdisSltFc1sz9yTfM9hDGTF4aj2J08cRp4+zub+xrbHL/1dJQwl6T32XmXqAZ0CPbshRvqNs6gwZTUZKDaVdbjxBXkGuusweUQ3/IJGSUUaIrwdTRvUchxzur+OXnPIBGpWLqcoD3whw97K7S2ppKmP0Y3o01H4efkwImsCEoAkdtrfmbeHA+xezY8717DDW8Hn257x/6H0EgoTABGZFzGJWxCySwpPQe+r7elUuI6sqi0+yPuGqiVcRr48f7OGomPFy82JswFjGBvRfkIBWoyXSN5JI30iSSe6383SHXYZfCHE28B9AC7wupfxXp/3LgSeAIvOmF6SUr1vt9wcOAJ9LKW9zwbiHNUaTZHNWGadNDEdjI4zTmki9jmN1zRhN0mbI55CmOt8h/75JmkgtTeXM2DP7dDr3yBlMb25luiaYFac+Tquxlf0V+9levJ0dJTtYm7mWNQfXIBBMDJrI0nFLB037RUrJkzufxNfdl1um3zIoY1AZufRq+IUQWuBF4AzgCLBDCPGllPJAp6Yf9mDU/w/Y7NRITyDSCqupNrR2G8ZpTYReh9EkKa9vbi/OMmyoyoPYk+1unludS11LXd8leD19IXhc+wKvu9adk8JO4qSwk7h5+s20GFvYW7aXHSU7+PHIj/xr+7+YHDx5UCR/txRt4eejP/PArAeGxNOHysjCngSu2UC2lDJXStkCfADYHXMmhEgCwoFv+zbEE4+UjFI0PYRxWhNhNvbDTp65rQVqixwK5dxduhvAOUMcmditdIOH1oPkiGRumXELb571JmFeYTy+/XFM0tT38/WBVlMrT+58klj/WK6ccOWAnltFBewz/KMB6/ppR8zbOnOpEGKvEOJjIUQ0gBBCAzwF3NfTCYQQK4UQO4UQO8vKynpqekKwKaOUpNhA9N69i5FFDNckrppCkCaHInrSStMI1gUT7Wc7GsMuIqcr5zZU9tjM292bO5PuZH/FftYfXt/38/WBTzI/Ibcml3uS7nFpyUMVFXtxlWTDV0CclDIR2AisNm+/FVgvpTzSU2cp5atSymQpZXJo6IldY7O0ron9RbUs7iWax0J70fWaYRbS2YcY/t2luzkp7KTek7V6wjqDtxfOH3M+k4Mn8+yuZ2lsG5jPt7allhfTXmRWxCyWRC8ZkHOqqHTGHsNfBFhPwaI4vogLgJSyQkrZbP71dSDJ/H4ecJsQIg94ErhOCNH/Qap20mY0kVvWfcJFf/BjhvJEY49/HyDIxwMPrYbi4abX42AMvyW0zWl/e+R05dUOpU6N0HB/8v0cMxzjnfR3nDuvnby29zVqmmu4P/l+525wKipOYI/h3wGMF0LECyE8gCuBL60bCCEirX69EDgIIKVcJqWMkVLGobh73pFS/sElI3cBn6UWccYzmzlaPXCz6ZSMMsL8PJkcaZ+crBCCcL3n8JNtqMpXJBT8Intvy/H4facNv3cQ6KPtzuBNjkjm9JjTeWP/G5QZ+tfNWFhbyH8P/pel45YyKXhSv55LRaUnejX8Uso24DZgA4pB/0hKmS6EeEwIcaG52R1CiHQhxB7gDmB5fw3YlWSU1GE0SXbk9ewPdhVtRhObs8pYPCHUodlepP8wTOKqylMSt+yUIEgrTUOn1TExeKLz546crhRlsZO7k+6m1dTK86nPO3/uHnhm9zO4ady4/aTb+/U8Kiq9YZePX0q5XkqZIKUcK6X8u3nbw1LKL83vH5JSTpFSTpdSLpFSHrJxjLeHWgx/fqUBgN35VQNyvt0F1dQ1tfWardsZRbZhmBl+B2P4d5fuZlroNNw1LljsjEiEimxots+NF+Mfw7KJy/g8+3MOVXb513UJu47tYmP+Rm6YegNh3o79/VVUXM2I1uMvqFAM/66CgTH8KRmluGkEp4wPcahfpF4pui6l7L3xUKEq327/vqHVQEZlBjNCZ7jm3JGJgIRj++3usnL6SvSeep7Y8YTLP2eTNPH4jscJ9w7nt1N+69Jjq6j0hRFr+KWUFFQa0GoEB4vraGhu672Tk2zKKCMpNhB/nWOz2nB/HS1tJqoNrf00MhfTVAuNlXbH8O8r34dRGpkZPtM157cs8Drg7vH38OfWGbeyvWQ7KYUprhmHma9zv+ZAxQHunHknXm72y1eoqPQXI9bwl9U309hqZOH4EIwmyZ4j1f16vpKaJg4W17JkouOP+cOuIEt7KGecXc13l+5GIJgeOt015/eLBO8QhyWaL0u4jHh9PE/teopWo2tusoZWA8/ufpYpwVM4b8x5LjmmioqzjFjDb3HzXHSSkovW337+HzNLAfvDOK05XoJxmMTyt4dy2jfjTytNY3zgeNcVFhdCmfWXOGb43TXu3Jd8H/m1+XyY8aFLhrL6wGpKDaU8MOsBNGLEft1Uhhgj9j8x32z4p47WkxDuy65+NvybDpURqdcxIdxx4xapV9wDw2bGX2X/jN9oMrKnbI/r9XIiE6H0ILQ1997WigWjFzAvch4v7XmJmuYap4aQXpHOW/vf4ozYM1znxlJRcQEj1/BXGhACogK9SIoNZHdBNSZT/yyethpNbMkuZ/GEsD4l7YT4eqARw6gEY1UeeOrBK7DXplnVWTS0Nrje8EckgqlNMf4OIITgvln3Ud9az8t7Xu7TqaWUfHDoA65dfy16Tz33JfeoWKKiMuCMWMNfWGlglN4LTzctM2MCqWlsJbe8f7J4d+ZVUd/c1ic3D4CbVkOYn274zPir8yHQvuIru4+5QJjNFg5k8HYmITCBS8ZfwgeHPiCvJs+hvg2tDTy4+UH+vu3vzI2cy9rz1zLKd5TDY1BR6U9GrOHPr2ggOkhxoSTFKjPT/nL3pGSU4q4VnDLOsTBOa4ZVLH9Vnt0Lu2mlaYR7hxPpY1+Gr90ExoOHX59r8P5+xu/xdPPkqV1P2d0nsyqTK9ddyYb8Ddw5805eOO2FIVv5S2VkM2INf0GlgdggHwDiQ3wI9HbvR8Nfxqy4IHw9+17wLMJ/mMz4TSaoLrA7lNMlwmy20GgUP78DIZ3WhHiFsGLaClIKU9hWvK3X9p9nf86yr5dR31rP62e+zoppK9TFXJUhy4j8z6xvbqO8voWYYG9A8esmxQb2i+E/Wt1IxrG6Prt5LETodcPDx19/DNqa7JrxF9cXc8xwrP8KoUQkKklcJmOful87+VpG+YziiR1PYOzmGI1tjTy89WH+svUvJIYmsvaCtcyKmOXMqFVU+p0RafgtoZyxZsMPMDM2kJyyBqoaWlx6rhSzGuepfYjftyZSr6OuuY26piGexOVADL9LCq/0RGQitBoU+YY+4Kn15O6ku8moyuDLnC+77M+ryWPZ+mV8lv0ZKxNX8uoZrxLi1Xd3norKQDEyDb9Zo8fi6gFIilH8/KmFrp31b8ooZXSAF2NDfZ06jiWW/9hQ9/M7IMecWpqKj7sP4wPH989Y2jN4++bnBzgr7iwSQxN5LvU5Glob2rd/k/cNV6y7gjJDGS+d/hK3n3Q7WjsF6VRUBpsRaviVL3BM0PEZf2JUAG4a4VJ3T3Obka3Z5SyZ6Jgapy2Ol2B0LC59wLHE8Ot7r6KVWppKYkgibpq+r330SEgCaD2dMvxCCB6Y9QDljeW8uf9NWowt/GPbP7j/x/sZHzietResZf7o+S4ctIpK/9NP37ihTX6FAb2Xe4fSh14eWiaP8nep4d+ZV4WhxcjiBOfVGI8ncQ1u9q6h1YC3u3f3DarywG8UuPdcGL6upY6sqixOn3G6awdojdYdwqf0KaTTmumh0zkn/hxWp69mS9EWDlQc4LrJ13FX0l2uURNVURlgRuiM39DBv29hZkwgewpraDW6pvj2pkOleGg1nDwu2Oljhfl7AoNXdH3XsV3csOEGTnn/FNLL07tvaKcc856yPUhk//n3LUQmKjN+JxU375p5F6AUU3l28bPcP+t+1eirDFtGrOG3dvNYSIoNpLHVyKHiOpv9jCYj3+Z9y/uH3iezKhOT7PkGkZJZxpwxQXh7OP9gpXPXEuzjMeAlGNNK07jp25tY/s1ycqtz8XTz5PV9r3ffwc4Y/tTSVLRCS2JIosvGapPI6dBUo4SYOsEo31GsOXcNny79lNNiT3PR4FRUBocR5+ppM5ooqmrk/MSuCUPHE7kqmRalb99ukia+zf+Wl9NeJqcmp317oGcgyRHJzI6YzeyI2cTr49t9+YWVBrJL67lqtn0ZrPYQ7j9wIZ17y/ayKm0VW49uJUgXxH3J93H5hMt5be9rvL7vdQ7XHCZeH9+xU1sz1B61K4Y/rTSNCUETenYbuYIIqwVeBwrD2GJikAuqg6moDAFGnOE/Wt1Em0nanPGPCvAiUq9jV0E1y09RDP4PBT/wYtqLZFdnM0Y/hicWPcG0kGnsLNnJ9pLt7CjZwcb8jQAE64KZFTGLWRGzKC4ZDUiWOBm/b42lIEt/kl6ezotpL/JT0U8EeAZwT9I9XDHhinYDffWkq1mdvprV6at55ORHOnauOQLIXmf8raZW9pbt5bKEy/rlGjoQPhmEVvHzT76w9/YqKiOAEWf489sjenxs7p8ZG8iu/Ep+KPiBl/a8xKHKQ8T5x/HvBf/mrLiz2kP2Ro8bzdJxS5FScqT+CDtKdig3guIdfJP3DQD+CXpeOfgTc6rncHbc2U7PbiP0OlIL+6duwMGKg6zas4qUwhT0nnrunHknV028Ch/3jp9TiFcIF427iM+yP+P3M35PqLfVja3qsPLay8w6ozKDJmMTM8JcVHGrJ9y9IHRCnzN4VVROREae4beRvGVBSklgcDbVtW9y56YiYvxi+Mf8f3Bu/LndxmgLIYj2iybaL5pLxl+ClJLMysNc/OZqYkcXs614G+sPr6eyqZIV01Y4NfYIfx2VDS00tRrRubsmZjyzKpOX0l7iu4Lv8PPw47YZt7Fs0jJ8PbrPO1g+ZTkfZ33Muwff5Z6ke47vsFOOud+E2bojIhFyUwbmXCoqw4ARZ/gLKw14uGna4+JBMfhbj25lVdoq9pXvQ2iDuCzmPv60aN/QSjkAACAASURBVJnDMeZCCEoq/DBUzOaBC2axeEIoZ3x8BjnVOb137gVLEldpbXO73IQzPPbLY6zNXIuvuy+3Tr+VZZOX4e/h32u/aP9ozog9g7UZa7lp2k3HC6hU5Slx874RPfZPK0tjtO/ogSs6Hjkd9n4AdcfAL3xgzqmiMoQZcVE9+RUGogO90GiURdhfjv7Ctf+7llu+u4WKxgoenvtXjAX3I+pn9TmxKCWjFE83DXPHBCOEIE4fR35tvtNjd2Usf6mhlLWZazl/zPl8c+k33DLjFruMvoUbpt5AfWs9azPXHt9YnQ8BMYpAWjdIKdl9bDczwwawMEmkOXLIyXh+FZUThZFn+K1COX8o+IGVG1dyzHCMv8z9C+suXsdvJlxGYlQwuwr6nsiVklHGvLHBeHko7pg4/zjyavKQTsaSHy/B6PwCryUW/4oJV6D31PfSuiuTgyczN3Iuaw6socVo1jeqyuvVv3+k7ggVTRUD49+3EDFNeXUig1dF5URiRBl+KSUFFQ3EBisLljtKdqDT6lh38Toun3A57lolIScpNpD0ohqaWh1Xdcwrb+BweQOLE44vesb5x1HXWkdFU4VT449wYdH1A5UH0AgNE4Im9PkY10+9nrLGMr7K+UrZUJXfayinRZhtQGf8Or2iz68afhUVYIQZ/oqGFhpajO0z/pzqHOL18XhqPTu0S4oJpM0k2XvE8ZqrKRmWourH/ddx+jgAh6s5dcbX0w0/TzeXZO+ml6czRj8GLzevPh9jXuQ8JgVN4u30tzE2VEBTda8Lu6mlqfh5+DEmYEyfz9snIhNVV4+Kihm7DL8Q4mwhRIYQIlsI8Qcb+5cLIcqEEGnmnxXm7TOEEL8IIdKFEHuFEFe4+gIcoV2VM/i44R8XMK5Lu5lOVOTalFFGfIgPcSHHwyDj/OMAyKvNc/h4nYnQ65w2/FJK0ivSmRI8xanjCCG4YeoN5NXmsSnrM2VjL66e1NJUZoTOGPgiJZHTFVdUY/+Ew6qoDCd6/fYJIbTAi8A5wGTgKiHEZBtNP5RSzjD/WHL6DcB1UsopwNnAs0KIQatFZ63DX9tSS2ljKWMDxnZpF+TjwZgQH4cNf2OLkV9zK7oUXYn0icRD4+H0jB8Uw++sbMMxwzEqmyqZEuKc4Qc4PfZ0onyjeDP7EyT0OOOvbqomtyaXmeED6OaxYMngLdnXt/5tzbD6Qtj2iuvGpKIySNgz7ZoNZEspc6WULcAHwFJ7Di6lzJRSZpnfHwVKAdelsjqIJYY/KtC7PbzS1owflFn/7oIqhxZkf82toLnNxJIJHcMUtRotMf4xrpnxu0C2wbKw6+yMH8BN48byKcvZ13CEnTrPHn38aWVpAMwIHcCFXQvORvak/BMO/wipa1w3JhWVQcIewz8aKLT6/Yh5W2cuNbtzPhZCdBFjF0LMBjwA5wPa+0h+ZQMR/jp07lqyq5WqTLZm/KAs8FY2tJBnvlnYQ0pGKV7uWmbHB3XZF6+Pd4nhj9TrKK1ros0JBdH0inTchBsJgQlOjwdg6bilBAkP3ggMBq/uH+hSS1Nx07gxNWSqS87rEL5h4BfZtwXewh2w9T+gC1CeGAyVrh+fisoA4ipH61dAnJQyEdgIrLbeKYSIBN4Frpeyq6SlEGKlEGKnEGJnWVmZi4bUlYIKQ3viU051Dl5uXozyHWWzbZKDfn4pJZsyyjh5bLDNrNo4/ziO1B2h1eRc6cQIvRcmCWX1fS/Ikl6RzrjAcejcetbMtxedm45l+LFV50ZGZUa37dJK05gcPNll53WYiD4UX29thM9vUWoMXPoGIOHw5n4ZnorKQGGP4S8CrGfwUeZt7UgpK6SUFkv0OpBk2SeE8Ae+Bv4kpfzV1gmklK9KKZOllMmhof3nCSqoNBBrjuixiK51t8g4LtQXP52b3YY/t7yBgkpDt0XVY/1jMUojR+qO9G3wZiKdDOmUUnKg4gCTg20t0/SdK2pq8UbDm/vftLm/xdjC/vL9AxvG2ZnI6VCeAS32P8Xxw9+gIguWvgBjFoGHr+LysQOTSbIrvxKTybn8DRUVV2OP4d8BjBdCxAshPIArgQ6Vp80zegsXAgfN2z2Az4B3pJQfu2bIfaOxxUhpXXOHiJ7u3DwAGo1gZkwgu+00/Jai6osn2JYhcFVIZ7hZaqKvfv6jDUepbq52iX+/HZMJfXUhl/nEsyFvA0X1RV2aHKg4QIupZWATtzoTmQjSBKUH7Guf/zP88iIk3whjlygVvWJPgdzeDb+Ukoe/3M+lL/3CSz8OmndTRcUmvRp+KWUbcBuwAcWgfySlTBdCPCaEsOjc3mEO2dwD3AEsN2+/HFgILLcK9RyUb74llDM6yJua5hrKG8u7Xdi1kBQbSGZpHTWNvbtnUjJKGRfmS7QNuWdwMKSz9ih880clkqQTzs74Xbmw205dMRhbuHbUYoQQrE5f3aWJJXFrwITZbGFVfH1bbgUvbsrG2N1svKUBPr9VCU8947Hj28csgsocswR19zz5bQZrfi0gzM+T577Pao8oU1EZCtjl45dSrpdSJkgpx0op/27e9rCU8kvz+4eklFOklNOllEuklIfM29dIKd2twjxnSCnT+u9yuie/QpFjjg326XVh10JSbCBSQlovUsiGlja25VZ2yNbtjN5TT5AuyD7Dv/9T+PVFKPily64Ab3c83TR9lm1Ir0jHTePG+MDxfepvk2pFhygibCrnxZ/HZ1mfUdnUcQE0tTSVOP84gnRdF74HDH006AJoLEjld2t28cSGDG5/fzfNbTYytDf+VYn7X7oKPK2USuMXKa89zPpf3ZzDi5tyuGp2NF/cdgruWg1//mK/05IdKiquYsRk7rYnbwX1HsppYXp0ABrR+wLvz9kVtBhNLJnYs9qkRbOnVyyuiMLtXXYJIZRY/r7O+CvSSQhMwEPr0af+NmmXY47nhqk30GRs4v1D77fvllKSVpo2uLN9ACGQkYmUZGynocXITQviWb+vhJve2YWhpe14u9wU2PEazL0F4k7peIywyeAd0u0C7wfbC/jH+kOcnxjJ3y6aRqTei/vOTGBzZhnr9hb337X1I21GE3//+gBLnkzhg+0FTkWUqQwNRpTh99O5EeDtTnZ1Nt5u3kT6dC2/aI2vpxsTI/x79fNvyijF20NLclxgj+3i9HH2zfiP7VdebRh+6Hssv2Vh16VuHlBmxgjQRzEmYAyLoxfz/qH3MbQqN9vDtYepbq4efMMPZGnGMqo5hwfPGMOfzpvM45cmsiWrjOve2K649Jpq4YvbIHgcnPZw1wNoNBC/UFng7TSDX7f3KA99to/FE0J5+vIZaM0KsNfOiyMxSs+jXx2wy204lKhsaOG6N7fz2k+HMUnJHz7dx1nPbuab/cXqE8wwZsQY/vwKA7HB3ggh2hd2LfVxeyIpNpDUgqpufcFSSlIyyjhlXAiebj0XR4nzj6OyqZKa5h40gExGKDOHRB7ZDqaus6tIvY7iWselmY/UHaGupc7lET1U54P/aHBTNI9unHojNc01fJr1KQCpx1KBQfbvA0erG3kjxw9P0cbyBEVR9PJZ0bxw9Uz2HKnmqld/penrh6C2CC56WaneZYsxi5R1jfKs9k0pGaXc/WEaybGBvLQsCQ+3418trUbwj4unUdnQzBMbDvXrNbqS/UU1XPD8FnbmV/Hkb6aTct9iXr5GCdj73ZrdXLzqZ37JcU54UGVwGDGGv8BKjjm7OrtX/76FpNhAGlqMZJTU2dyfXVpPUXVjt2Gc1lgWeHvU5q/MhbYmJXqkqQbKM7s0idB7caym2eEwwfSKfljYhS5yzDPCZjAzbCbvHHiHVlMrqaWpBOmCiPV3rti5M0gpefCTvew3xQGgPXZcuuHcaZG8/ttZjC7/Cd2+NdQl3QrRs7o/mMXPbw7r3JFXye/W7GJ8mB+v/3ZWuxy3NVNH61l+cjz/3VbAbickvweKL9KKuOzlnzFJydqb53FZUhRCCM6eGsGGuxby+KWJlNQ0cdVrv/LbN7eTftRxQUOVwWNEGH6jSXKkykBMkA9VTVVUNlX26t+30J7I1c2XtbcwTmvaQzp7cvccSzef+Hrl9UhXd0+EvyctRhOVhpZez2lNekU6HhoPu6/dbqryu2j03DD1Boobivnm8Dftwmz2PGH1F//dVsBPWeVcfc4ScPfuksG7KNqNF/3eJotozt+7gNyy+u4PFhSvFJzJTSH9aA03vL2DUXov3rlxNnov92673XNmAhH+Ov746T5ah6ifvM1o4h/rD3LnB2kkjg7gy9vmMz26Yza2m1bD5bOiSbl/MX88dyJphdWc99wW7vwgVY1eGiaMCMNfXNNIq1ESG+xtd0SPhahAL0L9PLv182/KKGVCuB+jA3qXN47yjUIrtD0v8JYeAKGBieeBVyAUbuvSJMJcictRlc70inQmBE1orzvgElqboO5oF42eBVELGBcwjhfTXqSgrmBQ3Tz5FQ38Y/1BFowP4eq58Uphls4ZvP/7Ax6N5Wgufol6o5bfvPxLz7PY+EUYD//E8td/wc/TjXdXzCHE17P79ihrRo9cOIVDJXW8ueWwC67MtVQbWrj+7R28ujmX6+bFsmbFHEL9ur8mnbuWlQvHsvmBJdy6eCwb0ks47ekU/vrFfsrq+p5ZrtL/jAjD367K6UBEjwUhBEkxgTYje+qb29iRV2mXmwfAXetOlF9U7zP+oDHg4Q1Rs20u8Fpi+R0x/CZp6peMXWrMMk6dZvwaoeH6qde3J3OdFD44ht9okty/di9ajeDflyYqTx0RZm1+y/rJoa+VmrwL7mXs9AV89Lt5eLppuPLVX9mZZ1uXpzJ8HtrmGiZwmDUr5th14wc4a0oEZ0wO59nvsiisHDqz44PFtVzwwha25Vby+KWJPLZ0aod1ip7Qe7nzwNkT+fH+JVyWFM2abQUsemITT2/MpKSmqV8XgWsaW9WbTB8YEcXW881fsJhgb37IyMbX3Zdwb/uLbifFBvJNegmldU2E+R3XmdmaXU6rUdrl5rEQ5x/H4ZoeZnulByDcLGIWPRuyNiiiYN7H49/bk7gciOXPr82nobWhnyJ6sKnDf078OTyf+jxVTVVMDnLxDcdO3tp6mO15lTz1m+mMshjnyEQlXLPqsCK89tWdylPAwvsBGBvqy9pbTuba17dxzRvbeOXaZBZZ5WiU1zdz82ZvPgGeTKomItTXxpm759ELp3D60z/y1y/TeeO3yYPqAgMlGun+tXvx93Ljw5vnclJMz9Fp3RHur+Ofl0xjxYJ4nv42k+e+z+K577PQuWuIDvQmJsibmGDza5A3scHeRAV629S2stBmNFFc00RBpYGCSgP5FQYKze8LKg3UNLYiBFx80mjuOSOBqEDbCZQqHRkZhr/CgLtWEKn3Iqc6hzEBYxz6slkKs+zOr+bsqRHt21MySvH1dOs1jNOaOP84fjn6C0aTEa2m0z98SwNUHobEK5Xfo2crr0d2QsKZ7c2CfT3RaoRDIZ0HKpTcAFdo8HfAYvhtyDG7a9xZNvZeSgxFrnUv2Ul2aR2Pb8jgjMnhXDLTSlDWKoOXg18pxVmu/Rzcjuc2jA7w4sOb53Hdm9tZsXoH/7nyJM6dFkltUyu/fXM7OXU6DMEJRFR0dcX1xqgAL+45I4G/fX2Qb/aXcM60nsOK+wujSfLEhgxe/jGHpNhAXrpmZoeJTV8ZG+rLi8tmcuvRGnbnV5FfcdxQ/5JbgaGlY8JcuL8nsUE+RAd5MypAR0VDS7txL6pqpM0qiMFdK4gK9CY6yJvp0Xpig3woqW3i3V/zWbenmGvnxfL7JeMI8nFhnsoJyIgw/AWVDUQFeqPVKKGcS2KWONR/6mh/PLQadhdUtRt+Sxjn/HEhuGvt95jF6eNoMbVQ3FBMlF9Ux52lhwAJ4ebZ8aiZILTKAq+V4ddqBOF+ng4lcaVXpKPT6hijd3HJw6o8cNOBb8cnqEMltTz+TQY/HDLi5xnFvXNNDn1OztJmNHHPR3vw8dDyj4undbzRh04CjTv89DQc2wen/hkiukpFh/p58sHKudzw9g5ue283j144hS/3HCXzWB2vXZeMd+6psGu1Iq3h1rN/vzPLT47j091FPPJVOvPHh+CnG9gbY42hlds/SGVzZhnL5sTw1wum2O3asZcpo/RMGaXvsE1KSUVDCwWVyszd+qawNbucktomAr3diQnyJjEqgPMTI4kJUgx9TJA3kXqv9vwIa26cH8+z32Xy1tbDfLSjkJULx3DD/Hh8PEeEiXOYEfGpWEI5KxorqGquYqzevoVdC55uWqZF6Tv4+TOO1VFc08RdpzumJmqt2dPV8JsjesLMht/TVzFINhd4dZQ4EMufXq4s7LppXPwnr85XIlw0itEorDTwzMZMPksrws/TjfOmRfL1vmLSCquZFTdwcg0vpeSw90gNq5bN7LpA6eYBYZMUP/+omXDK3d0eR+/lzrs3zubmd3fxly/SEQKev+okxb0nF8G2l5V1mPgFDo3PTavhn5dM46JVW3nq20weudDFT2I9sLugirs/TONodSP/vGQaV82OGbBzCyEI8fUkxNeTmTZcSkaTtGnYe2NUgBePXzadmxaM4YkNGTy1MZPVv+Rz52njuHJ2zIBOOoYDJ/ynIaVsT95ydGHXmqTYQPYdqWnXddl0SAnjXJRgv38felHpPHZACTUMjD++LWo2HNkFxrYOTSP1XnbP+I0mIwcrD7revw/mGP44KuqbefSrdE59KoWv9xWzcuEYfnrgVP5xyTS0GsHmzP6rs9CZ9KM1/Of7LC6cPopzu3OjjE4CrSdc/DJoe74Zenu48fpvk1kxP57/XHkS5yeaazjEnaJEYNkp09yZ6dEBXDc3ltW/5LGnFz0oV9DUauSf6w9y2Us/09pm4oOVcwfU6NtDX4y+NePD/Xj1umQ+ueVkxoT68Jcv0jn96R/5cs/RIS+P3Wo0OV1P215OeMNfbWilrqmNmKDjoZzjAh03/DNjAmkxmthfVAso/v1Jkf5E6B3ziQbrgvFz97Md2VOaDqET22fPAETPgdaGLlLC4f46uyMm8mrzaGxrdL1/X0pkVR5p9XoWPr6J1T/ncenMKFLuX8xD50xC7+2O3sudGdEBA2b4m9uM3PvRHgJ9PHhsaQ/Xe9rDcPOPEDrBruN6umn58/mTuXC6VeEenV55YrBDprk77j1rAmF+nvzxs339qoGTWlDFec/9xCubc7liVjQb7l5IUuwgCub1M0mxgXy4ci5vLZ+Fl7uWO95P5YIXtrA5s2zISE1IKckurePtrYdZsXoHJz22kTveTx2Qc5/wrp72iJ4gb7ZV5+Dn4Ueol+PFXmbGKkksu/OrGB/uy878KlYudNxfLoQg1j/WtuE/dgAmnN1xmyWDtHDb8bqxKJE9hhYjdc1t+PfiH+6PjN2WNhMfb9nL1c11fFXgwYKJodx31gTGhXWNcFk4PpRnv8+ksqGl3xfd/vNdlhInvzyZAO8ezuUd1CFSqs+MWQRbnlU0fnT+Dnf317nz1wumcOt/d/P2z3msWODaNZimViPPfpfFq5tziPDX8c4Ns1nYg4rsiYQQgiUTw1iUEMqXe47y1MYMrntzOyePDeaaubHEBfsQE+yN7wCuA5TVNbM1u5yfssrb1zQAYoO9uXDGqA7RY/3JiW/4reSY/1uQzbiAcX0Knwvz0xET5M2u/CpGB3phNMkuRdXtJU4fx46SHR031peCoRzCOhnngFhl4bRwO8y+qX1zhFUsf6+GvzwdLzev9vUFZzCZZPuXSF+VztWesOysBYxZmNRtn4UJITzzXSZbsss7zphdzO6CKl7+MYcrkqM5daL94bpOEb8IfnpKKdrS+aZtJ+dMjeDUiWE8vTGTc6dFHg87dZI9hdXct3YPWaX1XJEczZ/On9Tr/8qJiEYjuOik0Zw7LZL3tuXz/A/Z3Prf3e37g3082hePY4OPLyTHBHkT4a9D44T7ydDSxrbDlWzNKmdLdjmHzNIvAd7unDI2hPnjQ5g/LqTbOh79xQlv+C1JMtGBXuTU5HBG7Bl9PlZSbCBbssvx07nhp3NjZkz3hcV7Is4/jnW56zC0GvB2N//BLVIN4Z3i3YVQwjo7STdEWBVkSQj36/F8ByoOMCloUtfwUQc5cLSWe9fu4WBxLZMj/fn3qf6wFcYk9Fw8PTEqAL2XO5szy/rN8De2GLnvoz1E6r348/mT+uUcNomeo0Q1Hf6xz4ZfCMGjF07hjGeU2P7Xrkt2akjNbcos/5Ufcwj31/H29bMcyjU5UfFw07D8lHiunB1D1rH69mgi5aeB1MIqvt5X3EGQ0UOrISrIi+hAb3TujnnGqxpaSS2sotUo8XDTMCsukAfPnsj8cSFMGeXv1A3FWU54w59fYSDMzxODqZqa5hqndGpmxgbyWWoRX+8rZsmEMNz6GClgWeDNr81nUrDZSFl8+J1n/KAs8B78CuqOgZ8yk42wswRjm6mNQ5WHuCzhsj6N1cJXe45y/8d70Hu5858rZ3BB4ig0P+9SdtqI4bdGqxHMHxfCT1mKf7U/EpYe33CI3PIG3lsxZ2BDI911ivF3ws8PSmW4u05P4F//O8SG9BLOmhLReycbWM/yL0+O4s/nTx6Rs/ye0LkrUXrTovRd9rUaTRRXKwlj+ZUN7WGnhZWNDusreXlouWF+PPPHhTArLqjHRLWB5sQ3/JWGPmn02CLJHH5maDHaLdNgC+uQznbDf+wA+ISBr43jRs9RXo9sh0kXAMdr7/YW2ZNbk0uTsanPC7tGk+TxDYd45cdcZsUFsmpZ0vHwyOp88Aqyy7e9MCGEr/cVk3GsjokRjvvCe2J/UQ1vbc1j+clxnDwuxKXHtosxi+D7x6C+zPbfz05unB/P56lF3P5eKvEhSkJTrFWma3SQN1GBXjYNSHObkee+z+LlH3MJ8fXgreWzei0MpNIVd61GyS4O9mY+g/C/NECc8Ia/oMLAyeOCyalWXCnOzPgnRPjh46GlocXIIicMf6x/LALRMaTz2P6ubh4LkdNB66H4+c2G38NNQ4ivZ6+x/M7U2K02tHD7+6n8lFXOtXNj+cv5kzsm+XSSY+4Jy4Li5swylxv+T3cX4aHVcPcZCS49rt3ELwYeU9w90/r+ZOWu1fDKtUms/jm/faa5Nbucxtbjma5CKE977T7pIG/C/XW8seUwGcfquCwpir+cP7lHlVAVlRPa8De1GimpbSI2SKmzq/fUE6wL7vPxtBrBvLEhVBlanEpt17npiPSJ5HCtWbPHZISyQ5B8o+0O7jrF+Bd29vP3nr2bXpGOj7uPw1r4h0pqWfnOLkpqmvjXJdO40la8d1V+h0ijnojUezE+zJefsspZubDvT12dMZkk6/cVs2hC6OAZu1EzwFPvtOEHJQjh4QuOTwCklJTVNx/Xp6loJL+ygcJKAz9llfFxrSJQFu7vyZvLkwduUVtlWHNCG/4jVWZVzmBvdpXkMFZvX9Wtnnj2yhmYXBAHHKePO16QpfKwUnyluxk/KO6e7a9BW0u7pkyEv1f7NXaHRZFTI+xfj1i/r5j71u7B19OND26eazPDEpMRqgvan0DsYWFCKO/+mk9ji9FmsZK+sDO/ipLaJh5KnOiS4/UJjRbi5jvt57eFEIIwPx1hfjqbcfdNrUaOVDUSqdep8gQqdnNCJ3Dlm+WYo4O8yK7OdkkBEl9PN5cslsX6x5JXk6ckk3SWarBF9GwwNisyA2Yi9br2OGBbtJpayajMsNvNYzRJHv/mELf+dzcTI/xYd/t820YflNKDptYucsw9sTAhlJY2E9sOu65c37q9R9G5azh90iDPdMcsUtY8LKJ1A4TOXcu4MF/V6Ks4xIgw/L7eBupa6pxa2HU1cf5xGNoMlDWWKQu7CCVrtzuizEqdVro9EXod1YZWmlqNNrvkVOfQYmqxS4O/xtDKjat3sColh6tmx/D+yrmE+ffgzupBjrk75sQH4emmYXNmud19esJokqzfV8KpE8MG3/DFL1ReD28e3HGoqNjBCW34CyoN+HhoqWgpAJxb2HU1HTR7Sq2Kr3SHfyToYzr4+S0hnd3pe9i7sJt5rI6lL25ha3Y5f794Kv+8ZFqvheOpMrupHJjx69y1zI4PYnOWa+QbtuVWUF7ffFw7ZzAJnagk2vWDu0dFxdWc8IY/JtiHnBpFnG0ozfjj/RUhtrzaPGXG35N/30L0bGXGb15jiNT3HNKZXpGOn7sf0X7R3R7ym/3FXPziVhpajLx/01yWzbFzBl+VpwiU6bs/ti0WJYSSXVrP0Wr7lUW746u9xXh7aPucQe1ShFBm/Yc3t/99VFSGKie04c+vaGgvtxjoGUiwV98jelxNuE84Oq2Ow1VZUJlrO3GrM9GzFd96zRHASrahm5DO9Ip0JodM7nZB+z/fZfG7NbsZH+7HV7fNJ9kR2eTqfPCPAgcLrCwYfzys0xlajSa+2V/M6ZPCXbZQ7DTxi6ChFEoPDvZIVFR6xC7DL4Q4WwiRIYTIFkL8wcb+5UKIMiFEmvlnhdW+3wohssw/v3Xl4HvCZJIUVjW2J28Npdk+KDVpY/1jySs/QIfiKz3RXpFLcfdE9DDjbzG2kFmV2a2b5+eccp75LpOLTxrNhzfPdVhl1JEYfmsSwn2J8Nc57e75OaeCKkMr5ycOTvUqm4xZpLz2UaZZRWWg6NXwCyG0wIvAOcBk4CohhC0r9aGUcob553Vz3yDgr8AcYDbwVyFE3wp6OkhJbRMtbSaig5Ryi0PN8IPi58+rU9Yf2uvs9kT4VHDzavfze3u44a9zsynbkFWVRZupzabhN5okj311gKhAL/v8+baoyu9VqsEWQggWjA9hS1a5UzLE6/Ycxc/TbWgpTQbEKLUUVD+/yhDHnhn/bCBbSpkrpWwBPgCW2nn8s4CNUspKKWUVsBHom5KVg1gievx9DdS31g+phV0Lcf5xHG2ppsXNjums7wAAIABJREFUy75FUq27UkDEaoG3u4IsFilmWxE9H+wo4FBJHX88d1Lf9ENaG6G+xKGFXWsWJoRS29TGniM1ferf0mZiQ3oJZ0wOH1L6J4Ay68/f2qVwjl1ICRsfhhdmQ8Y3rh8bKPkXv74Mz82EdXcruRgqIw57DP9ooNDq9yPmbZ25VAixVwjxsRDCsuJnV18hxEohxE4hxM6yMtdEfFhUOY3aEmBoLexaiPWPxQQUho9TkoDsIXq2EsvfolxfRDex/AcqDqD31DPat+PHXdPYylPfZjI7PohzpvZNCKzdWPTB1QMwf1wIQsBPfXT3/JRVRm1TG+dPH0JuHgvxi6C5Fo46WFBDSvjfg7D1P9BYCe9fAR8sa1/PcQlFu+C1JfDNg+DhA7vfhedOgi9vH/D8A5XBxVWLu18BcVLKRJRZ/WpHOkspX5VSJkspk0NDXfPonl/ZgJtGUNWmhB0OxRl/vN4c2RNg6z7aDdGzwdTWblgi/HXdzvinBE/psrD73PdZVBlaePj87hd9e6U9hj+uT90DfTxIjOp7Va51e4vRe7kzf9wQcvNYaI/nT7G/j8kEX98L21+BebfB3Qfg9Ecg+3tl9v/zC317grDQVANf3wevnaYovF72Fty8Ge5Mg6TrYc8HyhPA579XAg1UTnjsMfxFgHXMXpR5WztSygopZbP519eBJHv79hf5FQZGB3pxuDaXIF0QgboBWVpwiDitUq3qsHfPevodiOq6wFte39xBMraprYnsquwu/v2csnpW/5zHlbOimTq6qySt3Vhi+Pvg47ewaHwIaYXV1BhaHerX1Gpk44FjnDUlvKNg3FDBJwTCp9nv5zeZ4Ou7YecbcMpdcObfFEmO+XfD77cpUhDf/gleXQyFO3o9XAekhH0fwwuzlOPPXgm3bYeplyjhp/ooOO9JuHOPUuRn/8fwfDJ89jsoz3b40lWGD/Z8c3YA44UQ8UIID+BK4EvrBkII62fuCwFLPNsG4EwhRKB5UfdM87Z+p6DSQIw5lHMozvYBfKvyCGkzkueI/fIJhuBx7X7+SL0OKaG0rrm9SWZVJm2y68Lu378+iJe7lnvPtK/ObLdU5yuLzL59j59fmBCKScLWHMeyeFMyyqhvbhsaSVvdMWaR8vdp7SVXwWSCdXfCrrdhwb3KLN/6KSwwFq7+EK5Yo7h/3jgDvroLGqt6H0NFDrx7MXxyI/hFworv4dzHlTrBnfEfBef8W7kBzL0F0j+HF2fBJzdBWYYDF+4kLQY4mqboUan0K72aHCllG3AbisE+CHwkpUwXQjwmhLjQ3OwOIUS6EGIPcAew3Ny3Evg/lJvHDuAx87Z+J7/CoFTdGqIRPQAcO0Bcayt5bXWO9Ys6nsh1vATjcSPTXmPXSoM/JaOUHw6Vcvtp4wjx9XRu3JZQTicE76ZHB+Dn6eawu2fd3qME+Xhw8tihk5PRhfhFiq5Swa/dtzEZ4cvbYPc7sOhBOPUvtj9PIRQhvN9vg3m/V9o/nwx7PrSdKNbWDCn/hlXzFJ/+uU/CTT/A6Jm9j9svAs76O9y1T3E5HVoHL86BtdebZUVcTHO94s76/jF440z4Vwy8ugheng95W11/PpV27BI4kVKuB9Z32vaw1fuHgIe66fsm8KYTY3SYGkMrNY2tBOkbMNQZhuyMn9J04qSWjQ0Oer+iZ8Oe96Aylwi94ue29vMfqDhAkC6IcG9FuKzVaOL/1h0gLtib/2/vzuOjru/Ej7/euckJOYYrgYTThEPAgAcV8KqKVlfZtSoerG67urXratuVuodWWyv9Vav+lLZ23dXtsT66tVoP1EIVFRU5rAXDlQCBJGCOSUIIEHJ99o/PTDKESTKTzOT4zvv5ePBI5jvf+X4/Xwbe85nP5/19f1acl9f/dtcd6PP4vldsdBTnTcng/T2Br8p1vLmVP+2s4pp54/u8+tmAmHgeRMXYfP7JF5z+fHsbvPIPsO1FWPJdWHLarTGni0+xQXn2V202zstfhz//Eq54HLI86xDsW2/nCtwlMHMZXPqIDebBSs6CLz8MC++Gj5+BTc9C0e9h8oWQlQ8jc2zqaprn54gAlyBtarAfhgc22MB++DM7XyXRMG4unPsPNh12w+Pw/FKYsxwuecgOn6mQcmRJv4OejJ7ohCpgaGb0AFBZRG6iiyMn66hrqgt8HsK7IlfZJsZ6llT0rddT5C6iIKNz8vZXGw+wt/oYv7ilsP/j4sbYHv/E8/p3HOxwz9tFleytbmSKq/d5jnd2VXGipW1o3bTlT3wyjC/0P87f1gqv3AHb/xcu+FdY/J3gjj12Nty+Fj59HtY9CD89Dxb+o8202v6/NnDe9HuYclH/ryMpEy5+AM77pv0A2PW6DdwtXUqBx6faDwDfD4OROfb3xkoo3WBTXA//BUw7RMXabyAL74aJC+2/5/jkzuPN/iq8///go6dg9xob/OfcBFFD+MN+mHFk4D9QewyAZjkEDM2MHtrboGoXebOWQv1mShtKAw/8WWfY/2xln5B65vWMiI3uCPwnWk+wt34vF+ZcCEDdsWaeWFfM+VMzuTg/BDVtTtRB89F+9/gBFnnKN7y3pyagwP/6Xw6TlRLP2XlDeJjHa9JiG7xO1Hf2iNtabU/985fgogfg/Hv7duyoKCi8Dc64Ev74r/DBY3aFtsX32Unh2BGhuw6AxHS46N/sH2PgeK2d56k/CEfK7M/6g/ab4P4P7L8PX9FxkD0fzv825C60Q5U9FSSMS7QfOLOvg9fvtemmf/41XPk4jO7bEqLqVM4M/J6bt2pbysgckUlafD8yWMKlrhRaT5DrmmMD/5FS5rrmBvbaqCjILoTyzYgIY9MSOOzJ5d9du5t2094xsfuTdXtoPNnKv/UnffOUdntWDetjDr+vnPREJmUm8f6eam7/Us9DUI0nW3l3dxXXz88hOir0i7WHXN5ieG+V7e3mXwltLfDS38GOV2wPduHd/T9HsguufdZm64wYBRkD8M1WxCYYJGX4nzcwBprqOz8MEkbaf6t9+TBy5cPfroHPfmM/4H6+yM5zLPbch6D6zJHfncpqj5OZHMeBo/uG9DAPwLjsc4iJirFVOoORvcAeo6mB0akJHWUbfCd2d39xlF9tPMDysycwbXQQKaM96UM55p4smpbFJ/vd3a4p4LVuRyUnW9u58swhnM3jK7vQZj7tf89mqfzub23Q//IPQhP0u55rIIJ+IETsh9DYM+2kdN75/fsGIgJzl8M3t8KZN9gb3J45G3at6f213THGZlQF+yfcjOm4MTPcHNvjz0lPYN+RfVw79drBbo5/VXbxlZjRM8lJyTl14fVA5CwADFRsZWzaKD7Zb5OlimqKyBqRRdaILO79zSZSEmK55+IQLkLuvXmrHzn8vhZNy+T5j0rZUlrHl6Z2P4n3+rZDjElN4KzuVgQbamLiYeK5sPcdG/R3vQ6XPWrTJVXwEtPh6qdh7k12cvvFG2D6FTYNdWSX0uDGwLFqz7eOA1Bf1mVYqgxajgXfhqSsU+cwRk489XF8L50rY+BYjactBzu/Ffm2b+yZ9ltOmDky8B+sPc6sia2UNJ8Y2j3+9DyISyQ3NbcPPf5CQKBsE2PSrqayoYn2dsMO9w5mZMxg3c4qNpTU8MBXChiVFBe6dtcfgMTMUyfj+uGcSRnERUfxfnF1t4H/yIkW3t9Tw83nTiRqOAzzeOUthnUP2CybpT+2N0mp/plwjr3reONqWP8oPLMAzlphJ5y9QfRImV3D2teIUTZIZ0yByRf5v5+hJ6bNTlTXH4TKz2H3mzZl1985vBPdI9KhocLnQ6cMWrvc25GQZvfNmAyTlsCYAIo1hoDjAv/J1jYOHTnBguQjUDtEJ3bB9vg9a+zmpuXyQcUHtLa3EhMV4FuSkGbHQMs+YcyUr9Labig7Use+I/u4aMIl/OCNHUxxJXPTOaHpmXfoYznm7iTGxVCYO4r391Rz/9J8v/us3VFJc1v70M/m6eqMK+Cj/w8X3A/zbx/s1jhHdKwdLptxja1vtHG17YyMnGDLm0+/LPjeeLDa2+23iiNlnRPd3p67u8R+02s5DokZth1ZZ8DUL3fJfsoJ/gMoRBwX+MvrTtj7WuKGbnE2mo/bmigzlwF2Na7W9lYONR5iQuqEwI+TswA+f5kxc22PflP55xgMh6oyKXUf54XbFhAb6nz3ugOB3QwUhPOnZrHqrV1UNjQx2s86v69vO0T2qBHMyQkwX3yoyJwK3ynp141uqgcjJ8AN/2MnzoNcEKjfoqIgZbT9k114+vPG2JvpYoNc52KAOG5y15vDf9xU4BrhIjUudZBb5Ef1LpvP7NPjB4If7sk5G04eIdfYCo6fVW0H4LVNUVx4hovFoa5V395mezghGt/3WjTNDvH4u4u37lgzG4pruGL22NBkJQ204djm4Wagg34gRIZs0AcnBn5PKmf1yYNDs7cPnoldOnKSc1NzAdh/ZH9wx/EUbBvbsA2A4iM7SZB0mpqS+Jcr/A+b9EtDhb3TMoRDPQD5Y1LJTI7n/eLT6/a8XfQFre2Grwzl2jxKDTOOC/wH3MdJjBPKjpYO3cBfuQNiEiB9EgCjEkaRFp/GgYYDwR0nYzKMSCe5+lNio4V9DbtobBjDivNymZwVmsnXU/SzHHN3oqKERVMz2VBcTVv7qfVnXt92mNyMRGaMG4Lf3JQaphwX+A/WHmNc5gma2pqG8MRukZ3s8Vl8ZWLqxOCHekQg52ykbBNZqYaTUklc20S+edHU0LbXy73X/hwVgno/XSyalkXd8RY+r+hclaum8SQf7a3hytnjhucwj1JDlOMC/wH3cUam2Zz2Id3j73LreW5qbvC5/AA588FdzNg0+9q/nnkOaSPCNObpLrE3JaXl9L5vkLypnL6rcr35+Re0G4bmSltKDWOOCvzGGA7WHicucQgXZztWA8eqOiZ2vfLS8qg+UU1jc2Nwx/MUbMtJ/ByAO89dEopW+ldTbIeXwlAsKzM5npnjU3l/T+c4/+t/OcQUVzLTQ3XXsVIKcFjgrzl8ENN6krboLxidOJqUuCEYMDylGhh9auD3TvAGPc4/bi5GommI2824pHFkJqaHoJHdcBfbG2DCZNHULD49WMfRphYqG5rYVFrLlcM1m0epIcw5gd+9l4zn5nNd9Hoa2sqH8Pi+J6PHdfpQD8D+hiAze+KSeHXcNDafrOaWGbeEoIHdaG22OfyZYZo/wI7zt7YbPtrrZs32wxjD0F5pS6lhyjmBP30StakF3BHzB6qahnAqZ2WRvZuvy7KFE1InECVRQY/zVx2vYlX8SeadbOGGqX8TwoZ2Ubff3raeEb7AP2/CKJLionl/TzWvbzvMGWNSmOIKQ3aSUhHOOYFfhHfH3k5bbAPN7c1Dt8dfWWTH97sMX8RFxzEuaVxQmT3GGB7e+DDNwENV1UR5v02EQ80e+zMzfH+vcTFRnDs5gzc//4KtB+r4ynCpxKnUMOOcwA9saJvB2nibGz85OXuQW+NHe7u9a7ebxSRy03KDGuN/c/+brC9bzzcLbmViayuUbw5VS09XU2x/hrHHD3a4p/aYXWx72NXmUWqYcFTgP1B7gj+lzQFg8r4huFhz3X5buKlLRo9XbqoN/O2m99rf7hNufrjph8zOnM1Nc++ClLF2AfZwcZdA8hhICO+NVN5VuWaNT2Nihi62oVQ4OCrwH6w9Tm1SFGOJJumjZwZsUYOAdZRq8F96NTc1lxOtJ6g6XtXroR755BGOtRzjoYUPER0dYwtFVWwNZWtPVVMc1oldr9zMJJbNy+bOJUN0jkYpB3BM4D/a1ELtsWZOyiEmp+fbXPktzw12s05VaRdfwXWG36e9xdp6q9mz9sBa/njgj9x55p2dk9ijZ0Lt/vB92IU5ldPXY9edydJZOsyjVLg4JvC3t8OdS3I50lrBlLGFMOkC2PAEnAzyhqhwqiqydW66WS/Um9LZ0wRvfVM939/4ffLT81kxc0XnE658wEDN7lC1ttMxt11kfQB6/Eqp8HNM4E9LjOW6cxNpNS22F3zB/XC8Bjb/YrCb1slPqQZfrkQXiTGJPaZ0rtq8ioaTDTy88GFio3xKM3jnDap2hqixPrwZPWGe2FVKDQzHBH6AvfW2iNiUkVPsIiVTLoYPn4KTRwe5ZUDLCajd2+3ELoCI9Fis7b2y93h93+t8bfbXmJ4+/dQn0ydBdHznncGh5PZk9GiPXylHCCjwi8hlIrJbREpEZGUP+y0TESMihZ7HsSLygohsF5GdIvLdUDXcn5L6EgAmpdmUTpbcDydq4ZOfh/O0gfEuvjK6+8APdpzfX4+/obmBhz5+iKmjpvK1WX7Wbo2KhqzpYerxF9sPlZFBrA6mlBqyeg38IhINPANcDhQAN4jIadFLRFKAuwHfnMK/AeKNMbOAs4C/F5Hc/jfbv731exmfPJ7E2ES7IfssmHaZXfe06UjPLw63Sv+lGrrKS83j8LHDNHVZLPrHm3+Mu8lth3i6W3HIVRCewO8usd8ofMpIK6WGr0B6/AuAEmPMPmNMM/AicLWf/R4GVgG+EcsASSISA4wAmoGG/jW5eyX1JaeXaliyEprqB7/XX7XD9po9i690JzctF4Ph4NGDHds+rPiQl0teZsWMFczI6OGDw5UPRw/ZidhQqikO6x27SqmBFUjgHw+U+Twu92zrICLzgBxjzBtdXvs74BhwGDgI/NgYU9v1BCLydRHZIiJbqqtPX3c1EC3tLZQ2+Fl1a9xcmH4FfPQ0nKjv07FDorLIDsVE97y+/cRUu6yhd7insbmRBz9+kLy0PO6cc2fP5+iY4N3V39Z2amuxN57pxK5SjtHvyV0RiQIeB77l5+kFQBswDsgDviUip3V5jTHPGmMKjTGFWVl9WyC8rqmO7ORspo2advqTS1bCySOwcXWfjh0SVT1n9Hh1Ten8ydafUHmskofOe4j46PieX+zK7zxXqNQdsOvs6sSuUo7Rc/fTqgB8l1zK9mzzSgFmAus9ddPHAK+KyFXAjcBbxpgWoEpEPgQKgX0haPspXIkuXrvmNf9Pjp0N+V+BjT+Fs++AcNas9+eYGxorAwr8ibGJuBJdlB4pZdPhTfx2z2+5peAW5rjm9H6etGyITw1t4NdUTqUcJ5Ae/2ZgqojkiUgccD3wqvdJY8wRY0ymMSbXGJMLbASuMsZswQ7vXAggIknAOUAIxyGCsOS7cLIBPn5m4M9d5Umx7CGV01deah676nbxwEcPMCFlAnfNvSuw84jYXn8oJ3g7Ujl1jF8pp+g18BtjWoG7gLeBncBvjTFFIvKQp1ffk2eAZBEpwn6A/JcxZlt/G90no2fAjGvgk5/ZHvhA8mb0BNDjBzvBW1xXTHljOd8773uMiBkR+Llc+bbHb0wfGupHTTEkZcGIUaE5nlJq0AUy1IMxZg2wpsu2f+9m3yU+vzdiUzqHhsUroegV+OgpuOR7A3feqiIYkQ7JowPa3TvOf/306ykcUxjcuVwFsPV5O7SUMia41/rjLtFhHqUcxlF37vbKdQbMXAabfgGNfcse6pPKItvbD3Dt2IsnXszy/OXcc9Y9wZ8r1BO8msqplONEVuAHWHwftJ6Aj54cmPOVb7Vj7gGO7wOMSRrDygUrO29EC0Yoa/Ycr7X1jrTHr5SjRF7gz5oGs66DTf8BRyvDd56yTfDLa+E/LoSYeJh9XfjO5Ssp047Jh6LH77YlMDSVUylnibzAD7D4n6GtGT4MQ6//wMfw31fDc5fA4c/g4gfhn7bbhVIGiqugc0K5P7zLLWb6uTdCKTVsBTS56zgZk+HM6+1CLed9E1JDsOjH/g/gvVVQ+oHtcV/yMMy/vdva+2HlKoBPX7CLFET147PdXQxRsTByYujappQadJHZ4wdY9B1bjmDDT/p+DGNg33r4r6XwwpX2ZqdLfwh3b4OF/zg4QR/sBG/LcagPfOF2v2qKIT2v1zITSqnhJXL/R6fnwZwbYdPPYedrtuTwyBz7M83zc+REezdsbMKprzUG9r4D7/0Iyjbahc4v/xHMuwVig8i5DxffCd70vL4fR1M5lXKkyA38AJf+AEZNtGvV1h+0E7JFL9vaNL6SR/t8GOTAgY+gfDOkZsMVj8Gcm07/cBhMWZ5FWqp2wBlL+3aM9jao3QfTLg1du5RSQ0JkB/6ENDvk46u9DY4eth8E9QehvswOmdQftJO1O1+zcwJXPmG/McT0UjhtMCSkQtqE/qV01h+wE+Da41fKcSI78PsTFW2Hd9KyYeJ5pz/f3m5vxArwZqxBM7qgfymdmtGjlGNF7uRuX0VFDf2gD3aCt2YPtDb37fU1us6uUk6lgd+pXAV2rqJ2b99e7y629YUGuoS1UirsNPA7VX9r9tSUaG9fKYfSwO9UGVNBovs+wesu1oldpRxKA79TxSbYO5T7EvibjtiyzlqVUylH0sDvZK58WxI6WDWe4mza41fKkTTwO5lrBtSVQvOx4F7n1lROpZxsWOTxt7S0UF5eTlNT02A3ZVAkJCSQnZ1NbGxscC905QMGqnfD+HmBv66m2M4PjMoN7nxKqWFhWAT+8vJyUlJSyM3NRYZDDn0IGWNwu92Ul5eTlxdk3R3fmj3BBH53sQ36MXHBnU8pNSwMi6GepqYmMjIyIi7oA4gIGRkZffu2k54H0fHBp3RqKqdSjjYsAj8QkUHfq8/XHhVtC7YFk9nT3mZv+srQjB6lnGrYBH7VR66C4AL/kTJobdIev1IOpoE/QE899RT5+fksX768232ef/557rrrLr/PJScn+93+1ltvMX36dKZMmcKjjz4akraeYnQBHD0EJ+oC29+byqkZPUo51rCY3B0KVq9ezbp168jOzg7ZMdva2vjGN77B2rVryc7OZv78+Vx11VUUFBSE7BynTPD6qzbalTeVU3P4lXKsYRf4v/daETsONYT0mAXjUnngKzO6ff6OO+5g3759XH755dx2223ceuut3Hbbbezbt4/ExESeffZZZs+efcpr9u/fz4033khjYyNXX3213+Nu2rSJKVOmMGnSJACuv/56/vCHP4Q48PvU7Akk8NcU23UKkjJD1wal1JAS0FCPiFwmIrtFpEREVvaw3zIRMSJS6LNttoh8LCJFIrJdRIbQUlWB+dnPfsa4ceN49913ueeee3jggQeYO3cu27Zt45FHHuGWW2457TV33303d955J9u3b2fsWP+LuVdUVJCTk9PxODs7m4qKitA2PnU8xKcGPs7vrdETwZPpSjldrz1+EYkGngEuAcqBzSLyqjFmR5f9UoC7gU98tsUAvwJuNsb8RUQygJb+NLinnvlA2bBhAy+99BIAF154IW63m4aGU7+FfPjhhx373Hzzzdx3330D3k7ABnBXfuCBv6YEJi0Ob5uUUoMqkB7/AqDEGLPPGNMMvAj4G7t4GFgF+CacfxnYZoz5C4Axxm2Maetnm4eN3tIwx48fT1lZWcfj8vJyxo8fH/qGuPLtUI8xPe938qidCNZUTqUcLZDAPx4o83lc7tnWQUTmATnGmDe6vHYaYETkbRH5VET+2d8JROTrIrJFRLZUV1cH0fzBcf755/PrX/8agPXr15OZmUlqauop+yxcuJAXX3wRoGPfrubPn09xcTH79++nubmZF198kauuuir0DXbNsFk9R7/oeT+3N6NHJ3aVcrJ+p3OKSBTwOPAtP0/HAF8Clnt+XiMiF3XdyRjzrDGm0BhTmJWV1d8mhd2DDz7I1q1bmT17NitXruSFF144bZ8nn3ySZ555hlmzZnU7bh8TE8PTTz/NpZdeSn5+Ptdddx0zZoRhKCvQRVk0lVOpiBBIVk8FkOPzONuzzSsFmAms9wxtjAFeFZGrsN8O3jfG1ACIyBpgHvCn/jd9YJWWlnb8np6eziuvvHLaPitWrGDFihUA5OXl8fHHH3c89/3vf9/vcZcuXcrSpUtD2tbTdAT+nTDltM/dTu5ikChInxTe9iilBlUgPf7NwFQRyROROOB64FXvk8aYI8aYTGNMrjEmF9gIXGWM2QK8DcwSkUTPRO9ioI9rAao+S8qEJFfvE7w1xTByAsTED0y7lFKDotfAb4xpBe7CBvGdwG+NMUUi8pCnV9/Ta+uww0Cbgc+AT/3MA6iB4J3g7Ykut6hURAjoBi5jzBpgTZdt/97Nvku6PP4VNqVTDSZXAXz6ArS3Q5Sfz/v2dnDvhdzzB75tSqkBpbV6IoUrH1qOQ/0B/883VNjnNZVTKcfTwB8pRnuyhbob7tHlFpWKGBr4I0XWdPuzu8Bfozn8SkUKDfwBCldZ5ttuuw2Xy8XMmTND0s5uxafYjJ3uMnvcxRCXAsmjw9sOpdSg08AfoNWrV7N27dpu78LtqxUrVvDWW2+F9Jjd6mlRlppiyJyixdmUigDDriwzb66EL7aH9phjZsHl3S+CEq6yzACLFi065eawsHLlQ8k6aG0+fSF1dwlMOHdg2qGUGlTa4w9AuMoyDzhXAbS32jV1fTUfs0su6vi+UhFh+PX4e+iZD5RhVZbZl3c1rsqizjIOYPP3QVM5lYoQ2uMPo97KMg+4zKkg0aeP82sqp1IRRQN/H4SqLPOAi4m3vfqugb+mBBDImDwozVJKDSwN/H0QqrLMADfccAPnnnsuu3fvJjs7m+eeey6cTfdfs8ddDGk5EDsivOdWSg0JYnpblWmAFRYWmi1btpyybefOneTn53fzisgQsr+D9atg/Q/h/gqIS7Lbfr4YEtPh5pf7f3yl1KAQka3GmMLe99Qef+Rx5QMGqnfbx8bYVE6tyqlUxNDAH2m61uw5ehiaGzWVU6kIooE/0ozKhZiEzgneGm9GjwZ+pSKFBv5IExVtC7Z5e/zeVE4d6lEqYmjgj0S+NXtqSiA2CVLHDW6blFIDRgN/JHLl27H947We5RYna3E2pSKIBv4AhaMsc1lZGRdccAEFBQXMmDGDJ598MmTt7ZG3dEP1Lk9+EUrwAAAF70lEQVRVTh3mUSqSDL9aPYNk9erVrFu3juzs7JAdMyYmhscee4x58+Zx9OhRzjrrLC655BIKCgpCdg6/vHV6Kj6F+oNw5g3hPZ9SakgZdoF/1aZV7KrdFdJjnpF+Bvct6L6IWrjKMo8dO7ajcmdKSgr5+flUVFSEP/Cnjof4NNj1BmC0x69UhNGhngAMRFnm0tJS/vznP3P22WeH4xJOJWJ7/Qc/to818CsVUYZdj7+nnvlACXVZ5sbGRpYtW8YTTzxxWrG3sHHlQ9lG+7uWY1YqomiPP4wCKcvc0tLCsmXLWL58Oddee+0AtMrDO8GbOr6zZo9SKiJo4O+DUJVlNsZw++23k5+fz7333hveRnflneDV3r5SESegwC8il4nIbhEpEZGVPey3TESMiBR22T5BRBpF5Nv9bfBQEKqyzB9++CG//OUveeedd5gzZw5z5sxhzZo14W6+5e3x6/i+UhGn17LMIhIN7AEuAcqBzcANxpgdXfZLAd4A4oC7jDFbfJ77HWCAT4wxP+7pfFqW2b+w/B188DhMvcQuNq+UGtZCXZZ5AVBijNlnjGkGXgT85Sc+DKwCmro05q+A/UBRIA1SA+j8ezXoKxWBAgn844Eyn8flnm0dRGQekGOMeaPL9mTgPuB7PZ1ARL4uIltEZEt1dXVADVdKKdU3/Z7cFZEo4HHgW36efhD4iTGmsadjGGOeNcYUGmMKs7Kyutunv00dtiL52pVSoRdIHn8FkOPzONuzzSsFmAms96QvjgFeFZGrgLOBvxaRHwEjgXYRaTLGPB1MIxMSEnC73WRkZASUIukkxhjcbjcJCQmD3RSllEMEEvg3A1NFJA8b8K8HbvQ+aYw5AmR6H4vIeuDbnsnd8322Pwg0Bhv0AbKzsykvLydSh4ESEhJCWiNIKRXZeg38xphWEbkLeBuIBv7TGFMkIg8BW4wxr4a7kbGxseTl5YX7NEopFRF6TeccaP7SOZVSSvUs1OmcSimlHEQDv1JKRZghN9QjItXAgX4cIhOoCVFzhhu99sgVydcfydcOndc/0RjjPx++iyEX+PtLRLYEOs7lNHrtkXntENnXH8nXDn27fh3qUUqpCKOBXymlIowTA/+zg92AQaTXHrki+foj+dqhD9fvuDF+pZRSPXNij18ppVQPNPArpVSEcUzgD3R5SKcSkVIR2S4in4mIo2teiMh/ikiViHzusy1dRNaKSLHn56jBbGM4dXP9D4pIhef9/0xElg5mG8NFRHJE5F0R2SEiRSJyt2e749//Hq496PfeEWP8gS4P6WQiUgoUGmMcfyOLiCwCGoH/NsbM9Gz7EVBrjHnU88E/yhhz32C2M1y6uf4HsdVve1zadLgTkbHAWGPMp57lXrcCfwWswOHvfw/Xfh1BvvdO6fEHujykcgBjzPtAbZfNVwPeVe9fwP6HcKRurj8iGGMOG2M+9fx+FNiJXRHQ8e9/D9ceNKcE/l6Xh4wABvijiGwVka8PdmMGwWhjzGHP718AowezMYPkLhHZ5hkKctxQR1cikgvMBT4hwt7/LtcOQb73Tgn8Cr5kjJkHXA58wzMcEJGMHb8c/mOYwfkpMBmYAxwGHhvc5oSXZz3vl4B/MsY0+D7n9Pffz7UH/d47JfD3tjyk4xljKjw/q4CXscNfkaTSMwbqHQutGuT2DChjTKUxps0Y0w78Age//yISiw18vzbG/N6zOSLef3/X3pf33imBv2N5SBGJwy4PGfaVwYYKEUnyTPYgIknAl4HPe36V47wK3Or5/VbgD4PYlgHnDXoe1+DQ91/sotvPATuNMY/7POX497+7a+/Le++IrB4ATwrTE3QuD/mDQW7SgBGRSdhePtjlNH/j5OsXkf8BlmDL0VYCDwCvAL8FJmDLel9njHHkBGg3178E+1XfAKXA3/uMeTuGiHwJ+ADYDrR7Nt+PHet29Pvfw7XfQJDvvWMCv1JKqcA4ZahHKaVUgDTwK6VUhNHAr5RSEUYDv1JKRRgN/EopFWE08CulVITRwK+UUhHm/wAAgmAZlf8qvwAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "for key_idx in range(len(clinical_history[0].history.keys())):\n", - " plt.figure()\n", - " for cv_idx in range(len(murmur_history)):\n", - " plt.title(list(clinical_history[cv_idx].history.keys())[key_idx])\n", - " plt.plot(clinical_history[cv_idx].history[list(clinical_history[cv_idx].history.keys())[key_idx]], label=\"fold {}\".format(cv_idx))\n", - " plt.legend()\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "lWlv-eAmUAQ2" - }, - "source": [ - "# Patientwise metrics" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hEykrVIYUAQ2" - }, - "source": [ - "## murmurs" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": { - "id": "Reg07vZEcSK3" - }, - "outputs": [], - "source": [ - "murmur_classes = ['Present', 'Unknown', 'Absent']\n", - "outcome_classes = ['Abnormal', 'Normal']" - ] - }, - { - "cell_type": "code", - "execution_count": 73, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "6WzYfeWwUAQ3", - "outputId": "38621976-906d-46e8-87a9-ddb3e32bc2da" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################\n", - "Murmur weighted accuracy:\n", - "0.5129449838187702\n", - "Challenge metric based on murmur:\n", - "13179.103838577634\n", - "Murmur Accuracy:\n", - "(0.5254777070063694, array([0.49253731, 0.55555556, 0.53275109]))\n", - "Murmur F measure:\n", - "(0.4314855581057991, array([0.46153846, 0.19417476, 0.63874346]))\n", - "#################################\n", - "#################################\n", - "Murmur weighted accuracy:\n", - "0.5144927536231884\n", - "Challenge metric based on murmur:\n", - "11865.365449015253\n", - "Murmur Accuracy:\n", - "(0.445859872611465, array([0.59574468, 0.64 , 0.39669421]))\n", - "Murmur F measure:\n", - "(0.3908123965948043, array([0.34782609, 0.28070175, 0.54390935]))\n", - "#################################\n", - "#################################\n", - "Murmur weighted accuracy:\n", - "0.41025641025641024\n", - "Challenge metric based on murmur:\n", - "12768.313136263561\n", - "Murmur Accuracy:\n", - "(0.27388535031847133, array([0.47692308, 0.92 , 0.14285714]))\n", - "Murmur F measure:\n", - "(0.2791994923343165, array([0.35028249, 0.24210526, 0.24521073]))\n", - "#################################\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "for fold in range(FOLDS):\n", - " murmur_pred = np.zeros((len(np.unique(val_patient_labels[fold])),3), dtype=np.int_)\n", - " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", - " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", - " for pat_num in np.unique(val_patient_labels[fold]):\n", - " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", - " binary_pred = np.argmax(murmur_probas[fold][pat_indx],axis=1)\n", - " murmur_indx = np.bincount(binary_pred).argmax()\n", - " murmur_pred[pat_num,murmur_indx] = 1\n", - "\n", - " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", - "\n", - "\n", - " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", - "\n", - " print(\"#################################\")\n", - " print(\"Murmur weighted accuracy:\")\n", - " print(compute_weighted_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred, murmur_classes))\n", - " print(\"Challenge metric based on murmur:\")\n", - " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, murmur_pred, outcome_classes, murmur_classes))\n", - " print(\"Murmur Accuracy:\")\n", - " print(compute_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", - " print(\"Murmur F measure:\")\n", - " print(compute_f_measure(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", - " print(\"#################################\")\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "kp0R1k68jw34", - "outputId": "f896b4d3-cc6d-482a-db98-3c311668c9c6" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################\n", - "Murmur weighted accuracy:\n", - "0.5728155339805825\n", - "Challenge metric based on murmur:\n", - "13066.93035453682\n", - "Murmur Accuracy:\n", - "(0.5477707006369427, array([0.64179104, 0.27777778, 0.54148472]))\n", - "Murmur F measure:\n", - "(0.4261196277668356, array([0.45502646, 0.17241379, 0.65091864]))\n", - "#################################\n", - "#################################\n", - "Murmur weighted accuracy:\n", - "0.5597826086956522\n", - "Challenge metric based on murmur:\n", - "12851.670243385208\n", - "Murmur Accuracy:\n", - "(0.44904458598726116, array([0.74468085, 0.56 , 0.38016529]))\n", - "Murmur F measure:\n", - "(0.44220223535438813, array([0.32407407, 0.48275862, 0.51977401]))\n", - "#################################\n", - "#################################\n", - "Murmur weighted accuracy:\n", - "0.4951923076923077\n", - "Challenge metric based on murmur:\n", - "12016.599733733156\n", - "Murmur Accuracy:\n", - "(0.3471337579617834, array([0.64615385, 0.64 , 0.22767857]))\n", - "Murmur F measure:\n", - "(0.33688749815130503, array([0.36681223, 0.29090909, 0.35294118]))\n", - "#################################\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "for fold in range(FOLDS):\n", - " murmur_pred = np.zeros((len(np.unique(val_patient_labels[fold])),3), dtype=np.int_)\n", - " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", - " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", - " for pat_num in np.unique(val_patient_labels[fold]):\n", - " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", - " binary_pred = np.argmax(murmur_probas[fold][pat_indx],axis=1)\n", - " if 0 in binary_pred:\n", - " murmur_pred[pat_num,0] = 1\n", - " elif 2 in binary_pred:\n", - " murmur_pred[pat_num,2] = 1\n", - " elif 1 in binary_pred:\n", - " murmur_pred[pat_num,1] = 1\n", - "\n", - " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", - "\n", - "\n", - " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", - "\n", - " print(\"#################################\")\n", - " print(\"Murmur weighted accuracy:\")\n", - " print(compute_weighted_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred, murmur_classes))\n", - " print(\"Challenge metric based on murmur:\")\n", - " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, murmur_pred, outcome_classes, murmur_classes))\n", - " print(\"Murmur Accuracy:\")\n", - " print(compute_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", - " print(\"Murmur F measure:\")\n", - " print(compute_f_measure(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", - " print(\"#################################\")\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "8LmUhPgDB-jg", - "outputId": "a729609b-5d9b-4a03-e3c4-6bee7da64dc1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################\n", - "Murmur weighted accuracy:\n", - "0.4919093851132686\n", - "Challenge metric based on murmur:\n", - "11959.88484436956\n", - "Murmur Accuracy:\n", - "(0.3503184713375796, array([0.64179104, 0.61111111, 0.24454148]))\n", - "Murmur F measure:\n", - "(0.3289170839895477, array([0.45502646, 0.15714286, 0.37458194]))\n", - "#################################\n", - "#################################\n", - "Murmur weighted accuracy:\n", - "0.483695652173913\n", - "Challenge metric based on murmur:\n", - "12077.58579712274\n", - "Murmur Accuracy:\n", - "(0.2898089171974522, array([0.74468085, 0.72 , 0.15702479]))\n", - "Murmur F measure:\n", - "(0.29229414548113736, array([0.32407407, 0.288 , 0.26480836]))\n", - "#################################\n", - "#################################\n", - "Murmur weighted accuracy:\n", - "0.44711538461538464\n", - "Challenge metric based on murmur:\n", - "14196.640172964111\n", - "Murmur Accuracy:\n", - "(0.2197452229299363, array([0.64615385, 0.84 , 0.02678571]))\n", - "Murmur F measure:\n", - "(0.22250228339229525, array([0.36681223, 0.24852071, 0.05217391]))\n", - "#################################\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "for fold in range(FOLDS):\n", - " murmur_pred = np.zeros((len(np.unique(val_patient_labels[fold])),3), dtype=np.int_)\n", - " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", - " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", - " for pat_num in np.unique(val_patient_labels[fold]):\n", - " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", - " binary_pred = np.argmax(murmur_probas[fold][pat_indx],axis=1)\n", - " if 0 in binary_pred:\n", - " murmur_pred[pat_num,0] = 1\n", - " elif 1 in binary_pred:\n", - " murmur_pred[pat_num,1] = 1\n", - " elif 2 in binary_pred:\n", - " murmur_pred[pat_num,2] = 1\n", - "\n", - " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", - "\n", - "\n", - " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", - "\n", - " print(\"#################################\")\n", - " print(\"Murmur weighted accuracy:\")\n", - " print(compute_weighted_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred, murmur_classes))\n", - " print(\"Challenge metric based on murmur:\")\n", - " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, murmur_pred, outcome_classes, murmur_classes))\n", - " print(\"Murmur Accuracy:\")\n", - " print(compute_accuracy(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", - " print(\"Murmur F measure:\")\n", - " print(compute_f_measure(val_murmur_patient_clf_cv_ohe, murmur_pred))\n", - " print(\"#################################\")\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Bzw8x-tXUAQ5" - }, - "source": [ - "# Outcome" - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "J4SfUo2YhDhK", - "outputId": "46e4399f-c10d-4b5e-ee58-52f1b0dcd504" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################\n", - "Outcome weighted accuracy:\n", - "0.7364425162689805\n", - "Challenge metric based on outcome:\n", - "13520.439324209101\n", - "Outcome Accuracy:\n", - "(0.4681528662420382, array([0.875 , 0.08641975]))\n", - "Outcome F measure:\n", - "(0.37895422514360155, array([0.61431871, 0.14358974]))\n", - "#################################\n", - "#################################\n", - "Outcome weighted accuracy:\n", - "0.6637744034707158\n", - "Challenge metric based on outcome:\n", - "12973.767506865399\n", - "Outcome Accuracy:\n", - "(0.4713375796178344, array([0.76315789, 0.19753086]))\n", - "Outcome F measure:\n", - "(0.4305877212147695, array([0.58291457, 0.27826087]))\n", - "#################################\n", - "#################################\n", - "Outcome weighted accuracy:\n", - "0.7223427331887202\n", - "Challenge metric based on outcome:\n", - "12375.371060116919\n", - "Outcome Accuracy:\n", - "(0.5031847133757962, array([0.83552632, 0.19135802]))\n", - "Outcome F measure:\n", - "(0.4519579324233609, array([0.6195122 , 0.28440367]))\n", - "#################################\n" - ] - } - ], - "source": [ - "import numpy as np\n", - "for fold in range(FOLDS):\n", - " outcome_pred = np.zeros((len(np.unique(val_patient_labels[fold])),2), dtype=np.int_)\n", - " val_murmur_patient_clf_cv_ohe = np.zeros((val_murmur_patient_clf_cv[fold].shape[0],3))\n", - " val_outcome_patient_clf_cv_ohe = np.zeros((val_outcome_patient_clf_cv[fold].shape[0],2))\n", - " for pat_num in np.unique(val_patient_labels[fold]):\n", - " pat_indx = np.where(val_patient_labels[fold] == pat_num)\n", - " binary_pred = (outcome_probas[fold][pat_indx]>0.5) * 1\n", - " if 0 in binary_pred:\n", - " outcome_pred[pat_num, 0] = 1\n", - " else:\n", - " outcome_pred[pat_num, 1] = 1\n", - "\n", - " if val_murmur_patient_clf_cv[fold][pat_num] == \"Present\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Unknown\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,1] = 1\n", - " elif val_murmur_patient_clf_cv[fold][pat_num] == \"Absent\":\n", - " val_murmur_patient_clf_cv_ohe[pat_num,2] = 1\n", - "\n", - "\n", - " if val_outcome_patient_clf_cv[fold][pat_num] == \"Abnormal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,0] = 1\n", - " elif val_outcome_patient_clf_cv[fold][pat_num] == \"Normal\":\n", - " val_outcome_patient_clf_cv_ohe[pat_num,1] = 1\n", - "\n", - " print(\"#################################\")\n", - " print(\"Outcome weighted accuracy:\")\n", - " print(compute_weighted_accuracy(val_outcome_patient_clf_cv_ohe, outcome_pred, outcome_classes))\n", - " print(\"Challenge metric based on outcome:\")\n", - " print(compute_challenge_metric(val_outcome_patient_clf_cv_ohe, outcome_pred, outcome_classes, outcome_classes))\n", - " print(\"Outcome Accuracy:\")\n", - " print(compute_accuracy(val_outcome_patient_clf_cv_ohe, outcome_pred))\n", - " print(\"Outcome F measure:\")\n", - " print(compute_f_measure(val_outcome_patient_clf_cv_ohe, outcome_pred))\n", - " print(\"#################################\")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "avJ17lXkExiS" - }, - "source": [ - "# XAI stuff" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "U1cXFf3Q49xm" - }, - "outputs": [], - "source": [ - "import tensorflow as tf\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "def grad_cam(layer_name, data, model):\n", - " grad_model = tf.keras.models.Model(\n", - " [model.inputs], [model.get_layer(layer_name).output, model.output]\n", - ")\n", - " last_conv_layer_output, preds = grad_model(data)\n", - "\n", - " with tf.GradientTape() as tape:\n", - " last_conv_layer_output, preds = grad_model(data)\n", - " pred_index = tf.argmax(preds[0])\n", - " class_channel = preds[:, pred_index]\n", - " \n", - " grads = tape.gradient(class_channel, last_conv_layer_output)\n", - "\n", - "\n", - " pooled_grads = tf.reduce_mean(grads, axis=(0))\n", - "\n", - " last_conv_layer_output = last_conv_layer_output[0]\n", - "\n", - " heatmap = last_conv_layer_output * pooled_grads\n", - " heatmap = tf.reduce_mean(heatmap, axis=(1))\n", - " heatmap = np.expand_dims(heatmap,0)\n", - " return heatmap" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "BNpareHdUnEh" - }, - "source": [ - "## XAI Murmur Model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "6A-2lCSyR3GI", - "outputId": "5538d7ac-8afc-4b8e-d205-55c8b0cb06dd" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model_5\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_6 (InputLayer) [(None, 16128, 1)] 0 [] \n", - " \n", - " max_pooling1d_50 (MaxPooling1D (None, 16128, 1) 0 ['input_6[0][0]'] \n", - " ) \n", - " \n", - " conv1d_260 (Conv1D) (None, 16128, 32) 1280 ['input_6[0][0]'] \n", - " \n", - " conv1d_261 (Conv1D) (None, 16128, 32) 640 ['input_6[0][0]'] \n", - " \n", - " conv1d_262 (Conv1D) (None, 16128, 32) 320 ['input_6[0][0]'] \n", - " \n", - " conv1d_263 (Conv1D) (None, 16128, 32) 32 ['max_pooling1d_50[0][0]'] \n", - " \n", - " concatenate_50 (Concatenate) (None, 16128, 128) 0 ['conv1d_260[0][0]', \n", - " 'conv1d_261[0][0]', \n", - " 'conv1d_262[0][0]', \n", - " 'conv1d_263[0][0]'] \n", - " \n", - " batch_normalization_65 (BatchN (None, 16128, 128) 512 ['concatenate_50[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_65 (Activation) (None, 16128, 128) 0 ['batch_normalization_65[0][0]'] \n", - " \n", - " conv1d_264 (Conv1D) (None, 16128, 32) 4096 ['activation_65[0][0]'] \n", - " \n", - " max_pooling1d_51 (MaxPooling1D (None, 16128, 128) 0 ['activation_65[0][0]'] \n", - " ) \n", - " \n", - " conv1d_265 (Conv1D) (None, 16128, 32) 40960 ['conv1d_264[0][0]'] \n", - " \n", - " conv1d_266 (Conv1D) (None, 16128, 32) 20480 ['conv1d_264[0][0]'] \n", - " \n", - " conv1d_267 (Conv1D) (None, 16128, 32) 10240 ['conv1d_264[0][0]'] \n", - " \n", - " conv1d_268 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_51[0][0]'] \n", - " \n", - " concatenate_51 (Concatenate) (None, 16128, 128) 0 ['conv1d_265[0][0]', \n", - " 'conv1d_266[0][0]', \n", - " 'conv1d_267[0][0]', \n", - " 'conv1d_268[0][0]'] \n", - " \n", - " batch_normalization_66 (BatchN (None, 16128, 128) 512 ['concatenate_51[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_66 (Activation) (None, 16128, 128) 0 ['batch_normalization_66[0][0]'] \n", - " \n", - " conv1d_269 (Conv1D) (None, 16128, 32) 4096 ['activation_66[0][0]'] \n", - " \n", - " max_pooling1d_52 (MaxPooling1D (None, 16128, 128) 0 ['activation_66[0][0]'] \n", - " ) \n", - " \n", - " conv1d_270 (Conv1D) (None, 16128, 32) 40960 ['conv1d_269[0][0]'] \n", - " \n", - " conv1d_271 (Conv1D) (None, 16128, 32) 20480 ['conv1d_269[0][0]'] \n", - " \n", - " conv1d_272 (Conv1D) (None, 16128, 32) 10240 ['conv1d_269[0][0]'] \n", - " \n", - " conv1d_273 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_52[0][0]'] \n", - " \n", - " concatenate_52 (Concatenate) (None, 16128, 128) 0 ['conv1d_270[0][0]', \n", - " 'conv1d_271[0][0]', \n", - " 'conv1d_272[0][0]', \n", - " 'conv1d_273[0][0]'] \n", - " \n", - " conv1d_274 (Conv1D) (None, 16128, 128) 128 ['input_6[0][0]'] \n", - " \n", - " batch_normalization_67 (BatchN (None, 16128, 128) 512 ['concatenate_52[0][0]'] \n", - " ormalization) \n", - " \n", - " batch_normalization_68 (BatchN (None, 16128, 128) 512 ['conv1d_274[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_67 (Activation) (None, 16128, 128) 0 ['batch_normalization_67[0][0]'] \n", - " \n", - " add_15 (Add) (None, 16128, 128) 0 ['batch_normalization_68[0][0]', \n", - " 'activation_67[0][0]'] \n", - " \n", - " activation_68 (Activation) (None, 16128, 128) 0 ['add_15[0][0]'] \n", - " \n", - " conv1d_275 (Conv1D) (None, 16128, 32) 4096 ['activation_68[0][0]'] \n", - " \n", - " max_pooling1d_53 (MaxPooling1D (None, 16128, 128) 0 ['activation_68[0][0]'] \n", - " ) \n", - " \n", - " conv1d_276 (Conv1D) (None, 16128, 32) 40960 ['conv1d_275[0][0]'] \n", - " \n", - " conv1d_277 (Conv1D) (None, 16128, 32) 20480 ['conv1d_275[0][0]'] \n", - " \n", - " conv1d_278 (Conv1D) (None, 16128, 32) 10240 ['conv1d_275[0][0]'] \n", - " \n", - " conv1d_279 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_53[0][0]'] \n", - " \n", - " concatenate_53 (Concatenate) (None, 16128, 128) 0 ['conv1d_276[0][0]', \n", - " 'conv1d_277[0][0]', \n", - " 'conv1d_278[0][0]', \n", - " 'conv1d_279[0][0]'] \n", - " \n", - " batch_normalization_69 (BatchN (None, 16128, 128) 512 ['concatenate_53[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_69 (Activation) (None, 16128, 128) 0 ['batch_normalization_69[0][0]'] \n", - " \n", - " conv1d_280 (Conv1D) (None, 16128, 32) 4096 ['activation_69[0][0]'] \n", - " \n", - " max_pooling1d_54 (MaxPooling1D (None, 16128, 128) 0 ['activation_69[0][0]'] \n", - " ) \n", - " \n", - " conv1d_281 (Conv1D) (None, 16128, 32) 40960 ['conv1d_280[0][0]'] \n", - " \n", - " conv1d_282 (Conv1D) (None, 16128, 32) 20480 ['conv1d_280[0][0]'] \n", - " \n", - " conv1d_283 (Conv1D) (None, 16128, 32) 10240 ['conv1d_280[0][0]'] \n", - " \n", - " conv1d_284 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_54[0][0]'] \n", - " \n", - " concatenate_54 (Concatenate) (None, 16128, 128) 0 ['conv1d_281[0][0]', \n", - " 'conv1d_282[0][0]', \n", - " 'conv1d_283[0][0]', \n", - " 'conv1d_284[0][0]'] \n", - " \n", - " batch_normalization_70 (BatchN (None, 16128, 128) 512 ['concatenate_54[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_70 (Activation) (None, 16128, 128) 0 ['batch_normalization_70[0][0]'] \n", - " \n", - " conv1d_285 (Conv1D) (None, 16128, 32) 4096 ['activation_70[0][0]'] \n", - " \n", - " max_pooling1d_55 (MaxPooling1D (None, 16128, 128) 0 ['activation_70[0][0]'] \n", - " ) \n", - " \n", - " conv1d_286 (Conv1D) (None, 16128, 32) 40960 ['conv1d_285[0][0]'] \n", - " \n", - " conv1d_287 (Conv1D) (None, 16128, 32) 20480 ['conv1d_285[0][0]'] \n", - " \n", - " conv1d_288 (Conv1D) (None, 16128, 32) 10240 ['conv1d_285[0][0]'] \n", - " \n", - " conv1d_289 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_55[0][0]'] \n", - " \n", - " concatenate_55 (Concatenate) (None, 16128, 128) 0 ['conv1d_286[0][0]', \n", - " 'conv1d_287[0][0]', \n", - " 'conv1d_288[0][0]', \n", - " 'conv1d_289[0][0]'] \n", - " \n", - " conv1d_290 (Conv1D) (None, 16128, 128) 16384 ['activation_68[0][0]'] \n", - " \n", - " batch_normalization_71 (BatchN (None, 16128, 128) 512 ['concatenate_55[0][0]'] \n", - " ormalization) \n", - " \n", - " batch_normalization_72 (BatchN (None, 16128, 128) 512 ['conv1d_290[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_71 (Activation) (None, 16128, 128) 0 ['batch_normalization_71[0][0]'] \n", - " \n", - " add_16 (Add) (None, 16128, 128) 0 ['batch_normalization_72[0][0]', \n", - " 'activation_71[0][0]'] \n", - " \n", - " activation_72 (Activation) (None, 16128, 128) 0 ['add_16[0][0]'] \n", - " \n", - " conv1d_291 (Conv1D) (None, 16128, 32) 4096 ['activation_72[0][0]'] \n", - " \n", - " max_pooling1d_56 (MaxPooling1D (None, 16128, 128) 0 ['activation_72[0][0]'] \n", - " ) \n", - " \n", - " conv1d_292 (Conv1D) (None, 16128, 32) 40960 ['conv1d_291[0][0]'] \n", - " \n", - " conv1d_293 (Conv1D) (None, 16128, 32) 20480 ['conv1d_291[0][0]'] \n", - " \n", - " conv1d_294 (Conv1D) (None, 16128, 32) 10240 ['conv1d_291[0][0]'] \n", - " \n", - " conv1d_295 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_56[0][0]'] \n", - " \n", - " concatenate_56 (Concatenate) (None, 16128, 128) 0 ['conv1d_292[0][0]', \n", - " 'conv1d_293[0][0]', \n", - " 'conv1d_294[0][0]', \n", - " 'conv1d_295[0][0]'] \n", - " \n", - " batch_normalization_73 (BatchN (None, 16128, 128) 512 ['concatenate_56[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_73 (Activation) (None, 16128, 128) 0 ['batch_normalization_73[0][0]'] \n", - " \n", - " conv1d_296 (Conv1D) (None, 16128, 32) 4096 ['activation_73[0][0]'] \n", - " \n", - " max_pooling1d_57 (MaxPooling1D (None, 16128, 128) 0 ['activation_73[0][0]'] \n", - " ) \n", - " \n", - " conv1d_297 (Conv1D) (None, 16128, 32) 40960 ['conv1d_296[0][0]'] \n", - " \n", - " conv1d_298 (Conv1D) (None, 16128, 32) 20480 ['conv1d_296[0][0]'] \n", - " \n", - " conv1d_299 (Conv1D) (None, 16128, 32) 10240 ['conv1d_296[0][0]'] \n", - " \n", - " conv1d_300 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_57[0][0]'] \n", - " \n", - " concatenate_57 (Concatenate) (None, 16128, 128) 0 ['conv1d_297[0][0]', \n", - " 'conv1d_298[0][0]', \n", - " 'conv1d_299[0][0]', \n", - " 'conv1d_300[0][0]'] \n", - " \n", - " batch_normalization_74 (BatchN (None, 16128, 128) 512 ['concatenate_57[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_74 (Activation) (None, 16128, 128) 0 ['batch_normalization_74[0][0]'] \n", - " \n", - " conv1d_301 (Conv1D) (None, 16128, 32) 4096 ['activation_74[0][0]'] \n", - " \n", - " max_pooling1d_58 (MaxPooling1D (None, 16128, 128) 0 ['activation_74[0][0]'] \n", - " ) \n", - " \n", - " conv1d_302 (Conv1D) (None, 16128, 32) 40960 ['conv1d_301[0][0]'] \n", - " \n", - " conv1d_303 (Conv1D) (None, 16128, 32) 20480 ['conv1d_301[0][0]'] \n", - " \n", - " conv1d_304 (Conv1D) (None, 16128, 32) 10240 ['conv1d_301[0][0]'] \n", - " \n", - " conv1d_305 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_58[0][0]'] \n", - " \n", - " concatenate_58 (Concatenate) (None, 16128, 128) 0 ['conv1d_302[0][0]', \n", - " 'conv1d_303[0][0]', \n", - " 'conv1d_304[0][0]', \n", - " 'conv1d_305[0][0]'] \n", - " \n", - " conv1d_306 (Conv1D) (None, 16128, 128) 16384 ['activation_72[0][0]'] \n", - " \n", - " batch_normalization_75 (BatchN (None, 16128, 128) 512 ['concatenate_58[0][0]'] \n", - " ormalization) \n", - " \n", - " batch_normalization_76 (BatchN (None, 16128, 128) 512 ['conv1d_306[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_75 (Activation) (None, 16128, 128) 0 ['batch_normalization_75[0][0]'] \n", - " \n", - " add_17 (Add) (None, 16128, 128) 0 ['batch_normalization_76[0][0]', \n", - " 'activation_75[0][0]'] \n", - " \n", - " activation_76 (Activation) (None, 16128, 128) 0 ['add_17[0][0]'] \n", - " \n", - " conv1d_307 (Conv1D) (None, 16128, 32) 4096 ['activation_76[0][0]'] \n", - " \n", - " max_pooling1d_59 (MaxPooling1D (None, 16128, 128) 0 ['activation_76[0][0]'] \n", - " ) \n", - " \n", - " conv1d_308 (Conv1D) (None, 16128, 32) 40960 ['conv1d_307[0][0]'] \n", - " \n", - " conv1d_309 (Conv1D) (None, 16128, 32) 20480 ['conv1d_307[0][0]'] \n", - " \n", - " conv1d_310 (Conv1D) (None, 16128, 32) 10240 ['conv1d_307[0][0]'] \n", - " \n", - " conv1d_311 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_59[0][0]'] \n", - " \n", - " concatenate_59 (Concatenate) (None, 16128, 128) 0 ['conv1d_308[0][0]', \n", - " 'conv1d_309[0][0]', \n", - " 'conv1d_310[0][0]', \n", - " 'conv1d_311[0][0]'] \n", - " \n", - " batch_normalization_77 (BatchN (None, 16128, 128) 512 ['concatenate_59[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_77 (Activation) (None, 16128, 128) 0 ['batch_normalization_77[0][0]'] \n", - " \n", - " global_average_pooling1d_5 (Gl (None, 128) 0 ['activation_77[0][0]'] \n", - " obalAveragePooling1D) \n", - " \n", - " murmur_output (Dense) (None, 3) 387 ['global_average_pooling1d_5[0][0\n", - " ]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 761,059\n", - "Trainable params: 757,731\n", - "Non-trainable params: 3,328\n", - "__________________________________________________________________________________________________\n" - ] - }, - { - "ename": "TypeError", - "evalue": "ignored", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmurmur_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msummary\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m: 'NoneType' object is not subscriptable" - ] - } - ], - "source": [ - "murmur_model.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "isz0Y0yfWcyb", - "outputId": "bf34af01-c27b-47c2-e7f5-cc82b6b30aab" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "13832\n" - ] - } - ], - "source": [ - "for i,j in enumerate(reversed(val_data[0])):\n", - " if not j == 0:\n", - " print(i)\n", - " break" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "M9vMujbMXASq", - "outputId": "2fa80f8b-f4f2-4d10-a854-7149e3951dc7" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "2296" - ] - }, - "execution_count": 99, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(val_data[0][:-13832])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "jGmeZ9w649xm", - "outputId": "97213500-d323-4606-b731-77b7fb165bfc" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "model = murmur_model\n", - "layer_name = \"conv1d_311\"\n", - "num_data = 5\n", - " \n", - "for example in val_data[:num_data]:\n", - " exp = grad_cam(layer_name, np.expand_dims(example,0), model)\n", - " idx = 0\n", - " for i,j in enumerate(reversed(example)):\n", - " if not j == 0:\n", - " idx = i\n", - " break\n", - " plt.figure(figsize=(24,4))\n", - " plt.imshow(exp,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", - " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", - " plt.plot(example,'k') \n", - " plt.xlim(0,len(example[:-idx]))\n", - " plt.colorbar()\n", - " plt.show()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "CWUhn-sfUq3q" - }, - "source": [ - "## XAI Outcome Model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "c6e6MCE0TRZc", - "outputId": "d409a5af-eb88-4601-a750-5f7fa2578b0d" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model_4\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_5 (InputLayer) [(None, 16128, 1)] 0 [] \n", - " \n", - " max_pooling1d_40 (MaxPooling1D (None, 16128, 1) 0 ['input_5[0][0]'] \n", - " ) \n", - " \n", - " conv1d_208 (Conv1D) (None, 16128, 32) 1280 ['input_5[0][0]'] \n", - " \n", - " conv1d_209 (Conv1D) (None, 16128, 32) 640 ['input_5[0][0]'] \n", - " \n", - " conv1d_210 (Conv1D) (None, 16128, 32) 320 ['input_5[0][0]'] \n", - " \n", - " conv1d_211 (Conv1D) (None, 16128, 32) 32 ['max_pooling1d_40[0][0]'] \n", - " \n", - " concatenate_40 (Concatenate) (None, 16128, 128) 0 ['conv1d_208[0][0]', \n", - " 'conv1d_209[0][0]', \n", - " 'conv1d_210[0][0]', \n", - " 'conv1d_211[0][0]'] \n", - " \n", - " batch_normalization_52 (BatchN (None, 16128, 128) 512 ['concatenate_40[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_52 (Activation) (None, 16128, 128) 0 ['batch_normalization_52[0][0]'] \n", - " \n", - " conv1d_212 (Conv1D) (None, 16128, 32) 4096 ['activation_52[0][0]'] \n", - " \n", - " max_pooling1d_41 (MaxPooling1D (None, 16128, 128) 0 ['activation_52[0][0]'] \n", - " ) \n", - " \n", - " conv1d_213 (Conv1D) (None, 16128, 32) 40960 ['conv1d_212[0][0]'] \n", - " \n", - " conv1d_214 (Conv1D) (None, 16128, 32) 20480 ['conv1d_212[0][0]'] \n", - " \n", - " conv1d_215 (Conv1D) (None, 16128, 32) 10240 ['conv1d_212[0][0]'] \n", - " \n", - " conv1d_216 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_41[0][0]'] \n", - " \n", - " concatenate_41 (Concatenate) (None, 16128, 128) 0 ['conv1d_213[0][0]', \n", - " 'conv1d_214[0][0]', \n", - " 'conv1d_215[0][0]', \n", - " 'conv1d_216[0][0]'] \n", - " \n", - " batch_normalization_53 (BatchN (None, 16128, 128) 512 ['concatenate_41[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_53 (Activation) (None, 16128, 128) 0 ['batch_normalization_53[0][0]'] \n", - " \n", - " conv1d_217 (Conv1D) (None, 16128, 32) 4096 ['activation_53[0][0]'] \n", - " \n", - " max_pooling1d_42 (MaxPooling1D (None, 16128, 128) 0 ['activation_53[0][0]'] \n", - " ) \n", - " \n", - " conv1d_218 (Conv1D) (None, 16128, 32) 40960 ['conv1d_217[0][0]'] \n", - " \n", - " conv1d_219 (Conv1D) (None, 16128, 32) 20480 ['conv1d_217[0][0]'] \n", - " \n", - " conv1d_220 (Conv1D) (None, 16128, 32) 10240 ['conv1d_217[0][0]'] \n", - " \n", - " conv1d_221 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_42[0][0]'] \n", - " \n", - " concatenate_42 (Concatenate) (None, 16128, 128) 0 ['conv1d_218[0][0]', \n", - " 'conv1d_219[0][0]', \n", - " 'conv1d_220[0][0]', \n", - " 'conv1d_221[0][0]'] \n", - " \n", - " conv1d_222 (Conv1D) (None, 16128, 128) 128 ['input_5[0][0]'] \n", - " \n", - " batch_normalization_54 (BatchN (None, 16128, 128) 512 ['concatenate_42[0][0]'] \n", - " ormalization) \n", - " \n", - " batch_normalization_55 (BatchN (None, 16128, 128) 512 ['conv1d_222[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_54 (Activation) (None, 16128, 128) 0 ['batch_normalization_54[0][0]'] \n", - " \n", - " add_12 (Add) (None, 16128, 128) 0 ['batch_normalization_55[0][0]', \n", - " 'activation_54[0][0]'] \n", - " \n", - " activation_55 (Activation) (None, 16128, 128) 0 ['add_12[0][0]'] \n", - " \n", - " conv1d_223 (Conv1D) (None, 16128, 32) 4096 ['activation_55[0][0]'] \n", - " \n", - " max_pooling1d_43 (MaxPooling1D (None, 16128, 128) 0 ['activation_55[0][0]'] \n", - " ) \n", - " \n", - " conv1d_224 (Conv1D) (None, 16128, 32) 40960 ['conv1d_223[0][0]'] \n", - " \n", - " conv1d_225 (Conv1D) (None, 16128, 32) 20480 ['conv1d_223[0][0]'] \n", - " \n", - " conv1d_226 (Conv1D) (None, 16128, 32) 10240 ['conv1d_223[0][0]'] \n", - " \n", - " conv1d_227 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_43[0][0]'] \n", - " \n", - " concatenate_43 (Concatenate) (None, 16128, 128) 0 ['conv1d_224[0][0]', \n", - " 'conv1d_225[0][0]', \n", - " 'conv1d_226[0][0]', \n", - " 'conv1d_227[0][0]'] \n", - " \n", - " batch_normalization_56 (BatchN (None, 16128, 128) 512 ['concatenate_43[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_56 (Activation) (None, 16128, 128) 0 ['batch_normalization_56[0][0]'] \n", - " \n", - " conv1d_228 (Conv1D) (None, 16128, 32) 4096 ['activation_56[0][0]'] \n", - " \n", - " max_pooling1d_44 (MaxPooling1D (None, 16128, 128) 0 ['activation_56[0][0]'] \n", - " ) \n", - " \n", - " conv1d_229 (Conv1D) (None, 16128, 32) 40960 ['conv1d_228[0][0]'] \n", - " \n", - " conv1d_230 (Conv1D) (None, 16128, 32) 20480 ['conv1d_228[0][0]'] \n", - " \n", - " conv1d_231 (Conv1D) (None, 16128, 32) 10240 ['conv1d_228[0][0]'] \n", - " \n", - " conv1d_232 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_44[0][0]'] \n", - " \n", - " concatenate_44 (Concatenate) (None, 16128, 128) 0 ['conv1d_229[0][0]', \n", - " 'conv1d_230[0][0]', \n", - " 'conv1d_231[0][0]', \n", - " 'conv1d_232[0][0]'] \n", - " \n", - " batch_normalization_57 (BatchN (None, 16128, 128) 512 ['concatenate_44[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_57 (Activation) (None, 16128, 128) 0 ['batch_normalization_57[0][0]'] \n", - " \n", - " conv1d_233 (Conv1D) (None, 16128, 32) 4096 ['activation_57[0][0]'] \n", - " \n", - " max_pooling1d_45 (MaxPooling1D (None, 16128, 128) 0 ['activation_57[0][0]'] \n", - " ) \n", - " \n", - " conv1d_234 (Conv1D) (None, 16128, 32) 40960 ['conv1d_233[0][0]'] \n", - " \n", - " conv1d_235 (Conv1D) (None, 16128, 32) 20480 ['conv1d_233[0][0]'] \n", - " \n", - " conv1d_236 (Conv1D) (None, 16128, 32) 10240 ['conv1d_233[0][0]'] \n", - " \n", - " conv1d_237 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_45[0][0]'] \n", - " \n", - " concatenate_45 (Concatenate) (None, 16128, 128) 0 ['conv1d_234[0][0]', \n", - " 'conv1d_235[0][0]', \n", - " 'conv1d_236[0][0]', \n", - " 'conv1d_237[0][0]'] \n", - " \n", - " conv1d_238 (Conv1D) (None, 16128, 128) 16384 ['activation_55[0][0]'] \n", - " \n", - " batch_normalization_58 (BatchN (None, 16128, 128) 512 ['concatenate_45[0][0]'] \n", - " ormalization) \n", - " \n", - " batch_normalization_59 (BatchN (None, 16128, 128) 512 ['conv1d_238[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_58 (Activation) (None, 16128, 128) 0 ['batch_normalization_58[0][0]'] \n", - " \n", - " add_13 (Add) (None, 16128, 128) 0 ['batch_normalization_59[0][0]', \n", - " 'activation_58[0][0]'] \n", - " \n", - " activation_59 (Activation) (None, 16128, 128) 0 ['add_13[0][0]'] \n", - " \n", - " conv1d_239 (Conv1D) (None, 16128, 32) 4096 ['activation_59[0][0]'] \n", - " \n", - " max_pooling1d_46 (MaxPooling1D (None, 16128, 128) 0 ['activation_59[0][0]'] \n", - " ) \n", - " \n", - " conv1d_240 (Conv1D) (None, 16128, 32) 40960 ['conv1d_239[0][0]'] \n", - " \n", - " conv1d_241 (Conv1D) (None, 16128, 32) 20480 ['conv1d_239[0][0]'] \n", - " \n", - " conv1d_242 (Conv1D) (None, 16128, 32) 10240 ['conv1d_239[0][0]'] \n", - " \n", - " conv1d_243 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_46[0][0]'] \n", - " \n", - " concatenate_46 (Concatenate) (None, 16128, 128) 0 ['conv1d_240[0][0]', \n", - " 'conv1d_241[0][0]', \n", - " 'conv1d_242[0][0]', \n", - " 'conv1d_243[0][0]'] \n", - " \n", - " batch_normalization_60 (BatchN (None, 16128, 128) 512 ['concatenate_46[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_60 (Activation) (None, 16128, 128) 0 ['batch_normalization_60[0][0]'] \n", - " \n", - " conv1d_244 (Conv1D) (None, 16128, 32) 4096 ['activation_60[0][0]'] \n", - " \n", - " max_pooling1d_47 (MaxPooling1D (None, 16128, 128) 0 ['activation_60[0][0]'] \n", - " ) \n", - " \n", - " conv1d_245 (Conv1D) (None, 16128, 32) 40960 ['conv1d_244[0][0]'] \n", - " \n", - " conv1d_246 (Conv1D) (None, 16128, 32) 20480 ['conv1d_244[0][0]'] \n", - " \n", - " conv1d_247 (Conv1D) (None, 16128, 32) 10240 ['conv1d_244[0][0]'] \n", - " \n", - " conv1d_248 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_47[0][0]'] \n", - " \n", - " concatenate_47 (Concatenate) (None, 16128, 128) 0 ['conv1d_245[0][0]', \n", - " 'conv1d_246[0][0]', \n", - " 'conv1d_247[0][0]', \n", - " 'conv1d_248[0][0]'] \n", - " \n", - " batch_normalization_61 (BatchN (None, 16128, 128) 512 ['concatenate_47[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_61 (Activation) (None, 16128, 128) 0 ['batch_normalization_61[0][0]'] \n", - " \n", - " conv1d_249 (Conv1D) (None, 16128, 32) 4096 ['activation_61[0][0]'] \n", - " \n", - " max_pooling1d_48 (MaxPooling1D (None, 16128, 128) 0 ['activation_61[0][0]'] \n", - " ) \n", - " \n", - " conv1d_250 (Conv1D) (None, 16128, 32) 40960 ['conv1d_249[0][0]'] \n", - " \n", - " conv1d_251 (Conv1D) (None, 16128, 32) 20480 ['conv1d_249[0][0]'] \n", - " \n", - " conv1d_252 (Conv1D) (None, 16128, 32) 10240 ['conv1d_249[0][0]'] \n", - " \n", - " conv1d_253 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_48[0][0]'] \n", - " \n", - " concatenate_48 (Concatenate) (None, 16128, 128) 0 ['conv1d_250[0][0]', \n", - " 'conv1d_251[0][0]', \n", - " 'conv1d_252[0][0]', \n", - " 'conv1d_253[0][0]'] \n", - " \n", - " conv1d_254 (Conv1D) (None, 16128, 128) 16384 ['activation_59[0][0]'] \n", - " \n", - " batch_normalization_62 (BatchN (None, 16128, 128) 512 ['concatenate_48[0][0]'] \n", - " ormalization) \n", - " \n", - " batch_normalization_63 (BatchN (None, 16128, 128) 512 ['conv1d_254[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_62 (Activation) (None, 16128, 128) 0 ['batch_normalization_62[0][0]'] \n", - " \n", - " add_14 (Add) (None, 16128, 128) 0 ['batch_normalization_63[0][0]', \n", - " 'activation_62[0][0]'] \n", - " \n", - " activation_63 (Activation) (None, 16128, 128) 0 ['add_14[0][0]'] \n", - " \n", - " conv1d_255 (Conv1D) (None, 16128, 32) 4096 ['activation_63[0][0]'] \n", - " \n", - " max_pooling1d_49 (MaxPooling1D (None, 16128, 128) 0 ['activation_63[0][0]'] \n", - " ) \n", - " \n", - " conv1d_256 (Conv1D) (None, 16128, 32) 40960 ['conv1d_255[0][0]'] \n", - " \n", - " conv1d_257 (Conv1D) (None, 16128, 32) 20480 ['conv1d_255[0][0]'] \n", - " \n", - " conv1d_258 (Conv1D) (None, 16128, 32) 10240 ['conv1d_255[0][0]'] \n", - " \n", - " conv1d_259 (Conv1D) (None, 16128, 32) 4096 ['max_pooling1d_49[0][0]'] \n", - " \n", - " concatenate_49 (Concatenate) (None, 16128, 128) 0 ['conv1d_256[0][0]', \n", - " 'conv1d_257[0][0]', \n", - " 'conv1d_258[0][0]', \n", - " 'conv1d_259[0][0]'] \n", - " \n", - " batch_normalization_64 (BatchN (None, 16128, 128) 512 ['concatenate_49[0][0]'] \n", - " ormalization) \n", - " \n", - " activation_64 (Activation) (None, 16128, 128) 0 ['batch_normalization_64[0][0]'] \n", - " \n", - " global_average_pooling1d_4 (Gl (None, 128) 0 ['activation_64[0][0]'] \n", - " obalAveragePooling1D) \n", - " \n", - " clinical_output (Dense) (None, 1) 129 ['global_average_pooling1d_4[0][0\n", - " ]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 760,801\n", - "Trainable params: 757,473\n", - "Non-trainable params: 3,328\n", - "__________________________________________________________________________________________________\n" - ] - } - ], - "source": [ - "clinical_model.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "kUjy4uqqTBtf", - "outputId": "459975fb-6dae-4a56-95f2-fcf023235449" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "model = clinical_model\n", - "layer_name = \"conv1d_253\"\n", - "num_data = 5\n", - "\n", - "for example in val_data[:num_data]:\n", - " exp = grad_cam(layer_name, np.expand_dims(example,0), model)\n", - " idx = 0\n", - " for i,j in enumerate(reversed(example)):\n", - " if not j == 0:\n", - " idx = i\n", - " break\n", - " plt.figure(figsize=(24,4))\n", - " plt.imshow(exp,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", - " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", - " plt.plot(example,'k') \n", - " plt.xlim(0,len(example[:-idx]))\n", - " plt.colorbar()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "uNajgjR8Zmec", - "outputId": "c53e6718-44df-4003-af69-c973a676cb4a" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################################\n", - "#################################################\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################################\n", - "#################################################\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################################\n", - "#################################################\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABNAAAAEICAYAAACeZwkAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzdd3gU1foH8O9JBwJSFRAQARtwFZWL6LVgQ/TqtfdrV6xXvT9BwYqgyFVUsICIIKDS7IUgVURAuvTeCRASSELqZtv7++PMZCeb3WQ3mSEJ+X6eZ59kZ2fPnJ05M3PmnXPOKBEBERERERERERERhRZT1RkgIiIiIiIiIiKqzhhAIyIiIiIiIiIiKgMDaERERERERERERGVgAI2IiIiIiIiIiKgMDKARERERERERERGVgQE0IiIiIiIiIiKiMjCARkRERMcEpdQApdSXYT7roZRKPdp5IkApJUqpDhHMx21ERERE1RYDaERERMcIpdQupdQVEc47Tyn1sNN5ikY0+SciIiIiOpoYQCMiIqKoKaVio5w/zqm8HEucXk/cDkREREQVwwAaERHRMUgpdb9SaoFSaqhSKksptVMpdbXx2ZsALgLwkVIqTyn1kTH9dKXULKVUplJqs1LqNkt645RSI5VSKUqpfACXGtM+Mb6Tq5T6XSl1kuU7opR6Uim1FcBWY9q1SqlVSqlspdQipdSZxvQvALQB8LORp+eN6d2N+bKVUquVUj0s6Z9sLDNXKTULQNMI1suLSqlDRmu3u41pf1dKHbQGBZVSNymlVodJY5xSaoRSarqR14VKqeZKqWHGut6klDo7aD10CPr+G8b/PZRSqUqpF5RSaQA+N7qifq2U+tL4bWuVUqcqpforpdKVUnuVUj0t6ZVouWftyqqUamss/yGl1B4Ac0P8HjMPzxvpH1BK3aCUukYptcUoDy9a5k80fut+4zVMKZVo+byvkcZ+pdSDQctKNMrkHmOdf6KUqlPediMiIiKqagygERERHbvOA7AZOrD0NoAxSiklIi8B+APAUyKSLCJPKaXqAZgFYCKA4wHcAWCEUqqjJb27ALwJoD6ABca0uwEMMpaxCsBXQXm4wchHRyOoNBbAowCaABgF4CelVKKI3ANgD4DrjDy9rZQ6EcA0AG8AaAygD4BvlVLNjLQnAlhhLHsQgPvKWR/NjXlPNOb9VCl1mogsA3AYQE/LvPcAmFBGWrcBeNlIrwjAnwBWGu+/AfBeOXkJzldjACcB6G1Muw7AFwAaAfgLwAzoetuJAAZCr7toXALgDABXlZGHJCP9VwGMBvBvAOdCB1tfUUqdbMz7EoDuALoAOAtAN+h1AaVUL+jtdCWAUwAEd8kdAuBU47sdLMsjIiIiqtYYQCMiIjp27RaR0SLiAzAeQAsAJ4SZ91oAu0TkcxHxishfAL4FcKtlnh9FZKGI+EXEZUybJiLzRaQIOrByvlKqteU7b4lIpogUQgeHRonIEhHxich46OBT9zB5+jeAFBFJMZY5C8ByANcopdoA+DuAV0SkSETmA/g5gnVizv87dHDObGU33lgelFKNoQNNE8tI53sRWWGsh+8BuERkgrGupwA4u4zvBvMDeM3IV6Ex7Q8RmSEiXgBfA2gGYIiIeABMBtBWKdUwimUMEJF8S/rBPADetKTfFMBwEckVkfUANkAHywAdNB0oIukikgHgdeiAI6DX5+cisk5E8gEMMBeglFLQZeC/RpnIBTAYOlhLRERExwCl1FijRfs6m9Jro5SaqZTaqJTaoJRqa0e6FcEAGhER0bErzfxHRAqMf5PDzHsSgPOMrpLZSqls6EBJc8s8e0N8r3iaiOQByATQMsx3TgLwXNAyWgfNH5ynW4PmvxA6ENgSQJYRpDHtDpOOKdT85rK/BHCd0RLvNugA1oEy0jpo+b8wxPtw6zmUDEtAMlz6h4zgnPkeUS4j1LazOhwi/XC/qSVKrmvremwZtCzrfM0A1AWwwrI9fzWmExER0bFhHIBeNqY3AcA7InIGdKv3dBvTjgoHkiUiIqqdJOj9XgC/i8iVUXwH0AEwAIBSKhm6K+L+MN/ZC93K6c0o8vSFiDwSPKPSY601UkrVswTF2oTJoynU/OsAQET2KaX+BHATdGuqkWWkE60C6MCRqTmAVMv7svIcifwQ6Qer7DKs9kMHN9cb79sgsM0PwFImjM9Mh6ADcZ1EZJ+N+SEiIqJqQkTmB7cSU0q1B/Ax9E2zAgCPiMim8tIyhhKJM3ohmDdrqwxboBEREdVOBwG0s7z/BcCpSql7lFLxxuvvSqkzyknnGqXUhUqpBOhxyBaLSLjWTqMBPKaUOk9p9ZRS/1RK1Q+TJ7NV2FVKqVilVJIx4H0rEdkN3Z3zdaVUglLqQuhxw8pjzn8RdLfVry2fTQDwPIC/AfgugrQitQrAXcZv6AU9HpmdVgG4w9hmXQHcYnP6wSYBeFkp1Uwp1RR6DLMvjc+mArhfKdVRKVUXwGvml0TED10G3ldKHQ8ASqkTlVLhxmUjIiKiY8OnAP4jIudCj5U6IsLvnQogWyn1nVLqL6XUOyrKJ8HbiQE0IiKi2mk4gFuUfmrkB8Z4VD2hx6PaD939838AEstIA9DjhL0G3XXzXBjjiIUiIssBPALgIwBZALYBuN8yy1vQgZlspVQfIxB3PYAXAWRAt0jri0D95S7oBxRkGnkoa9B/GL8py/h9XwF4LOju5/fQLau+t3R5tcMz0ME9s1vsDzamDQCvAGgP/dteR9ljt9nhDejg5RoAa6EfnvAGAIjIdADDoJ/2uQ2ln/r5gjF9sVIqB8BsAKc5nF8iIiKqIkYPhQsAfK2UWgX9IKQWxmc3KaXWhXjNML4eB/0woz7QY9+2Q8m641GlROxs0U9ERES1hVJqHIBUEXm5qvNiF6XUdgCPisjsqs4LERERUU1kdOH8RUQ6K6UaANgsIi0qkE53AP8TkUuM9/cA6C4iT9qZ30ixBRoRERERAKXUzdBjhQW3miIiIiKiChCRHAA7lVK3Avqp3Eqps8r5mmkZgIZKKfOBQ5dBPxm8SjCARkRERLWeUmoe9IMDnjTG6iIiIiKiKCmlJgH4E8BpSqlUpdRD0ENYPKSUWg39EKLrI0nLeEJ4HwBzlFJrASjo8VSrBLtwEhERERERERERlYEt0IiIiIiIiIiIiMoQV9UZcErTJk2kRcuTkZgggNcLxMcDIhAoKPGjsCgGdeoAcLsBpZBTGA+vF6hXD/B4gGR/DvbnNYDPp7+amKinFxUBMTH6b3IycNxxQGKMBxABsrKAxo31jHl5eiYRnYBSgf9jYoDYWMDn0wt0uwG/Xy8kIQEoLNTTCwv1vC6X/m5+vp5PKf0jfT7oH4HAdLdbT0tM1O9jY4HYWBT6EorzHms89DU7WyeblKQXK6JfZnLx8fozQP/v8ejviujFxMXp+QBjHZjr+fBhPYP5hdhYnZf4+MAGMn+v263fJyTo35yfD9StG0jc4wGOHNH/Hzmip4vo3x4To1916+q0zMx7vfq916u/V6dOYP3ExUGS60NlZep8eb06jcOHgdzcwA+Mi9NpJCYGtp/Pp/8mJQXWvc8X2JYNGgA5OXpZeXl6+xUV6e+Y2z8hQS/PLAfmNnK79eeJifp7ycl6XpP5vcREnabPp/NeVKTLh9ut54mP1y9zfq83sHy/X09PSND5NNazX8UixufR5Tc3V38HCKxn8/fXrRsoPH6/fpm/3Vye+RJBUd1GgX2joECvr6wsvY3NdMx1kZAQSDMxUf810kFCgl5GUpKenpSkf3NRkV5XBQX69zRsqP83y1liYsltb5a3uDidtrkss6woBTcS9CISBVCqxD4R4/fq7RoTo8uluX1iYnQ+fL7AzOY2M7dXbKxef14jDb9fz19QoPMTHx/4zXXr6pffr+ePiwuUU69Xp2vumIWF+rsuV2An9fn0e48nsA+ZZSspSa+LhASdL/Mzc/9zuXS65rHk+OP1X/MYdOQISh1IzN8J6LwCgX3E79ffjYnR7+vWDRx0zHVgllGPR7+83sCxxCwX5jHB5dLfLSgI7IMierp5zKxfX3/m8ehyAegyZx4XzG1Wt25g/zP3ZVNMjF5ObCwQEwMRnZTHo78SE6NXRb16gV3LPGSYm6FuXUDByFt+fmDmuDi9H9Stq2ds0ECXCY8nMG9+vs6Heew0y29cXOCYbx4Lrdu4ceMSx70ilYREpY8NXm9g9SmlZ4uN1dPMw5g53VwFiYn6b26uzq65uxYVGcf8wkK9Iqzr2lhnxeXD3EbmscF6XLNuC5cLaNAAPhUHn08XO3NZdesGdiMRoE6cB0X+eL058/MD51Bz45j7m9+PIn88CgoCh9n69QNZjPG6IfEJxcW9qEhnN048gTJvpmuew8yKggjg8SDXk1TidGUeeszTdGys3rzWKoBZ3JOT9Txm0a9XT+fBTMPtBuq4j+h/vN5AuY6L0y9zo1nPhwkJeoMlJQWOhfXqwSt6e/h8+qtKGVWNROMYc+hQ8Qb3JtbT68AszOZfESA2Vp8zCvMD54LkZJ3HAuOhpUeO6O1ibgtz3Zkvs+JglgXzvTmveYzLyQlUuMzjCRAovObKMo+X5nYyz63mOjHPw4mJkOMaQolfV4CsGz4mJnD+MPfVhITATm9uZJ9Pn2vM4318fPH68CbWQ1yMX6//oqLAsT4hIbD9zG1ippeUFPjfPJjExpY8uMTE6PWZlKTXrfnb8vNLHhvMQmYeI2Ji4I2vg7i4QBWhqAjIzAwcPsx93CyDycmB44HXq+epXx+Iha94G5nVO/Nwnxjvh6gYqLxc/dvN/bGoKHB8Nw8e5r5prtc6dQJ1XjND5vfNg465vqznN5HA9jfPF/HxxXX64sKelKTnNden263/z87W6Zl10NzcQLkrKtLHZXM/M8uVuVLMc655nqtfP1AHyMkJ1HVycwMrKSZGTzePi+a2Ml/WdZOTAzRtqssWYvT5pTBXf6+gQM9vHqjN6wYzn+ZBKCYmsE79fn39E5+gqy7Kcs0SE6P3fZN5gDIPkuY+YO6nZp3aPFia9bXjjtO/17z+SUzU5dM8r8bFBeqf9esH9jmzvm3OV7duYBvXrRvYPub2LijQ08xtYR4zYmOLr/Pg8wXq0maZMg+0Zp2wYcNAefD5AufdhIRAPcism9Wvr7e1eV4285yQULJcJCTAHxuPGLcrcMwx603GNijen808mfk31625vs11VKeOrqfH6fOUys3RyzaPL40b6/TNc4BZ7zXLvfW4aW67/Pzik5TExevjYVGR/jw/X5c/63YzKzjWsmGmaT3Xm5WL+Hj44xP1dYW5z5rHV+sxNfi4be6z1utc4/e7XHrSkSOBw3psbOAy07xUNjeJuduZWU5IgC4PiYl6GT4f/AlJxZsl3mfsz3l5er/w+QLluWFDvV7q1y95LLBW9syyY56jjX3a3bRlcdXTrCZlZACdWufoNLKz9XcyMgAAuwAcElEg9FJKDpU/GwBgBTBDRHo5mqEgx2wArW3r1vj6++U4uZVH1xaaNgX8fngQj3hvIdZtr4MzzgBi9+8FYmIwY92JyMwEunUDDhwALiychdcXXYkjR4AWLYC2bYH9+4Fdu/Q+tm0bcMklwD//CZycdEAfhL/5BrjjDiAtDVi0CNixQx+UWrYM7GgnnKBrKA0b6h2na1cgNVXv+W3bAm3aAOvWQbqdB7VmtZ53wwZ9QFm8OHAAionR3+/cWe/M+fn6iJGaqqd16KDnadAAaNgQa3NOwo4dej9v0ECvox9/1Ptthw56sX5/oN7iculsn366nveEpj4cSI9FcrI+T+zbBzRporPj9wOnJB8A0tP1lyZMAPbs0e8bNNCv+Hj9282KbW4u0K6dXql+P9CqFdC9O7B8OXDmmfrCPS9PpzFtmv59M2bohbrdgUpKUhLw97/rdWeeaA8d0j8qM1On0bmz/n6dOkDDhvBcfDniv5mk1212tl6fEycC8+bpvLpcurx06ACccorOd1ycTis2FjjjDL3800/X0xo00On07AnMnq1XyoIFwPr1wNatgYvewkLg5JN1nps3D1zJHXecLlher14nGzYAF14InHiipUC3BerVg6/NyYjds1MvLz1df2/zZv23bVud15Yt9fpMTgYOHtTrPi5OL79tW6B1a53PLl2Apk2RG3Mc6ucd0OV37lydtlnZz87W+YiJAc45J1B4zEpM/fp6W7ZsqQtXcnJxpWdrl1t1ufB69Xbt3FkvY+lSXf7NCnLLlroAFhQE9gMz4OD16t+SlxdY36eeCmzZon/zqlXAypX69/zzn8DatXrdAsBJJ+myZAZwTj1Vl8vGjXU+8/L0Nm7XTq/LpCSkqtbIzQXO6OCBxMXD7Q7E3OrkZej9um5dvY+3bKmXk5wMrFmj0zPLIKDXW/v2Op/16wPnnqsDtX/8ofOUmanz37ixTquoSJ9lu3bV6zonR6//xo31vElJOp9t2gAdO+r1t26dXj8bNug09u/X39m0SefR5dLTvF5d9k47TZf3tm2B7dv1jmyu427d9HoF9DypqcATT+h1tmWL/m0pKfr3JCQELjDatNHpAcXHWXTsqGs6hYW6fCYm6vXTpYtOp2NH/T47W79iYvRvS0vTf9PT9fpr3Vr/hjPP1Glv2aL3vxUr9Prp3Fnnf9MmnX9z38nL079t1iydr2XL9Lpv106/T0rS6zguTpfFv/1N5wPQ+2RSks5jcjKkbj243XrXSEsLxNZSUvQhKyFBF92mTfVqaNVKz3fmmUAiinTeli7VM8fF6Rm/+07PkJYGXHGFPrbv36/nXbJE/z4gsI7NbXb88fo3m+vaDMimp+v1escduqwUFACdO2N73Glon7AXvpatkZ2tV0/HjoHTR4MGwMaNur7YqFHJ+lydOrq41Kmjd69u3QKHrh07gPbJB3X5TUnReZ89Wx/bjztO7xP16+t8duqk89aggU6gVavAeUBEz3vmmXrb9uyJI3FNkJ0N7N2rD2c7duhNtWtXIE5zVvOD2J53Atq39eljy65dgdqzeRw65xzA5cLWvBZYtUpv5l279OpOTtZZqZ+5G0XNT0JigiB1n8L27Xr9NPMe0PlxuQLHj6Qkvf6zs/XKcLmAtDT8lnYGmjXTh0GzfLRrF6jAN26sTwdmEKNFC7077N8PXHCBnj81VX+3e3ddt4iJ0Zs7NRX42+5fdFlOT9dlft8+oFkzvf3NdZqTo/8mJekv/vab3k+OP15nols3ZHgbAQhcc8XG6m3/93aH9cqZMEHvy8nJONzhPDRxH9AbOy0NvuNbIDZtn963GzRAYcJxqLNuGYoTvOAC/YOWL9fzpKToMm+Wg6QkneeWLfV+bQbXWhgP4jJvFpo3jtq00cf72bP19ty2Tf/GvDw9/+HDupzt2KHfd+2qy7x5wW/eFTTT27FDT2vXDkW9rkeivxD44Qf92a5dOv3kZF2emzfX29fMR2qq/m7TpjoPBQXAtdfq/91uoHlz5MU3QvL6Jchodx6aJRcCc+bo4+uiRXr+Vq30fpmbq9dDbKz+W1Cgz0tNmwbqdgUF+tx33nmBC7rkZJ3W6acDv/6qC5M5LSFBF7jmzQM3GTp3Lq53ZJzQGc0a+7A7NRZt2uhVMWmSrkqZp4U6dQKH3wsuCBwbDh3S81x2GXCcPwsA4GvQCPv363kbNtSrvP3xuShKqI/ERb/petTevfq37tqlEzaDJs2b6+125pl6elyc/n/NGr0NPR5d59qzR/+OLl0CQbTGjfVCc3L0gczr1dtNKV0eWrbU5X3v3kBw4sgRfRBzuQLbNDVVL+unn3SZTU3VZXb+/EC527FD/+imTfXLPAY3bBio527cqI9tOTnwXXgJYjeu0ytuzhydxg8/6HXRSO93qFdPb5cGDfTvMQ8IZqX7+OP1bzznHF3XfeABoFUr5PnqoLAQaLZmjv7OypX6O2bQq0MHnZ/mzXW6+/frdVKvnv7NXm9xfc3T8iSkpQGt44x62dSpev2OG6fT8vt1Wua1Q926+nhy8KA+Vufl6X337LP1uu/YUZc9lwvo1Uv/3vR0fcBr316fy8wgcpMm+nzeti1w8cX6++ZNxaZN9bYCdD0pO1sff7t00dvTvGu/Z48+ruzfHwiC1qun95PkZH1s8Xh02Tv5ZF2ufD79P6Dz1rGjzu+11+ptumePXvaKFXp/atNGn4djYnSeTzhBl4XTT9fnafNGZuPGer9OStLrKj0daNcOuXVPQP3Ujbrsm4GuGTMCd+AKCwMnVzOd+HidZ5dLp3nwINCjB7Bzpy4zTZsir1FrfYNu3iy9vnbs0Ov5ttuAmTP18aVePb3eO3fW+XW79frPMYI1+fl6f1u6VG+3hAR4Gp+AeG+hPl4VFuptNmNGoF7WuLEuP+b2i43VZbqgQOe/bl09j1nvi4kBWrVCYfOTUSfnoN5WOTl6Xa9Zo7dRRoZeN2efHTj2m/tsdnbgZgEAdOwIadoMmzbpJFJSApu7YUO9+zZurLOxYUNgkzRurHeDE0/Uq7fViaKvydq31+sqJwe5rc6Ay6WzfkLmRr3OFizQ9bPsbF2e09KAyy/X5aNHD/37zXpjy5Y6YHD22frc16qVLktmvbp5c+x+eFDxJen+/XpTffYZsHzoDF1ufvpJb6OPPtKnMpDpEIDlEc6rgKZO5iWUYzaARkRERERERERENYjZArk8ZovIo4gBNCIiIiIiIiIiqlrWvrjlsfb+OUoYQCMiIiIiIiIickBa2kb4/W2qOhs1R6Qt0KpA9c0ZEREREREREVENJSIYMqQjdu/+V1VnpWawPgiovFcVYACNiIiIiIiIiMhmIgIAyM+fW8U5qUGqcQCNXTiJiIiIiIiIiGxmBtAAVaX5qFGqcRdOBtCIiIiIiIiIiGwWCKBRRMwunNUUA2hERERERERERDZjC7QoRfMUzipQfXNGRERERERERES1B1ugERERERERERHVHuzCWQEMoBERERERERER1SYMoEWlmo+BZkvOlFJjlVLpSql1lmkDlFL7lFKrjNc1ls/6K6W2KaU2K6WuskzvZUzbppTqZ5l+slJqiTF9ilIqwY58ExERERERERE5gWOgVUBMTGSvqsiaTemMA9ArxPT3RaSL8UoBAKVURwB3AOhkfGeEUipWKRUL4GMAVwPoCOBOY14A+J+RVgcAWQAesinfRERERERERES2YxfOKJkPEYjkVQVsCaCJyHwAmRHOfj2AySJSJCI7AWwD0M14bRORHSLiBjAZwPVKKQXgMgDfGN8fD+AGO/JNREREREREROQEtkCrgFrQAi2cp5RSa4wuno2MaScC2GuZJ9WYFm56EwDZIuINml6KUqq3Umq5Ump5xuHDdv4OIiIiIiIiIqKIsQValMwx0GphAG0kgPYAugA4AOBdB5cFABCRT0Wkq4h0bdakidOLIyIiIiIiIiIKyQyg6Y51FJFqHEBzrOOoiBw0/1dKjQbwi/F2H4DWlllbGdMQZvphAA2VUnFGKzTr/EREREREREREVNPVhqdwhqKUamF5eyMA8wmdPwG4QymVqJQ6GcApAJYCWAbgFOOJmwnQDxr4SXTI9jcAtxjfvw/Aj07lm4iIiIiIiIio8tiFM2rHegs0pdQkAD0ANFVKpQJ4DUAPpVQX6BKzC8CjACAi65VSUwFsAOAF8KSI+Ix0ngIwA0AsgLEist5YxAsAJiul3gDwF4AxduSbiIiIiIiIiMgJfIhAlMyncFZTtuRMRO4MMTlskEtE3gTwZojpKQBSQkzfAf2UTiIiIiIiIiKiao8PEaiAatyFs/qG9oiIiIiIiIiIaii2QItSNR8DjQE0IiIiIiIiIiKbsQVaBTCARkRERERERERUe7AFWgUwgEZEREREREREVJuwBVpUasNDBIiIiIiIiIiIiCqMY6AREREREREREdUuHAOtAhhAIyIiIiIiIiKqPTgGWgUwgEZEREREREREVHuwBVqU2IWTiIiIiIiIiKh2YQu0CmAAjYiIiIiIiIio9mALtCjxKZxERERERERERLWNDqApxRZoEWMLNCIiIiIiIiKi2oMt0KLEMdCIiIiIiIiIiGoXjoFWAQygERERERERERERhcEWaEREREREREREtQu7cFYAA2hERERERERERLUHu3BGiU/hJCIiIiIiIiKqXdgCrQLYAo2IiIiIiIiIqPZgC7QocQw0IiIiIiIiIqLahi3QosYAGhERERERERFR7cEWaFFiCzQiIiIiIiIiotqFY6BVQDV+iIAtoT2l1FilVLpSap1lWmOl1Cyl1FbjbyNjulJKfaCU2qaUWqOUOsfynfuM+bcqpe6zTD9XKbXW+M4HSimGb4mIiIiIiIiIjhVmC7RIXlXArqWOA9AraFo/AHNE5BQAc4z3AHA1gFOMV28AIwEdcAPwGoDzAHQD8JoZdDPmecTyveBlERERERERERFVG2yBVgHHegBNROYDyAyafD2A8cb/4wHcYJk+QbTFABoqpVoAuArALBHJFJEsALMA9DI+ayAii0WXvgmWtIiIiIiIiIiIqh2OgRYlG1ugheopWVlOhu1OEJEDxv9pAE4w/j8RwF7LfKnGtLKmp4aYXopSqrdSarlSannG4cOV/wVERERERERERBXAFmgVYF8LtHGwuffiUWn3ZrQcc7zkiMinItJVRLo2a9LE6cUREREREREREYWhwyAcxj0KNgXQwvSUrFzW7EwsyEGj+yWMv+nG9H0AWlvma2VMK2t6qxDTiYiIiIiIiIiqJbZAi5JS+imckbyApmYPROPV2+nsORlA+wmA+STN+wD8aJl+r/E0zu4AjhhdPWcA6KmUamQ8PKAngBnGZzlKqe7G0zfvtaRFRERERERERFTtcAy0KEU3Btohswei8frU6ezF2ZGIUmoSgB7QEcBU6KdpDgEwVSn1EIDdAG4zZk8BcA2AbQAKADwAACKSqZQaBGCZMd9AETGb2z0B3X+1DoDpxouIiIiIiIiIqFpiC7QKqKInbEbClgCaiNwZ5qPLQ8wrAJ4Mk85YAGNDTF8OoHNl8khERERERERERNVYNQ6gVd+cERERERERERHVUGyBFqXounCWk5SaBOBPAKcppVKN3pGVYksLNCIiIkFonWQAACAASURBVCIiIiIiCuAYaBVgUwu0MnpKVhgDaEREREREREREtmMALSrmUzirqeqbMyIiIiIiIiKiGopdOCugGo+BxgAaEREREREREZHN2IUzSuYYaNUUA2hERERERERERDZjC7QKYACNiIiIiIiIiKj2YAu0KLEFGhERERERERFR7cIWaBXAhwgQERERERERERGFwRZoRERERERERES1DVugRY0BNCIiIiIiIiKi2sPswqkUx0CLCFugERERERERERHVLhwDrQIYQCMiIiIiIiIiqj34FM4KYACNiIiIiIiIiKj2YAu0KCnFp3ASEREREREREdUmbIEWJY6BRkRERERERERU27AFWtQYQCMiIiIiIiIiIioDA2hERERERERERLUHx0CLErtwEhERERERERHVLhwDrQIYQCMiIiIiIiIiqj3YAi1KfAonEREREREREVHtwhZoUarmXTgdz5lSapdSaq1SapVSarkxrbFSapZSaqvxt5ExXSmlPlBKbVNKrVFKnWNJ5z5j/q1Kqfuczvcfa9fivffawO3OdXpRRERERERERHSMYQCtAmJiIntVRdaO0nIuFZEuItLVeN8PwBwROQXAHOM9AFwN4BTj1RvASEAH3AC8BuA8AN0AvGYG3Zzy4uefIydnL9LTVzm5GCIiIiIiIiI6JrELZ9QYQCvlegDjjf/HA7jBMn2CaIsBNFRKtQBwFYBZIpIpIlkAZgHo5WQGY40NIuJ1cjFEREREREREdAwyW6ApxRZoETG7cFbTANrRGANNAMxUSgmAUSLyKYATROSA8XkagBOM/08EsNfy3VRjWrjpjomLjQUA+P0+JxdDRERERERERER8iAAuFJF9SqnjAcxSSm2yfigiYgTXKk0p1Ru66yfatGpVqbTYAo2IiIiIiIiIKopP4ayA2vwQARHZZ/xNB/A99BhmB42umTD+phuz7wPQ2vL1Vsa0cNODl/WpiHQVka7NmjSpVL4DLdAYQDuW+P1+ZGdnV3U2iIiIiKgGa3Pbbbj99lurOhtEVM2ZATSPZy8KXK4qzk0NUY27cDq6VKVUPaVUffN/AD0BrAPwEwDzSZr3AfjR+P8nAPcaT+PsDuCI0dVzBoCeSqlGxsMDehrTHGMG0ETYhfNYMvCLL3D88Y2QfuRIVWeFiIiIiGqovenp+Pbbb6o6G0RUzVlboL01ZUoV5qSGqOZjoDm91BMALFBKrQawFMA0EfkVwBAAVyqltgK4wngPACkAdgDYBmA0gCcAQEQyAQwCsMx4DTSmOcbswnmstkDzej3weouqOhtH3dfz5wMA0nNyqjgnRERERETO8nq9eO21V5Cby7ovUVWwBtAK3e4qzEkNUo0DaI6OgSYiOwCcFWL6YQCXh5guAJ4Mk9ZYAGPtzmM4x/pDBO6992zs2LEezz9fu/pk8ykoRERERFRbTP75Z7z11hvYty8T44e8XNXZIap1rAE0jocWAbMFWjVVfXNWxY71hwjs2LG+0ml8880X6NBBIT39QPkzVxPmIYvhMyIioupFRPD7ihW8wCCykatI9zgpKqoZYy8t2LABi1asqOpsUC2wYMFcPDZgwFFYUuCc5uf5LTJxcZG9qgADaGEEunAemy3Q7DBx4mcAgJ07N1dxTiJnVspj2AKNiKjamLp4Mc697LIaFzjx+/04dCitqrNxzPj2zz/R49FH8enYo9bhgKjaeer11/FLSopt6QV6X9SMy76LXnwR/7j55qrOBtUCt9xyOUZNner4cqx1G7/f7/jyarxaPgZajRVogVbzA2jjvv4aH3/8qmPp16TukOZBqyblOS0rC1/+/HNVZ4NqmRyXC+s3bKjqbFAtcceHH2LlmjU1rmL51VeDcemlLZCWtqeqs3JM2JWuH8q+dft229M+kp+Piy46D5u3bLE97WOJx+OG1+up6mzUah9/9RWuu+UW29Izj6sx1bhLFIV2MCOjqrNANmAXzgpgAK3mOZaewvlA374YNWqQ7enWxANAcRfOGhRAu27gQNzz4otIP3SoqrMSMZfbjf377b+gXL1pE7Kzs21Pl0q7eswYdO7Wraqzccx78513sLwGXdB/+eWXmDnze9vTNY/IXm/NGjbhzz/1zY3Dh2vOUAbVmXludqJ+kbJiBZYtW4rX3njD9rTt9stvv2Hj1q1Vsuwbb0zGDTe0rpJlkzNq4s1jpyzcuRPq1FOReqD6H7O/njULzc89FwsX/lHVWTnmHc1rWnbhjABboNVMx/pTOO1Q05qEA5Y8V3E+orEvUz9w1mPzheXhrCysXLXK1jRNd33wAXr0OAk+n70B6C433YRLr7jC1jQptEW7dwOomYHymuTlQYPw96eesj3djMxMHDiQanu69957D5544ibb0zUv7GpaAM3n0/mNja2acTiqAzu3mVkOalpLRLtd9+ij6Hh5qWdtHRVerweZmQerZNmmDfv2YU0NurFQ3ZlncbZAA0YsXAgA+H3JkirOSfl+N8aBW7vWmbq63XLy86HatcN3331d1VmJmtN13RJdOFmvjgwDaDVP4CmcNasyfzQ5dUcr/fBhfO9Ql8WaWCk3167dB/fzbr4Z5/boYWuaph+XLQPgzPpe5VDQj0KrifsMAcdfcAEuuqjmtCKpiQG0mQsXIjVVX+TX1gDayi1bEJ+cjOnz5tmSnpMt0Lw239Ah53Tq3x9n2diFsbZjF87SasLNQTOPscY1aXW3LVXftHv77cFVnJPoOV3X5RhoUVKKDxGoiY6lLpxOszuA1uuhh3DTPfcgNy/P1nSBwF04u6P/BS4XduzYYWuaJqcuKLbvcW7MHnP92tkCjSecqmF3K0KiUMyzSE16cM9VjzyCwkJ9noqJqd4XOKtXr8DgwS/Znu6i9fqJ3tN++82W9Jy6YfT1qlW4d/hwW9PcsXcvVOPGmDdvDtye6j9mWJcuZ+Hmm8+r6mxQOZxoneJkF85CtxuXXXst1u7aZXvaTqhJPVDMslBTAp8+o5zFVVFQozKOZgCtJgRvqwW2QKt52IWzfE4dALYZXcecOJiZeba7gnLDwIFo36GDrWmaYhy8I+80O7dhTWqZcixhqw3n1MR92inmBYLd+/myZX/gl1/eK+5q6ZzqvS179vw7hg0b7FhA3O6ybHd6365ZY3vai/76CwDw0EN3I/Gii7Bs2Z+2pOuUNWvWYPXqpVWdjSrn8Xiq9bHX52Dd14khVwZ/9x1+mz8fT48ebXvadkvPzcXPxsOR7CwDG3ftgmreHFdddRHu7NPHtnTN43VNGSrHrC/WlBZzVnZer/yyZw/UG2/gyJEsy1R24YwKx0CrmcpqgbZz50xkZ68+2lmqhpy5M+LkYcU8QHbs2xc3DravifGslSsBOHNBbN4xdKJS5bRdqanILyiwJS27x4CjyNSkcuf3+/H26NHIcaD1qhPYqjLAqYcI3H33xZgw4Tk8/vjZtqYbHIiyMzAlIraXDXGgVfDPf/yB/3z4YYn0K8upFtdOXLAkxMcDANLT9XhhixfXjIG+ly0bBZ+v+reYc0JeYSESTj4Zr0+bVtVZCctr2fcnTBhrS5pOtkB747vvANSMm209P/wQOS6X7ekuWK2vCf/8cwEmp6TYlq6TLdCm/vgj9u7da2uaZn2xJgbQ7DznvGkMNbNt20YAwNSpX+Hxx691ZFnHNAbQap7YMsZAmzLlKsye3eVoZ6naceqEbKbrSAs0y/8/LF5sf/oOBtDaXXIJ+vR5zvb0X3nleccu5Dv16IFe99xjS1psgVZadm4utmzf7ugyalIXzl9Wr8YL77yD/3vvvarOSkR4FzLAqRZopl271tmaXmFhYYn3IvYdQx999HI0berMBYidXWSHTZpU/H9NCqDZlbYZQDPVlIvGn356DLNmvVPV2agSe42nmY9asKCKcxKeNYD25JMP2ZLm0egKWBNutm0+GHg4hp3HGKeCh06NXef3+3H7o4+iR49/2JpuTQ6g2Xkd5DHSio9PAAD07v3vksti3S8yDKDVPHHGBuEYaEdfcQDNgQOM01F/J/IcYwlQDhtmf2Bg+PB3sMLSvcVuC4wHClRWTbi7GU5uQYEj6/j8Bx7Aaf+wtwIUzIlKscfjcSQwV2QEX7Jzc21NNycnByNGPIWiIntaU5pYiQowj3LOd7W0R0FQAM3O8rx8uT3jiYXSsWNd7Nq105a0nBjTxTzf7dy929ZjvhPnfqcCaEejZeqRI/sdX4YdbvvPf7D/oH1PBO34n/8AqN7BHq+DXThrewDNqWsAp3pIOBX49BhjNtreAs04Ztf2MdDcxeshPuTn7H0QAXbhrJnKaoF2rBIRbNoU+Rge5onI9jvFxoHFiQtsxwNoDhwUnWhyH6wmNCf21IBBmsO59X//Q9devUpddFfWpqMwaK8T+2FC+/Y4/667bE/bvPi2ez98550h+OWXj/HbbyNsTZeVqICa9hTO4H25Jj38YOHC321JR8L8XxlmOUiZMQPPjhljU6rOduE02XWRezQCER5P6G5sO3duiDqtJcuWOfYQpa+nT8crDrQo9lXjOo8TeXOyC6epJgTQnLpp5XQLtNGjP0ZWVlY5c0fOqYAfx0DTvEY527Vra8jPBcD4lBSstvHmwDHH5qdwKqV6KaU2K6W2KaX6VTZ7DKCV42gG0NZv3YpJU6ceteUFS0n5BP36XYDly3+JaH6nulqap7cTunTBpp323Ck3Od3io6a2KKkJATRrBcWucdWsRARut9v2dAFg8ebNAIAih9J3MnDrVKV42dq1iLvoIqy1cR8vDqDZXJ49Hr3dbB8o3dbUQtudmhpVvqdMGYzrrlPweo9uwLq4vNWQlqbBXThrUgAtM/OQLelYjzu2deG0/P+zTa2XAWf2teCAmV0BNCdaIJVahrco5PQ77+wUdVrdL78cHTu2r2yWwnKifmLHec2pelPw9rfjpoJTDxGwHq9rwrHbqSchOh1AW7lyOZ544lHb0rU+NXinjTdizf1q7tzZOJiRYVu6IoJp06YiPX2LbWkGc6IL5xNP3Boy3R///BP3v/EGunz+uW3LPCbZ1AJNKRUL4GMAVwPoCOBOpVTHSmWtMl+u7nbs2IwtWyq2sxU/rdF/9C4iOl9/Pe568MGjtrxgO3fqLmaHDkXWpNdcRxs2/IWde/bYlg/rwWbJOnvHrXG6xYcT6cewBRqAki3QTu7Z0/b0P/z8c7Rvn4i9e+2/k178VF+H1rPLgcBcoEuds5ViM7hoh5jirvfOPBHQvPiYPv0DTJigUFh4pFLpHo0WaG0vuADDhw+LeP7Jk98AALjd9g+0XJaYGt4CrSZcPJoOH67GATTL+a7IxlbHTpzjgvdfu4ITR2O4gnABtNrCjgCaU/t8cADtued6VzpNp8bSKrIcr49G4LeySrSarQEBNGs5zcrKtC1da326XcdKxRFKsOZ3xm/hhyLIjbI3xrZtG/DMM7dj7NhbKpy3UKxlwNYunJa09uwpHYc4kp9v27KOafZ14ewGYJuI7BARN4DJAK6vVNYq8+Xq7oorTsdpnTtX6LuB1lVHv9vYz3/8gfT09KOyLOvBwxx7JjY2dJ/tcAYN+g/ade9uW56sBzG7m5s7HSZyIkDCLpyatYKSkWlfRcI0fd48AMBffy20Nd2MnBxkGmNyORUcKCyy92Jo4759xWXZ6cCAnZUWp7pwmulNndoH+/dvxKxZIwEA2dkVH0dIRDBq5kxb8lee+fMj77JntjwL1aIqIyPQ3SA3L8/WFpXmUe4f/zgTw4a9blu6TqnJXTgPHbKnZYATF6NOBdCceIhAcBDGruCE5ygE0MJ14awMp4II1bUFmlOts4MDUd9++1Wl0/QX3wSytz5p3Ued2P52121qags0wN5t5w46tubZ1KvDWl90hdl2czduRINHH8WcKB7k5nLp/O3fv7ZyGQzy1VeBYQLsLA8ey3ZLTXX2QV/HrOjGQGuqlFpueQXfdTgRgLV1UKoxrcKO6QBaKBdddD4uvvLKcuczd6PgLpxHo5L8r759cc01V9uebkFBDvLzS7aYsD4kwXyseWxsZP2JnQq6WNO979VXHUvbCUdrDLR5y5ej54sv2laBc3K92HXSd7plSmKCflqO3QGj4b/+Wvy/U+NOrNu1C0uMx6jboWPfvsX/232REFzW7Aw6myXN7kC2Nc8jR96Jw4f3GtNLrpuDB/di8+b1EaX515Yt6DN+vH2ZLENsbCw++mgo5s37ttx5zRspobpw9urVtfj/Bh064O9PP21bHq3Bh2HDBtiWbiSWL1+Oa645F4WFkd8VrsldOF0ue8ZidLoLp9vG46UTZ7jgc4VtXTgt6U5OSbG1K1TxMiJogfb5530xe3bk49D1GTmyMllynLUOYcc4Y061IC4KKld2LMfcP9PS9tk6VIU1EONEQLHuFVdg2p+Rj81cHmvd4MHnn7ctXafqdlNnzSr+384AWvCYwuGCXdGyHruKwqS5cKseF2zu0qURp+vUw4XWrv2r+H8nunACgeAfVUDkAbRDItLV8vrU8aw5vYDqZsmSxfhjYfktTMJ14fR6AztC8M6WkZeHJ196yZa78tu364i16tABvT/6qMLpZOfkFP9/113H4cYbG5b43FrpNy+YIm2B5kTlwYmuaFZ2VfJFBLsPHCg1fcaKFbakbxXchfPX33/HHf37Y9bKlUiv4NMGf1m+vMR7JwNodj2NJ3i/Cr6DVhl+vx/zlywBEDhRb968GU2aJGPy5C8rlXaO5ULbqUpWj//+F91vvx2b9uzBJS+/jDwb79r+bLTMs0vwPm5n2TMvYJ1qgQYAe/euRlGRDrQEB9BuvLENrrwyslbPR7PVZ0xMDAYM6ItXX428+0OoCuuBA6kl3q+1ceyUzLw829IKZ9So20JOf+bZZ7F27Ups3fpXyM9DKXSVbMFjV+B96NBnbEmnLNHcjHC5XMgNc55xojXH0ejCWd1boFlbIN3Zpw8uvPlmW9K1CtUCraCg5CDl338/FCNGPFxmOtZyP+evyPefqmBtzWRHiyHr9k87ZE+3aAA4/dOS135er7fSxxfzHPbttxPwjo2BTmsXTqda5H2ekmJLOstCDNj+pU2twIPrdnYcYw5kZ5d472QLtMKiIrw1bhyyKtkSzVoGwl0LJxkPX4nmWjnUOcvjcePrr/sgL6/iD1ewbqenn3nGthv11gBaNDfmyMLep3DuA9Da8r6VMa3CakUAbYFxYZwZRbcvf5gA2jff9Cj+/8cfS9696J+SghHjx5e4YxCp4IOt9QkmoytxgL+rf/8yPx837izs2qUH6jUDaOEeu1ua/ReAI2fMKDXNzothuyrO78+cibY334x1O3eWSPO2N96wPb+bUktetF79wAM4ePgwgIpXAictWFDi/ZfffVexDEYgzqan8Zx9dclWmY9++KEt6QLA8PHjkXVEt840T6DvvPMO8vPz0bv3PZUqN7kOBdBC5emM++/H/A0bMGe7fU3Gn33rLdvSAoD8oMCDna3F5m7cCAD4ddEiFLjs66IUbp8ODqBFIzg4sNfYp50QyYW91+vFrl2bLO+P3vAFU8Kc40aMeAO9eqkSZb2gIA+dLr4YH300CPv3R9eFdsWKr0NOdxllJSEhKeK0gltxlNUCTUQiPoZMnvxB8f8zZ34TcX5C2bpvH35evBip+0rWE71eL9LTD+Lyyxuh/6BBZabR6dJL0ahRg5CfOd2F084W1inGscFO/3ryyRLv7Xry3NNffFHi/bZdu+Dxem3tMh2qBdrPP0ffIsfamtHpsdtWb9qEFZXYjtYAmh3nHWtQq8Wll2KtjefdYCN//rlS37eew1atj6yVdCSKHG6BBgD7bQpOpuzeXWraPW+8YUvawWXfjnURnOasWfYN+RBcF73xmWfw4ogReOabyp1zrL87XKs2M4AWTau3UDf0Hn+8E2bNehcTJ74YZS4DrOetKVOmYJFN424zgGYT+57CuQzAKUqpk5VSCQDuAPBTZbJWKwJoF11/PUQEPa64otRnhS5XyIizuVOZ3RpN6ekri/9fsKDkXRzzwFGRljGh7mRam9hWtHK6OcQJwyozczM2bdIDPZq/NSam6h4/XBiighjcnL0ygtfi75s2YfD330edzjxj4PPtBw5g/LRpJT6LvemmimavlG/KaS2ZX8EKdXB5+2TChAqlE4n4+OjG1IvUjJUry58pQuu3Bh41PXDg4xg7blyJz8M1RY+EtQXajAhav0bC7/fjwxEjwn7++I8/VjjtaAd3jYaIoNntt5eaZgeP14t3LQH4teUc+6IRLoBmvQjdvDm6bRsc4Bv0U6XO5WWKJID26acv4q67zih+H2mXCTu2X7iHxQwb9gqAkvvf+vXLsGHLFgwb9irOOuecSi8bCHTHjCYAEnyeT08P//CdTz7pjRtvLH8b/PhjyYuXPn1ujTg/oZz60EP414ABaP23v5WYnp2dhfbtmyM3NxtDhg8vM40dYfajQperxHbbsTeyhw+Vx4mWmeuCWp58+8MPzjx4RcVg/oIFSMuqeIsIAPg2xNNHmz/2GJK6dYs6rSNHslFQUIDc3JwS0z2e0sd5lyvyh6L4/X788MMXmD49EJTetGcPtjpwI8AsEV1uuAFd77uvwunYeVMFKB2EO3Skcg+VKUtGJdMuOd6xfXVqawBtT0YGXDa2GjUlGcNrVJaTw85sC7rRbcfN0qIQaSzdtCnEnNELfvDbig0bAAC5ley9UKILZzkt0KI5BlvrIyNG3IhFiyZj//5tAAC3u+SxbN++LTh4sPzzUVFREcaP/6TEtG9+j3y82HD+OnQIBZZtxy6cFWRjCzQR8QJ4CsAMABsBTBWRSt1JqBUBNADofsEFWBuikl731FNx48MPw+0uQm5u4MQfyUME3O6SO4X5pL2K3IULPtjGxsZir6XS90UFu1FFcsL47rsX0KuXCjl49L59e7Fli77j9+GHb+GyywIPCzhaXZBclTgRuTwe5BSE73bbY/BgvDRlCm4P6tJYHutg5X9V8EmvkdgWopuoVUHQCehATg7+/cknyC8nCOLUncJQ4mJjse/wYfy2eLGtXQvtKn//uOoqjAm66/ZQ794YOzYw9ovZhSk7Lw8ZQc3qy2MNoD09ZAgWbNtWidwC/3zqKcQmJeGZ554LO8+B3NwKr5/bygjMVVZw6zNAl8VHhg3Db0YFrqKCbxbY0Rpi67ZtyMnJCbsurQG011+/sPj/5cvDP33KFHwxF6qybBdrYGjevNAtpFetmlfiffDNo3DeDHGxH63gbRXcVaWwMHAMt26LQ+W0THBFeMFszhdNq7vgFmhvv/0YAGDBginYtq1kvWzOnM8AAMOH3wUAyMjYj4MHd5ZK8777Khcwi9SCBfPKnecf//oXvghqCWW1cM2aEu/nL11a6W6401auxE9hytOWSowDFup8V+f++yuUVm5hIZ59+WUcCtmjQXBJz55oce+9tncjr8i6HTllCk45pRE6/u1vuOuuy0p8VlgYOI8dOrQPHk8RfL7IL2hfffVuPP/8vejXr+ST4xfvq1SvGGzevRvHBQXJdqWmYlVQeauIigxIP33lStw1dGjIz4IDUUfjgU8VZQ32Hang0B+h3G8JwIsIbvr440ql5/P5cMm995aYVicxsVJpmsLtkeq667C+Eg9ue3/sWPz4xx8lphW63ZhVySFdQjUoGPb995i9ZAncHg8OVfBm5/qdO3H9w6G7Zv+wZg2OVCIIOs/SjTvc+TfeqI9UtAvnqlU/4KOP7gwsc9744vG9//xzKp588jTcemsbHDy4p1Q6VpmZpYP9H35b/jixAOD2+XDZhx/i+KAbUN9v2IBzgq4nIm2BVv2fYVsF7OvCCRFJEZFTRaS9iLxZ6axVNoHqKrjysjREpexXY3DvX2bPxg031MMzz7Qt/izwEIHAgSQvr+zKepyxEX1+P7IKCrA7J6fM+a2eDLpojYmJQftrry1+/6fR4ilaoS78Dh0KHZQxL5iskf5zz22Diy/uiDFjx+Ktt17E8uVLMGzYEACl1/FrI0YgrkWLCuUT0BckoZ4+tTotDalRrEur7qNH47h//7v4fbhm+1Oj7ApUHEATCVlRtiu4U94gytuDLipemD4dXy1ahO+Mk7nf78fcVaswx9JaKzc3F9+EePpNZpSPVS7yerEiRGU5+LfHx8ej1SOP4LJ778VZFex2mRri4kmgA4YHKliJ8Pv92LV/PxYZXbzLYt69b/nggzj+ttDjKIWTE5S/nHIu6v1+P36YOROLVq1CVm4u7n/5ZRyxXDylBHW/DSc76GLB5/djt+Wib/r69Xh5/vxS35vrQFcnAPh4wQI0veGGUtMLiorw2a+/4rIhQ5Bbxrrx+/1Qt92GAWECfGuCApPmscQvUqI5faREBKd26YKGDY9DRkboyvUHH+hWzd9+W3LcqieeuAwPPnhvmS0Xr3/hhRLvnbhzb5o4MfAUt1tu6RkyX8H77QMPnI733w88DTPcb5liab1ZEQeys/HhlCklpsXFxWHMmNeK3592WhN8+ql+n5UVeXeezSG6VBUVuUpU7FeuXIGdO3Uwy+MJX6F/a9IkzLEcK4IHYTYNHXoHbrqpc8humwsXTgIA/POfJ+LRR9sVT3/77WcxZMhdEfyio8PlcmHR8uW41xLIeHfUqBLzhDrH3fb++/hm8eISd98jNXHJElz79tuYFuKi84dVq3Dau+/ipd9+C7vssrwVplWBiGCbJQibHsEF3dAZMzD800/RLERrsB9+CJTjD//4A1luN+qmpEB98gkG2tRt7tWZM7EhLQ2b0tLKnfcJo3va7t27sXZtyfWan6/PBT6fD3fc0Qr33ZeEbdvKD/ybZs6cHHJ68BMko/X5L7+UOmf+vmQJzr744ojT8Ph8IeuS6RV4evc1b7yBSfPnY/WOHaU+C65PutxueH0+jJ4zB64K3sAJF1SYtmQJVI8eGGi0snZ5vfD4fCh0uyEiQ+vEEgAAIABJREFUGPjZZ1hfRhdSaz31SE6OHvd1+3ZsCHOTtsDrLVWHCGVF0Hl3egRd4JauWxcyILxu92785+WXMT/ohrbZwGDM/Pm4c/ZspFWwJWFOGfv31Arun8MnTsRzIYa56D9uHHr274+FlbgxGCqANum333Dl448j8c470WzUqIiOhfmFhci3NCTYWE7r/D8r0YJ2rGW8unBl2TxGRNKF8+MxY1CvXt1yb24dPrwPPp8Hw4cHejg8++wVyMvTweKdO3fis2+/xeHDh6FatcLAESPw8MN3h00vx+3GljDn+KUHDyLxnXfw29atyCgogLrtNvT+9Veop5/GTZMmlZo/khZohwBUXd+vasreMdBsd8wG0NZEcNC69trAmEp+vw8uVx5mztTd+eauWmVMD+xA33//bKk09u3bg6lG1xtrC7Sz334bbceOLTGvy+PBkRADNB7MzMTnQeOmBXclqZ+kx2bZm5uLB6ZPj7hVVqiD67XXtgw5b2GhPqENG3Y31q+fW+Kzh3sHngg7cGD/kGkP/PRT+Hw+/GGpaLi8XhwIOlEu2L4dqSGaozc791wMmDq11PRLx45F6xEj8GMELX88Ph/S8vLw28aNSM3OxmpLJTPjyBHkRjlA5pasLIwMEWyyBtBC3d1ee+gQzlm4EAfK2U5evx8/bdhQYl2uyszE7sOHsXrnTgyYOLHM7982ejR+27sXIoLzJk3CF8bdn8SEBHi8XjS4/XZc3q8frnj+ebzy5Zc4nJ2NnWFOnk3690dmORcQ1oDef+fORddPPsHyAwcw3bK/9RwwoMR3rE8Q25GZiV8tLSvzPJ5SrU/yXS5c++67eGLUKFzz1lsocLnQ+u7SJzoRQcshQ9AyqAvt2txcXLZkCXLcbmQXFOD5n38uFZyY/PvvuHP4cJxsCVKX5euv9cWCWaH5ePZsAHpff+Ltt7EhRAB26fbt2JeRgaVBlVq31wu31xu24jPk++9x42OP4R/334/3pk7F+J9+wkuffYaFq1ejIIo76JONlpF5Xi9yvV48u3Ah2g4cWBwoveaTT/DmokUlyu/6fftCBm33ZmRg2LRpxXk+4vFgZ1DA1fp75i1bhl1BFfOnvvsu5KDgmZa74Z3fey/s78kyguhvf/558bTV27cXXxgsDqq4P2jcGXxo9mwkRBAktfL5fHiyX7/i9z/8EHqMQK/XjSNH0vD77x+U+mzixC/Q6eyzI77Yn7p0KX7auhXbKxgQ3p+Xh5lLluDivn3LLSczZvxS4n1OziFs2lS6Fe577w1AevpBHDiwFe+//0rItNYdPoyECO/aAnqfMcvY+gMH0PL//q/UPB6PB+PGDSwx7bPPBmL69Cl44YWSXYDzCwtx2n//ixbPPFPqZsbGEMG9yy47FRdd1AmADgpecEHgyaJ5eVnFgcJZy5dj5ooV8Pv9yCkowIuff44rHn20eN6Px5R+OqF1W3fqFIObbz4Hq1eX3wph4sThmDevdMXbKsflQppln/P6fNjqwNMZASAzs3SQss+gQXC73XC73di8eVPIcj1n7VrcOmwYnrXcsHSHOD/2//VX/BJUR7t79Oiw+ZlpBPUHL1yI1QcPIuaTT3DKqFFYYQmIhLvZdCArC1PXrg352a3vvotThgzBS0uWoMv48Thh/nzMNeoMy3fvhrrmGqjevXHWSy8h26jH7Cxjnc+dG3ji8srUVPyVlYVC4/e/FuIC3S+Cvj/8gHVG99f8oiI8WM5wCoPmzkWnoUNxxoABuK+Mmyk55bRYKyrSn1sH4Ha5Qt+onDFjGnJzc/FdBONwrU9Ph18Ev+zfH/U4Y36/P6Ljpbr/fmQFnX/cRkAJAE778EO0s7QM8RnpTgoxxu6azMwyAyvmGK5dnngCG3eWbDUa3ALtjgEDED9oEHqPHo2+xjVENNxeL+4LM+boCuN8/tqMGTiQk4M6w4Yh4f33Uffpp7F0yxa89umnuNIYk8/v92NMSgoyMjKQ0KwZWnTpgsGWlmHZOTl4e+RIXDJyJDoNGoQVIW6eXjB9OhpZzrXREBEMXbAAcyzBaa/fj8lbtiA9Nxfn3X8/rn/nneJ9yu3x4M0pU/C3p57CyBBPpnZ7vUjNyMDD48Zh8rZt6Gk8ldPt9xeXscMuV4khTYo8HuS43Sj0evHp8uXw+HwYXsaTyv1hxqnck5uLHgMGYPDo0Xjiq6+Kb/J9/eefUBdcgGfDtE40H7DzgjEcyKgtW9Dom28gIpidloZl+/bhm40b8VdqKn7fuhUHLfWg3KIijPnlFywPKm+hFLndxce+s8aMwc0jRpQol6MnT0by+efj+B49AAB9X3wRt73+eqikimWFqKeN3LoV06Ic4+/DMWPw/pdfYsrckteT5n5aWFQEEcGsxYtDDqW0aN06PNW/PwoLC/Htt5+VuSy324WZMweUmJaauhVnntkA69evQrv27fHIgAHo/+qrAIDXPvoIf/wxL2RaccOH47iJE3Havn04FFQmRATnhRj2Z3QZLWTDNVqxiv5oUUtU4wBa8V3S6v4C0AvAZgDbAPSLYH4p67V2rYT9rHPn80tNu/DCu8pMb9IHH8gdXboIABn85JPF0/Mfflhk0CCRIUPksnbtBIBccsYZsmzYMJGJEyVl9OiQ6bVp06bE++SkJLnUMu37G28U6d1bCoYOlStPP11G3nCDzH3sMVlx110in30mG8ePl3Xjx0ubFi3KzLf11bLlKcX/N216kgwe/HOZ6++UU84I+/n9Z5whO669Vq448UQBILnPPScDr75afnrkEQEgsTEx8u4998h9f/+77OjfXwbeemtEeXyuTRtZ1KWLPNKkiQCQl046SeT552Xdyy/L1pdekoe6dy+et0WDBsX/P92zZ7lpXxsXJ4datBBp2lTk9NNlwyWXFH+W9tprIgMGyJJHH5WOrVoVT/+qXz/pZVlmqJf/tNPkjRYt5KmGDWX8mWfKkksuEXn8cZHnn5cx11wjAGTUxReLPPywfHXbbRFvL+vrb5bfCkC+euklGWIph5G+zm/cWKRHDzl83nlyR5MmsrRtWxnXsaP8es458sW11woAGXLVVSIvvyxnNmsmAKRRUpIAkF6dOsl7//53RMtpmpgooyzrbdJjj4nvo48k+8035dvnn4863/OSk2XIOeeIv0sXudrIV/O6deXZyy4TAPL5nXfKR48/LpeddpoMv//+Cq3jxdOnl3j/xL/+JdPefFMAyFWdOom89574Bg+W7/79b/EOHhw2nVF3BY4lM887Tx479VQ5pVEjWXrnnSL9+sk155xT/PnZp5xSobyaL+ndWxrFx5eYtu3112Xxe+8Vv//immtEhg0T/8KFYdOpk5AgAGT+1VfLT507F09f26uX5DzzjCzu21fqxMdLz7POkj5GOQEgL9x+u2T+739S8NFHYdO+/4orSua5Tx85cscd8ly3brLmpZfEN3SofPSf/5SYJ2fkSPnzv/8VADK0d2/JCLO+5emni//P69BBpFcvybniCpl5wQXyyXXXSXxsrGQNHSrvPfWUHPziC1n/8ceS8vrrUa3jrl3L3md7nn++/N6nj+ydOVNkwwaR9HRxf/xxmd/ZVK+eeOvXF2nVSqRtW5FTTxXp2VMmX3ihXN+xo+zp10/ks89EPvlEZOhQ8fXtW+L7f73zTrn5fvfdCbJtW6b88YfI1Vc/XqlyBkCOHHecSKNG4jrpJCns2FHk/PP16+GHRe69V+Spp2TTgw8Gyn4Fjk+hXs2NcwEAWff22+L//ntZPmKETJ86Vc4988yw38vK8sp7L79canpycn258uKLw35vxjvvyOmnnVbh/E6bdrj4///+9yX57rs5Zc5/YMIEWfPKK4EyfeedMuuGG4rfr33lFdnVv7+43n1XMt59V2TmTJH+/UUmTIg4T6m7d8veoUPFP2uWyOLFMnfuypDzLf05fJ0g+CWnny4/d+ig83jhhboM9OsnX957b/E8m99+Wzzjxsllp58ecbqDL720+P/j4uNl33XXSbfWrQWATLjpJnm8e3fJGjxYst99V9xjx0rdxMSots9ZjRrJBzffLN3ati31WWxMTFRpJcXGllwnV1+t18MDD4g8/7xMMI59bZs1k1n/93/y5i23RF2e8u+/X3b27Sv+MWPEN26c5H/4oaS8+65cYjmPhHt17Xq3PPTQu1Etb+HCxbJlS0GZ8zxknLfeb91apE0byW3XTqa1ayevtG8vX3TvLjJ4sMizz4r06SMyYYJInz6SO26ctGrcOOJ8/PPMM8X/wgtS0KeP3Ghsq7ZNmoi/X7/ieTIff1zkk08EgNx3zTXSrVOnEmksuO8+ASAXn3DC/7N33+FRVG0bwO+z2fTeOySkkISWQAotofdeE3ovAiKCgCIogqCABVFQwY4NG4r9w16x4IsKKoiIgmABpSiChJzvj50Nk81udjeZyWbD/buuuWBnZ2dPZqeceeY550iZlCQP5ufLk+PHS9m1q5QrV8p/16+XoQEB5ctvuuYaKbdtk5898oj8Zd06+fK6dVWWcW9EhJSZmfLTpCT5elqa/Hf0aPnB0KHy6JQppuvctGmyT4MG8pOBA+X5RYuc/u21nE61aiX/zsmRD+fkyLIBA8rnvzF5svxv9mzT7zV5spQjRsgXlTrUoaVLra4rUqkTApC78/LkS02ayJsttr15ahQdbbdsbZo0kQ0tlhuj/OZjGzaUcvRo6Wc0yqSQEPnXggVyROPGMi44WAKQV2RlObUdHu/USZa1ayefy8qSDXx9K71/0+DB5fXKqqb89PTy/9/bsWP5/69Rzbec/rv2Wnn89tudKu/2O+6QAORQ5Vyrnpo7+bebp7uaNpWyfXspi4qkHDhQ7mvXrvy98wsXykdLSuTfixZJuXixPHnddbJxdLTcUFIi37NzPBy66SYpX3xRrh0xwlS+9HR57zXXSABy1ogRUn79tZTvvy/PvPCC/OWZZ5wqs59fkM33wsIiqrUdAMjNnp6ybMgQuSwkRP4wdKg8qbp+aTWdvewyeYfy/1aAdHW8pa5MrXJypPz7b4cmAJ/XelzK1RvIoUKaMht/ANAIgBeALwFk2flMlTvswIETND8IzFOKKsAyOj1djm7RQj6hnDDMU//WreWJ++6r9ndMz86Wc1Q3supphqqCqdd0xRW2AwTWphwHLpJ1YVofEiLfCAqSmy0Cjy9NnChftPgNAci1l9m/8dwSF1dp3oXp0+VnY8ZUmHetEoB19XR5fLwcFxVl830/T0/5vsYXkfjQULm0Tx8JQM7t10/zv6mgYUPdt1uLuDgZ4e9vd7nWyck235vRsqXsbOO4rs4kp06tNM/fyg2lXLtW/vbSS7pvI2tTr9zcCq9HqG6mh+TkyHyLhwkAZFHjxvL6nj3LX19tEYQzT+khIeX/j/XwkI9ZCaisHjSoVv7O1AYN5JLLLpNPbtwov7Nx42Ge0gwG6QfISX5+5fPaKDcEAGRRcrJ8f+FCOTgnR941aJD0twiSjlUF/6vc9r0GyPXrP5BCCE3+xjYWAYNZMTGyXXS03DtwoPzMwYcknKqe9irnST2moubN5e+vviq7d+9b43V9anHOXWUjoBOi2serMw1V1bcsp2wr5w5XTgXBwbJxUJDc1K6dPDJjhqbrHqqcR30tzgWunHwNBvmLlfrPgqIiOb9VK3lk+nQpH3lEzsrJ0ew73x5Z8WF3Y1Xd06uKbVOiXLujfX3l882by+42Hl6NcaJ+3dfbWy6NsH3zPkIVTFnlQFBGz6l/SIgsUQKYY5WAtHkakpoquyrHUhPVdah7DR4kODM1tnMcD1G9PzTT9oN9LaamSlKAvamVlYCWu0yhnp7y65wceXdqqvS1uKYPUI6LAY0by/ucvBYVJCfLNRMmyCts1NdeWr9etm7SRMapHoq5egpS/T8nLEweLC7W/Dt+GDNGXmnebwDp6phLXZla5eRIeeaMQxMYQLNRSKANgNdVr68BcI2dz7j8wLM2tUtJcXkZajJlZ9t/qunO0wLV00Y9p5lNm0pfo9Hlfy+n+j3dnJ9v873p7duX/7+wUSPZwE2C3Jw4car7U3FgoMvLwKluT2mhobJBHbpZ1nJKduBhGidOnCAjlAed3kpLh7oyRTqZcVyTKVX5lwG0i1Orli2lPHvWoQkuCKC5Sx9o8QDUY9IeVuZVIISYKoT4XAjxeVhoaK0Vzprp7dqhV1JSpflPTZuGB1T9iWnl1j59yvvl0lNBQbtqfzYnIUHDklQUERCAa7p2xYMjRthf2IpBMTEAgNWqfkNGxMXhzk6dEOnvDwAI9fHBB5Mno23jxtX6jrcTE7GrXTv0j4nB+t278a+VNv/dUlMRqAzxXJek+PoCADb0748gKyMivabqG8ieGzMzcWHcONyYna1Z+SzNaNBAt3U7wttoLP//yuLiKpa86PrWre0v5KSrP/20/P8d4ir2fXjLwIH4bsoUAMD7Bw7gZ1XfdNXRLM5634qOCvP3R3GLFjVaR3000M8PfZRzEABc26lTpWW6JyXh4+Ji/KbqwNeVfsvIwLtNmuDh1FQ0CgxEuEajqFFlaVFRri6CVVtsjPQXHRhYrfW9MmFCTYpT5/h7emJoSgp+Wb4cNwwdWu31ZAQHIyk0FD51sN5gzfyMDBQmJaFNbCx+PnUKPx83jYQ3o3t3bJw40c6nay4uLKzSvCsyMyu8bujjg8Tg4ErLNU1JwZLiYiy1U4ef16cP0iz28/ut3A94GQzwqIMjd3aLjAQAjExNxeicnCqX7dmyZW0Uqd6YmZxc5fu1cR9XHT/1748rc3PtL1gN14wfj0B/f6dG5awNCap6vKVr2rTR9Lv2A2il6RrriTrcB5q7BNAcIqXcKKXMlVLmBlWzkuaIoKBEu8s0iohAqHLTMKnVxcMiLiQE44qK4GEwINjPD22refExCIHZTZuWv76yfXvsV3V6nRpfKb7otHHjrscjj2yrMK9Nm/bwduJmaLFy8W0TH4/7S0psLvfwjBl213VP4sXt/nl6OkrCwwEAbxUX4/ulS7Gyb1+MLyjAx04MTx8fGoq3lyzB03l55fNu8vPDP+npeLxlS8zKzsY9gwZhdvv2ODJvHto1bIgPlJGt1EICAirNO9q5M/Y3bIgAgwH9goLQ0d8fLYKCsMFK4GhvSQn+GD0aL48bh1PFxRiqQaVkuRNBLbNkP78Kr0szMvBeq1bYX1gIefXVuKx1axxfvBi/XHEFIlXLdkxLw4V77kFkUFCV65/bvj0WpafDIASubd7c5nK5ycno3KyZw+XuaDRiTatWWBEbi7Pdu6N1SEj5ezPamYK+Vw8bhhO3346PbrwRTy9a5PC6q3LyhReQn5VVYV5MYCD+uv56bJw4ERc++AAlFhfa7IQEfHnVVTg65+KgJCOysjBfVTkpVgY3yGzYUJNyflRQgPuVTmQB4J1Vq+Dv7Y3G4eG4v0cPh9fz7+jR8BICPgYDXm3fHgYhcHOHDgCAZvHxeHbePABAdHg4XlA6Q44JCsIXixfjnRkzcHUVAe4j69bhiZEj4WM0ond8PLyVzpt/XrIEWxYvrrDs+Pbt0TE1Fceffx7nXn4Zz0yciB332e5kdk+LFngtPh7/de+OJSkpAIA7+/TBHGXfKMjKwoerVzu8HRw1eOBACCHgVUVFzNKo6GgkC4FV3t54JTwcW6Oi8FJ8PDZmZeG7fv1wY48eeGn8eNw8ZEj5Zx7o1QutY2MRFRaGG1SjDrvCvvh4RBmNKAoKwtjISPxQXIw/hg/H39Om4eepU/HvmjUou+MOzFHtjzX1wPTpuL2aD08ctcNiuHpHDBw4Dp99drDCvPnz77W+sA2HH3oIf1fx3W9deSV2zJqF9664Ah8tXIjiDh2wvaQEj06fjgesDNBgy0OTJuEW5ZrRunWhzeW6WQngWnqkXeUHbSdKSnB67lwcvOEG/GZxPNvjbTSiV+PGGGflmvFjnz54acIE/HbVVfjrmmswRFUvAoCudq4jTaKj0aiK69Y/d96JjGqOLr6sSRPc26wZbm/bFvfl5mJ/URG6x8Zic1ERTs+Zg6d69kRccDCuGzwYsVYCNo7Y1r07fpw/H//eey9eVs6/zli3znbH6mb5+W2wcon1QURsebOoCG+lp6PI2xu7EhPxR7Nm+L6oCKuzs/He1Kn4qLgYx2bOxNYrrkC/lBTcOX48pjiwbzki2NsbJ6++Glt698ae667DXOVcYzAYIKwEKMY2agQDgMcyMnBhyhQcbN8eP1uMkgwAXz/2GJaNGoWJ/fvb/O5nhw/HLWPG4Mm2bSvMLwkNxbKcHLw2YADKrrgCO0aNwh9TpuDwmDH4ZtiwGv29ABBvEUh/yEr51Tw9PfH8+PHYf8MN+EgVQCzr1w93K3XUjNBQbBw8GG8PHYr5rVrh8U6d8HP//rhw8834bNAgdEhJwRobge3/2ajTj2rZEn+//z5uHzsWPl5ezvyJ2LN8OTZ37lz++rfOnfGZ8npZXh6OLFiAMif306qk+fujV2IiNs+ahbBqHp+psbFoptyrAMBdLVrgq169UHb99Xhddc16cMgQ/LVgAc7ZGGW8KilKwkhLJREAAFqr7mmcVdqnDw6o6qNnunRBA39/TLN4wPn11KlY2qULDq5YgR+WLbNcDY5/+y0Gq34vAPBWBfpTlHu6sOBgpCt13an9+6NfQQHeuv32apdfCy926YIbQ0Iw0EZwJtriXkkLVd89XYLq+CicjtfqXesXAOqoVYIyz6baiuHPmrUYiyYNwY8HDsDrvfeQp1R0G4aGwjM6Go/v3Yux2dnw8/ZGpDKSpsFgwJFHH0VoaSk8W7fGunXrcMVdd1Vad0RoKI6phhP2NBjwXJ8+6Nu4sWmHOXECIQkJyIqJgRACsUolcEnfvlh21VVY+dhjeOrddzF51Chcfv31FdadkJCKw4cvDj+9cOFjWLXq4kiHo0bdggkT5iEjA3jhhfcxYICpQt2gQRJuuGENrr56ts1t0r9JE2T6+GBRUhI+/fdf3Pi//8HbwwMhShZTUWoq3lOGvvb38sKns2fjV2XbWNMsOhr39eiB/K+/xsiUFPzxzz9odP48NoWEYGFyMrIbNgT8/ADl6UVrVabboXnz0OeZZzCoZUu8tns3PrEYlS0qKAgdmzQBVKPzDPb2hp/qgBzctCkGZ2cDSnaaZQUsLTER148YgdGqG/CdY8Yg5tgxwNMTp9PTAV9fQBldL97XF8/26IFWSUk4WVqKEx4eSDcYgNJSQAkaPD11KiLmz8dxG0/xzR4cOxbjwsKwZvt2LNyzByOzs3HGwwPxCQlYNGECilu2RPq0adh45ZVYuGkT/qpiZC65bh1K33gD8sQJ/HLmDP44dw4epaUotMjmNHp4IC4wEL/PmoVWjz6KL44cMWVcGQw4umEDHvvsM4yzccMX7udntQL7w+rVOPLrryhURmG8ubgYnfPysPWjj/DVX3/hBosRbdW2tW2Lft98AzRpApSVAR4eFUZ+WztwIEpatkTrbt3geeQI2sTHAwEB2DJnDorXrq1y+6oJITCooADPqUZlDfL3x4cbN6Lsq68wYN06vPbdd3hryhT4enqabgYMhgpPFGMiIvC/RYuAs2eBP/9EWZ8+2Gc0onFmJnDuHIY0boxn9+7FxhUr8OSNNwInTgBhYdizcydCIyIQ36+f3XLePHo08ry98e3+/bh/9270Cg1Fm9BQHFMqq0E+PujQrBmgjKg0sVkz7PznH6S3aoUbH3gAx06fxjNz5mCoxbZp3rAhfIxG/NGuHeDlhaCwMFwoLoZMTIRfVBTGFBTAQ3lyfcWoUejfvj22Xn89cj08kBATA4SFoUN2Nm62Msz3hO7dTRUrIXBsxgx4//knfgoIwBE/PySGhuKCxc3BA5MmQZw+DQQFAaWlGJKdDVjcOCdERODJjh3RNDwcwV99hSx/f8BgwHUpKSiMjka3ggKcLC2Fl58fllx1FQL++w/nnnsO3/zyCwavXIluXbti4+bNVW7rhIQWiI5Oxc6dFUehbNAgHd999y18Dedx8M03EbRvH4ruugtlUuLlLVtw2bhxGDZgAO568knsUkba6p+Tg3MnTuC+xER4nzljOk6UcyYATElIAJRKfJ+MDPQKC8O6N95A97Q0xAcGlp//rhs5Ev+cPo3VL7xgtcxbt76FY8d+w7Fjf+Pxx9cjI6MjRo++DYsXF+Lrrz+ssKzRaEROTh4+++zjKrfDU61bo+CbbxBrMMDTSiaMEAL+np7w9/EBlN/59iFDsLJvXzRdtQoHbIxsOHfuStx2m/1g94SOHYGzZzGnXz9seOcdzNy4Edufew7NUlJw66OvYc2ahejSZTQOH/4F3bq1w113VX4IYhYTE4epI4oxpU0bRPr4wLO0FMLDA0L1WzjijTd+QlxcA4SEVByFsnfvidiy5Vb8/PM+u+sYO3Ye4sPDgbNnIZctw29HjyL6xAl4btmC0rIyyLVrAR8fJHh4AD4+gI8P2nTpArz9NpCZiSMWo3lbM37ECFw5fz6a79qFu5WRA4uKuuCupddi63vvYcXKlQCA/t27Y/7UqcgrLIRPdLTVdaXGxKBH8+YYExOD7r/9htdLSzE2OdlUNi8v0+TpCZ+AAMjVq5F+2234/tdfcdeIEZjZpQs+PnIEbZVR0tR+W7UKOH8eS4uK8LAy2tn17drh1W+/RZK/P5IyM4EzZwCDAU+PGoXbduzAtS+/jHOlpXhl4UI88fzzGPfMM1bLvGP2bAQcOgQEBECoRtQL8/dH7/x8+Hl7Y/dNN+G6V1/Fyi1bAABzpk3D2nvtB0IXZ2VB/PsvkJAA/PkncPo0Xu/WzXSdF8I0KVYOHowJTo562D4qCkmqh8U9mjXD3G7dMHnCBOw+eBBz1q7Fkd9/r3IdsbGpuPPOHVi0qC9On648+ioArF27EW0y4pHWqBGGTZiApUvvwG233YBTp/60ujwAtAwJQciZM+gUHW2OT8zKAAAgAElEQVT63Y1GRKgyaQEgwMsLA5s3x0BPT1Od9sIFbLrmGkyxMRIlYAoU/aL8TWE+Pni1uBgNLlzAieBgZCojTe6ZORNBPj4Y3rgxEBeH5b17o9egQUhJSkKhKsvt80mTgN9+Q8uwMJxr2BDGqKgKv8nhVauQYCUQlRgTg1MbN6Lfvffi3Z0VR9kNUeqyoV5euMrPD2U+PugXEAA/Dw8sadrUdM0SAgWxscB//yFICMT4+GD3tGloamefatu0KT6yGG36/jFjMGnzZqyeNQs927XDuUOHEBMWBvj744tTp7Du7rutrqu0tBQDmjYF/PzQSHkA7KsEGFP8/fHT4MGICQ+Hl6cnOiYmomNCgqkO/M8/gMGA3MhIvHP55YCNh3zZsbH4rVs3HPrzT8z5/nt8cOoUfps8GVFZWYCvL+b07o2SLl2QN3cu+hUW4qaSEty4ZQtusTLCIQDMGjAAWfHxyEpPxxhlVMcob29E+ftDjh4NBAQAgYHA+fP4eswYXIiLQ/NjxyDKyvDq+fPo/eijNrdrenw8+iQm4vYdOzAhPR2TfXyQ6OODxPh4IDoaKCpCr+HD8d1LL6H96tW4oV8/pCYnY2RJCYyFhZVGY1X7aM0aBH7wAXzvuQf5SiCtWUgIIAQCVAHE4c2awU+pv6olxsTgkDIysC3vTpiA348cQWZiIo5FRgIZGfivQQP0HT4c3+6zf52x5CEEkn188GazZnjl33/hq5SpcXg4riooQH5aGsrOnkXTqCg0TUoCwsJQqozc2augAK8qo557eHjg2VtugV+bNvj33Dn8sHw5gpKTEak85Htw+XIUjR+Prvn5yExPx+I778SSceOQ4O9vumbU0KBBM7B1q/MBSQBI9PdHCz8/9Pbywm9du6Lta68hJz4eJampGPbmm2iuQeZ3gJ8f/j5zpvz1cgBX1Hit9YyrRth0gLsE0D4DkCaESIYpcFYCYGRVH7B2k96lc2e8aTGcrtnWradx9OjfmDHD+pPGlJQ8/PCDaWh2pY81AEB8fBJio6MRGxoK/PgjDAYDysrKEBccjEEtWmBow4ZISEpCUVoaoBoaOCokxHRzDGD24MF45eOP8brFhfiea69FYHg4+kyejNILF5ASGoq+Fum/N/Tubbrg//MPfDw9cXbWLHgpTwkWjRmDRTNn4m4rQ49Pm7YcS5aYnn74+gajU6eRaN9+OPr1M9385OYOLF+2oKA93nv7bcyZdzUyMrKQnZ2PsrIQLFo0tsI60xs2xKjiYsz090f48ePA77/D49w5AEBcQACSw8OxYdgwDMrOxqzHH0dgRAQeHDAAKCtDZnw8nt6wAcOsPLW6urAQ+XFxwNdfI9BoRKCvL3D+PAI8PJBtUSEz+2r5cnzxzTdICA7Gl7ffDvzzD7LT0jDIIsskUlX5vMLLC3f89x+SnThgP1m3Dnl5edhicbPaMjoaOGa9MgoAgxs1Ml3sPTxMN8XKkNdqT8yfj+5WbibM3r/lFrQPCAD27sWC9HQs6N7ddLGPizNV2A0GpMXFQb72GmA0YlLHjvAbNqw8TfqRNWswdv78Cus0KtH8JB8fJHl6lu+jtnwweTLOqZbxMBhwSnVBsDQlNxf45pvy1xsKC3HNZ58hOTISyf7+uL57dzRp3hxdmjQBhMDgggIMTkjA0IICRLRqhaZdu+K4RZn6xcVVWCcAFMfG4sPz57Fq4kR4enigMCUFsMgCGt62LYaPHYsfhEBqFc0U0tMzkJeXjwdWrcTuLVvw8s6dOKc6lo1GI2A04tnx4/HOd98h0+LC6qHan7wsggtCCDRWPdl8qE8fXDdlCoICA4FTp8rnN1FuQs8++ywMDRrAr00bq8N+A8D0Hj0QfOgQOvv7Y2bjxsCRI0BpKcJ9fDCrsBAT27ev9Jn1Q4cC+fkoadQIR0+cQKmqEtcyKwvvXXcdjBcuANu3I0j5e9V/w+XmzAFfX5zdvBlezZsDp05hYLt2wN69Nret2X+q7env5QUYDEgJDTU9oTx7FkkxMZC7dkEoT8atnd8tHXrwQWD79krzjQYDuim/UbCPD1YNGlQegPfy9ER2SgoOPPYYkJVlN4A2c+Zr+PHHd7Bz57Pw9PTB+fOmIe7T07NhUH73pPh44JdfsHvrVtN2i4jAa7NnA82bY/2TT5av66kZM+D9ww/AJ59UuImzxWAw4OebboLHmTOAxU1y52bNrAbQHnnkGxQWZpqfv2DKlMn49lvgr7+ADRs+wIIFffDxxxebgX788U9o0CAal112A557brnVcmzr2xf9fHyA775zqNxqvl5eFY4PNaPRE9OnX4MuXebjzTeX4ZNPduLQoX34+eeLD34eeeghdAkPN93UKWb07o0Zw4cDLVsCZ8+W/w5+fkGYN28zunSRuOuuGzFu3GS8sPUpnFAdZwDw1Ve/ILL0KLBvnynQXVZW/nfdefXVWPvII/jhyJEq/66ePYsRF2dqRm4wGJCV1QHffPMu8vIGwmg0okWL9uUBtLVr78NVV12G0tLzuOWW9di16wAeffRWAKYbELVof3/gxAl8M3o0djvQ3MXfgZuQrPR0NG/eHNi1C+O6d8fJ0lKMmb0Q8Ya/kNa6dXkArWF8PNrn5wPe3rj22qVYsWIpVl9+ORbceWf5ur5ft860vV55BdFGI8aqMoGt2bdmDXb++KPpegmgTXq61eWClWt+UkgIDs6ahT0HDqB38+ZYaiXTXgiBeZ06YXheHr47dQqeRiPGtmyJIa1aIeCaayos62U0IkCVUd8yMBCF8fFYO2OGKejToAFw+DA8DAasGDcO1/frh+9//BF/tmhhN4D26dy5EIcPV7mM2ri2bfHTiRN4/csv8fGBA3aXD/Hzw/s9e1a4wfAwGHDrsGFAUhIyU1PROi8Pjfv3x7/KwztrvLx8kJlZgFWrvrZZ//XzM9Wzhg4YgH37foCPTyMYjVFYvHgEEhOTcfLkcZxSjqPNAwdiaGAgfKr4zqpMHjAAvn//jdGq/QowZT7+3913A6dOIXvIEHx56BCuzMsz1Q2PH0dMZCS+X7oUJw4eRLxFRqGflxe65uWZflPFyv790So2FrhwASgrg9HKuSs+NBS3jh+PeQ89VOm9QF9f+FsJqoeojrk1QUGAg93JNImMhLztNnzm54eec+bgz7NnKy3zys03o2jKFMQGBmJtu3Z46cABTGzXDqMGDoR3YqJpX/jnn/Lg7B1r1mDDpk1W6wrq+xghBD7IzESc6rreICCgUjDHUY2V7R/l7Y2owEC81LQpPgEQZZG1ExMaikObNgEREcDJk1gzcaLNAFqEqp70WuvWiKoiI6xpRAQQHw8ozYN7padjWm4u7v38c6vLPzp3LlqePIlhZWVo07y56VpmcV0KDwlBu9RUyPvuMz3sVpoCv7R2LRbcdRe+tlLP+fiOOxAZHAwYjTheXAzfsrIK94FtEhKwqm9fTGjbFn6A6XoD4Kd589Dw1lsxODcXm9asQbiVzMzn5s/H3HvvxaOrVyP+118RX1oKGI1ICAsDoqKApCR888EH+P3gQSxZtQqHfvsN3XNzsWbLFhw5etTmtlPrHBqKzikppocTijWdO5v26TNnTNtBYfTwgHznHcBggCgqAoDya2/bJk3w5hdfIDY4GL6q362wVSvITz8FDAYkNGiA7Zs2mSomyvX88NNPY/vRo5gw23bCBgDMmfME1q413c/Onfss1q4dhrKyMiQnX3yo+tyzz+L8gQPwiI/HG6++invs1O0CVMdCtI8PfkhMBDp2BDw8IKdPx14rQdM2SUn42Mq9nC3B/v4VAmjV7yCp/rpQVjebNANu0oRTSlkKYBaA1wF8C+ApKeWeKj9k5WK4ZNEiPPzwY9h8//0YMsTU909J//5Yv2IFfH0DEBISU+kzAJCfPwXLl38Ib+9ABAZW7FspPb1JhddlSuZLdGAgPD08kGClaZ811tq9R4eHo3thIf577jncMn48XnSgnwxvo7HSzaW6Ep6Z2Rovv/wrDIaL82691XTzpZ7n5VWxYlBYWIiXXtqBAOXv6ddvTOW/wWDAdVddhXBVUKtDbCzWdOiA9UozscsKCxETFIRnRo3Cg5ddVr6cEAJDe/fGrePGVVrvyGr0i9QsMRHjLFKY/a00PY1SVbRu8/bG6bg4eDpxE5ifkQEhRPmFQkvdcnJw9rnnrL43pEsXtLfIuLHHYDDg7M6deOL++5EUFYXQaqakq/l6elaoMAJA24yMSsu9s3w55L59iLQ4Hi5r0gQnFi2CEAJCCCzt2RPDLJo+AEDT5GTEREXhvEVFsFtqqtVyBRiNeKBTpwoBUltSquiT4ttvD+CTT3Zj06aH4eXlhZYpKTj78ss4vHYtjijZCGZ+Xl7obeVvV+8b3naaLAR4eaG5lb5Syj/v6QlPT0+kKs0QrbHVLEIIgTuHDEFOou0m6NHBwchu2LBCUMNgMMDfx6dC6n1VvD09HQpwqf1nIxho6eaRI9G70HbzMr3ceqv1jMrg4Bjk5RVj1aoTiI29ePPv5eX801PPatys2Ao+dW/RAg0t+qSbPXshkpIyrS5v1rJlx/L/R0YmIiYmDh4eHhg+fBluueVhLF++Dl27dq3wmaIadhdga0/x9DSdrz08jLj66mW4/faX8eqr+/DUU18iWsl0zMrMRJzyf5vrFwaL1wIHD/6DtWvvwcEPPsD27e86XNZZJSX45O670a1LlyqXGzHi8gqvS0pMzVtiY9MAADNmrES3bpPxxRc/YdSoiXj//b+wYcMuTJ48A5mZF5vOqK/JamkhIRhk0XTcGj8n+57z8/HB1WPHwkc5pwcFBWGe0qwzUHXunjdvIW694gpMdCAj1p5WyclOnS8ahoSgtwNN2xPDwtBNdY20dqwsGDCgwuudBQVYW0U/P15GI5rExyPQxoM7swsvvIA8J/vhFELg+kGD8NGCBZCbNyPAznfsWLDA7joTY2Lw009n8M6bb6JrV+vNDs3Xp5CQGEyf/obVZfxUgY9GjRpVeK958/wKr0c3bw4fJ5qsW2PtXHji5Mny/+9avhylGzfiWou6QmpUFHIdbG6bXcV1UG1uFc017QXQqiMvIwPHr7wScVYyXIIDAvDl/Pl4beJEZISH4yqljlvVtfmdl15Cv27d7H5vu8BAJNewr8riwkL8s349vrQ4roKNRnS3kbXqqEhVfbVHVBRyrPRlV5U7evfGx0OH4uGxYyu9lxwdDQ+DAW3sBPyt6dmuHV63kTkaqNo/wry94WtxXAghsKBz50r11AYhIfhn+3Y8NWuWzXuLgfn5+HHiRLSroisUAIiKiMC9S5bglbvvxpySEvR2osuOmjLf1z67bBk+3rgRvk422Y2PjESGjTq+Wrt2xRg58nqkp3dHXt4gREebzlGhoaZjKDo6DoMGDcLwnj0xZOBA3H3TTWhm42GNWYKd86+1vqBfnj4d+U709e1sE+ZLjZSm53GOTK7gFgE0AJBSviKlTJdSpkgpV9hb3lp1zNPTEyNGjMToESOwdOlGnDz5Nx6/807MsBK0URs0aAOMRk+sXHkcEyb8ANNgGUBJyb3IybHe8XeMnb6gKpXX2tMv5QIqhMC8gQORWs2BEdQnYE9Pb4SHR1eomBuNXpXK4OnpXHMVoOITrfLvFgJX5eU5XKmY268fbteofypLF6wcZeoLl0EIBDgYCPtk8WJ8pHoCrQ6Avr3ceqZGdVirSBqNRmy5+eZqr7NkyBD8uGFDpWworbRMScF7N9xQYZ6fRheKUtVTn2WjR+MVO8duTQUFBVXKAgGA+LAwxKr6taiK+sYt1cFKuz1vvv46llhkU5g509+WLR4WWQ11xcKBA/FyNfoIqamZM20/ARVCwNc3GBcuXHyy7O3t2PlOfc7VMggvhMBki351wsIi7H6uTHWOtNzvBw8ei0mTLjdlXKpY3hRoJSys8g2XEALp6c0Rr9wk/+dAFpZ5G6uvT35+fvDw8EBwUBAKC4vwpdJ00RHhwcH4PytZ3QCwefMJ3HnnHuTkVHyWnJVVhMWLX0JJianpaHh4NGbO3ISEhAbK/uOPRo1MD4qMxovnZWvnHmd4OvDbWGtyq2b+vdUBHR8fH8wdNcruA4G6xNp5bFavXtVaV3azZlhRRf9yWhzL6v21WUYGDqxbB7lrF1b16oVVffqgcYz1B77WdOjQAT16DLK7XKNGlbOTAcDHx3Z90Fq9r6as7bd/WWSee9joz8xRznTWXpCejkIrDyytZXgGa9D0DKhcX23bpImNJavWrnVrPOREVxU1cdXAgfDz9i7vv7Q6xg0fbnV+RA0f+HobjWgdE1PpAeLYHj1qvG5bdekAJ5v9q/n5+MDDogsQs1nFxdXe95deey0GtGuHrZs2lT8o0Yv5PBgcEIDWTj7wN4uu4gHZ5Zffi1mzXoQQAqNHL8XUqa9X2C6pqS3wwAOv4P3391f67FfPP4/58633xfnFyJF29+HYgAAs6t4dAHDd0KF4ecgQhPr5YcfUqdjWs6cjfxqaVfEgnEwYQHMBaycXy4qiv7+/QychDw+j8q8nDAZjeYUhIqLyzt9OeSIU4OSTHGsnSXtP1h2lrjiOGbPUNM/OycEyA82aLVsqPq3UqiKVb+eJSnUFW+n00V6n97bkN2qENqrOic2/X8vUVHR0ovN7e6xVxDu1bl3jGyug4j7gq/GF1PJmxZGmRI4w9zXRo317LB4xAkYNtgMA/Pax9T6egqq5f6ipj+3HahD4VIuLi8M81SAEZtP79avRTYWZZQaall60CK5O69ULt+kwMrEWXt26FQsWVN0Zs1lQ0MWMAUcz0LT4rWwxHytDe/dGcXEJxo2zP6iIlBdrIrayn9QemjcPXjU8BnvbON937Gg743qZ0vQ81YGn047sv02rWbm35O8fjMRE65lhubl9yh9WVcXT8+Iy/v7adSvctm0HK/N6YbqdQXfGDhsGLy8vFFvJNtPq/FsbLEc7fGfJEkRXI+PEbJEDAx/VhLo+devixUhWHqgu6NABC6rR2b4j5xqDoXIgICEh0+p10BzoVT8seMLJwSFssRbsTLXIfKspZwJoO265Be+p+sczs5aBFqzRiMPqfrW2bXsf7yr9w1aHTy2NgqxFXeGhtWtxv5WH0JE1OFbVLPet2y+/3MaSjrP1IKEmATQza9s0xYksJ0vx8fF4fsUKDOzRA52tDPaiJS32h+SGDfHdd9a7AUlLy0Xz5n0rzS8sNDXnDA4OR8eOveBr43e49tob8OOPf2P58osB5pOvvoocB/s3W9G3L/6dPx83DB+O3kowzJk63SOqAS/qbkNF12EGmotYO3AdeRq7ffte3HXXe+Wve/a03fGktRuMVzdvxg/PP+/0jZG18mr1dNe87gYNmqBFi47KvKorvubmM1Vp3LjiEzGtAmjqwE6BRjc2ANCmcWM8aNHnV7QGARJA+yBDbVBXJHa89JJu6wasN5+tDnMG2nWXXaZp8CHSSnOAadOm283OcIR6W2jRbNbMWtm0Sgn30CkzCgD6FhQgXbkZWjh6NO65/HIkaPSwwCxdo9FLe3brhpstgp4zZz5tddnZs7cgLs70d1WnCafWzBkMzTIy8NhjTyDQgebM6nO4rWuEeZnHNmzAOAeaBtmzZvhw7H224iAMDz/8GqZMsZ1o3qdbN+zfLxHpwH5jbsJZ1fnCvI+PG2e7z8naog6gjRpVdd8vzli+vOKoZjNmXIG1a1+xm4WQlZ6OM2fOoZGVY8qdAmiW57EOmVU3Z66urhajzlWX1pldjpzHrS1TUGA9c62oaACmTFmARYtuKy9rwxo20ysvh8Wx+uajj+LxKkZZ1uI7qkMdQMtt0gTJsbGaHRPqDDQvL68arde7tgJoGtXJrJ2rwxy4fjnCaLGPh2lwD2AzA02DB8eWdenXV67EbI1GnLa2X8RqdE8E2D7nHLntNuypYqAQS+k2mlv6+Vkva0nJUrzyygkEBlbdastgMMDf3x9JSaYHcZmZmQiy03TTUk2aq6u7ArDdccCljQE0FwgMCMC0aRUzBxy5GU5OTkfjxq3KX2dmjrK5rGXfKubvbVSNpwPqC4+PtzdWrVpdxdLOMQekDIaLB7q9AJpjTysr/v1aVfjU2+ItB0a6coZlGnwjDUZSAS6WWc+MEjOtvkP9+zV3oD8dp9ZtUUZn++KxxfxUVuvmp9a2qZdWwSidgqvWyudoP2X2qCvrepT/zmXLkJOZieU6ZZ5pfd5Qy8sbittu24vBg3+qMD84OBo9e5pGl3K4CafmpbvI3BzTmQBop04Xs75sXSPM69Uqq8Ho4VGpaXOHDj00ybIFHD9fHjokMWHCDfYX1Jk5gJaamg4vL+1ufC1/T0eav9qj1W9Un2zX6GGUKwJo1mRnW+8zyWg0Yv78VQgNvdiVgVbXCsv6Q+e2bRGqUQaSre+oDnUAbeXs2Tjw1FM1XqeZujl9Tet8lsdpeGgopo2yfW9TXVoF0Kztq8FOBjZs0aM+Y3lv+f7mzZjWq5cm9VTLbdE9N1ezh5qWSRoPXncdflq2TJN1A7bPObEhIciqYd+pgO0AmsFgQECA4w+rzeXU6t6qrRPN681e1eSb6x8G0Fxk3LiKqbmOZpNYC4xVZKrYONLExVHqk/qAwkLMt8iUqgnzyUFdXi0qvpbbSavq3sWAnwF+GqRAq1meHlO0CqC5Ywaajjc/ejXhNNOr/zaztm3aYN68eZqsS6tKpSVrv59mGWg6NuEEgO5FRfji2WcdygquDr22uVlcXDoCAip3Ev7ff6ZRh51twvnoQseaiTrDHGx25vdr0CAdzz33D/z9QzBlyiqry5hv7C37QqsJPc+fej3U+H3fPgzToUNmczPPC1ZG+aoJy/OFFgEa9bY9+P77NV4fXaT+fVpo8IDL8jjo1WsxWreeWOVnrrvuZTRpUuTwd2h1HNdGv5taXCN6qZrAaZGtrmatz96ayFU1lT+2Zw/ucSIDyFFanWstf/+U+HjER9jvw9MRlhloWrD8u9u3aoV7Lr9ck+2h3k/T0qru+N5ZlgE0D4OhWoMZ2aL3fZGtAJqztA6ghfv44JCDWYIfjRmDz4YNg2M9Kl9apDQN9OrI5Ar63L3UEea+y8wcvcDZCyyYKzZCaHeimdGnD5798EPN1qdmvhipt4fltjFLS8tDkyaO9a+hdwaaHgEedZkbREYirpoDM1Raby1moGlFz0qq5b7h7Og79ugdQPvw3XchjZ7QIElDt+1sbV/rmZ9vZUnnqcs8YZD9zqfrGj0qbvPnPwYvr6o7fR00aDp27HgBffo4NriF+TcMcXC0ZmeUKedjZ/c/Hx8/PPnkX7D17EJWc731TWRERIWRToODtakCmzPQtAqgvXTDDQjKza1wPR0/fiquvXYZjh3T5CsAAA3j44GjR7Vb4SXOfPzu2bYNURERwL59NVqf5QPPfv2WW73x8PHxw9mzZwA4/5BYq3NCbdSjtLhG5DVpgpy0NPzv++81fxikPv612B6fbdsGUcUI31rQ6rqr/nuNHh7Y/8QT0KQyBv2uW/3at8eLH3yg+XrV23TPnr3AO9s1W7dlE06ts171Oo6Li+/An3/udairIUdoHUADKve5mZXVDN9883Wl5drExwN//63Z99Yn5j7Q6qp6XQO2fELuaJMsRysNWmagdc7OxuNr1gDQ/qRjPjmoTzbqkb7U1qz5FGPHWs88sGQZ4BrQsWP1CmhjvXr0r6J+mvPT/fdr1+TADW8mazMDTet9Wu8Ampb0zoYyK/v2W7TWqCmu+vcbazEkvTvQo5LcqdNIpKQUVLlMbGwS3nrrW0RGxlW5nJl5z9BjH6lOBpojzE2L2HzvYr+qkZGx2LTpE23WqXEArU9BAQrbtKnwe61de69D/ce52o2jRmHX3Xe7uhguUR6o1ug4c/Q8sHjxg6rPOPbdWgfVa+OaqdV3mDPF9AyguQs9mnCWaRzUUWdYPbFunWbr3bZau2531PS8t7CsR2u9rfWSnl6ECRPWa3ZfYV6Pltu68prcY9vWNWzC6SKWQSJHKyL2D0rtm3DqyXxSUKe72spAq856AeDorl1YbWVUwJqsV+8MNE3X64Z9oHmU7xeVRyetKXUJS/r313z9egTQVi9apPk6AX0zdeTnn5f/X9OnZ24YEFZzt4C2HuXVK9ClRxNOd2W+aR4yZAoSErQZkt4cQCsr0/YG2l3qK2rjOnVCixRttqtagA4Zn1rTPChVjfU4e03Rqqx6Xn+0fmhhHthI6wCaOpjRoEGypuvWix4BNK1G3zQLUnUnokfdVGt63lNYNuEsq8vpPhXok2SiZx3aMrsvXMPBGuorjsLpQpYVfEfTU+0dRHo04dTTv2fPAgD8/C52qqh1AC0mKkqzGyrziUePGzS9nmzWVpaRlsy/X1SU8x1e2mOu/DXNyMATd92l+fr1CKDNnz5d83UC7hfMAdw/gOYu5S9/8qlHBpo5gKbxtmATzovM1ygts0W0zkC7uF73ydo102sf++3gQV3WqyWtA9WO3hxWXM65z2h1rauNa6ZmGWg6BdDM6/3ii70IC3OPHpI0+/1Vv82HGzZosk4zrbsTcWeWTThDNBrpVA9r1z5T/n+tg4qOjNTtLMsmnJbxhw9vvVWz76rPGEBzEcsMtBCtR/HR6cZE65PDydOnAWifgWZ/sIXqKc9A06ESpVsGmvkJhi5rN3n1wQftL+SE0//8AwCIitJm6Hk1cwBNr+1t+eSsLnPH4KoeHe3WJncJWurRdMBMryacUudj252Yr1FaZovpNYhAbGzNRz2rbXoF0PTIutaa1oHq6gXQHOOOTTi1qmfr1YTTvE3dKfCtdQbaoB49kKLBaI1knbkePf/KK/HwihUYpFE3PHro3n0IUlNNXZRofe+pRwaa5bFgGUBj/ck+DiLgQuond7K0FCgrw3kN1+8uGWinygNo2mag6dUHTnkfaDpmoGnez5zOFb7EmBjNO35vxWMAABqQSURBVPgMVwLK/fsP1nS9wMVUcL22i559oGm93+ndrHfvhx/C+6efNF2nu2cXuVvlRI/jpEzjPpTM9HrQ444uZqBpV4PTKwPNYDDgjTd24vRp9+lbyd3PQzWhdR9o6pvOVq0m2VwuNjap/P/OnkfdKYCmdR9oejVpd6cAmlbXBEP5gwl3aVLontKV5vFpKSkY26ED8O+/Li5R1fSqe9TGIAJUPXX5FFCvayfmg2HkYK0DBPr0gVZ+ctB0rcC/584B0LcJp5bKR+HUcbhprbexHidgsxNPPonvtm0rf63Vd2SlpeHArl24/PJ5mqxPTe8MNL0CaHv3/o0dO07osm69pKekoGGMts1w3f3G1V3KX94fj54ZaBqfk/SqxK52cNj3usS8n7lDE04AaN68JVq0yNN8vVq6Y9LF4I7Wx3HTBg00Xd9ii2b/PXtqP+CKVoMpmc8xnTr1xcCB99lcLjMzFwEBpodrTveBplFZG0REaLIea7RuNq9XU3kzdwqgaZaBpqxH64fGVFHxgAH4v/97C5MnTHB1URySmGjqC9DLS9sMYldkoPEBpH11vQ+0ep2BBgAn/vgD/koASWvu0invlZMmYc/hM+jT5/LyeXU5gGY+seiZgaZ12fV8Yhrs7w/4+uqy7uSkJJzWoex6N/PSK/vRz88fpvtWLXNV3Y+7BKBscZcMNL0C+oB+GWjl2aUab+P5/fqh3Zgx+Kus7jevM9MjA818bdZ6EAF3MbtPHyx/9lkcO3GiPDihlQ9vvhmHNQwgLp89G0+8/jp++PFHfP/00wjuMBSAtlkcWh2/bdp0Qn5+PubPvwk7d1a9bMOGTbFnzwdw9sykVT0oMSICx9avR8TMmUhP1qcDfa37QNOrTmLZFU1dZjAYTHe9NdQgNhYA0KpZsxqvy5rIgAD88fffmq93ztSpCFZlcNZ1Qgh07NgJorRuZ56Z3XbbY1i//i1ERGh7TtCjKw17faAxfOaYupyBVu8DaMHBwcCff2q6TncbRCA0OBhLl27CgQMX52kRnNIrgl7+RE/HUTjdKQPNHZmfII8ZMsTFJaHqcPsAmpsch3qeLyYMGoT7nn4aXdu313S9ejbhbJufj5PGcJxwkyRQc3aQlgE0Ly9Tx84dOnTVbJ3u5q177sFDH36IMI07tQ7y80NKSipQpt0No97XfK3OxQEBgdix4xMcOAC7ATRnj3E9BhYJDwzEziefREMdRmEFmIGmB4MQmgTQcrKy8OXatWjSrx9w5IgGJavo5yVLIHv10ny9ty9bhtN+0cDhbzVfNwFBQSFo0UL7LmfKH2Tq2IQzIaEBvv9+b6XvpKoxgFbv6NOEs2N+PgBg5tChmq7XGm0GETCdAHx9tc0YKFV6BNRlEAGd+kCrDe6Uzh4dEoLdu88hK/QYoENTJNKXuwfQ9MoG0Jr5PKTHkd22ZUvs3y+R7HUIWh6B7toHmh7nT72acD7//D7k5SXg+HHNVqubXZs2Ya/GGdLNUlNxa9++wBtvaLpePQidm5tp1YTTOdU7xrU+77bMygJ0GvBBq2wTvQNoevWtpgctH1w1T0oCdNr3fTw9AR8fXdZN7kePOo36WFi58kmUlHRFo0b6NU2vj8xNOOsq9zkz10FaB9Dio6Mh//4b2L1blxsqNS0CaABw440bkZtbpMm6zPTslNVcadIrQ6U2bird5bbVy8tL8+0RFhyMP0+e1HSdVJm7NIG0xV2CO+5Ryor0asLpjvRowgkADRqk6dVqX3MtUlLQom1bXTJF3IGeQXDA1Q8DnAygudE5QatsqdfXrMG9n+9EVHg4oEPdxNPTE+fdpEcJd7nuEqmZ6zR6BNAWL74V3bsXIyys4vs8Vuwzj8JZVzGAVgNaD6Vbm7QKoJWUTFEixEc1WR8ANE5OxoRRozBXh44t9cpAc6fsMHe2Z9s2HNXpiTSRq7jT+UOvwW70pkeFVY8MNHJPeh3DrghKVfdvcZem84CGzQ3T0rB+wmSIb3drUKrKPDw83CaA5k6/P5GZXn02y8WL8dPkuTh2rPJ7PFIcU5cz0Nw3AuRCFw8292gmZE1d7pjUw8MDD6xfj6YZGZqvW4+27hXWr8taySwmMhI5OTmuLgaRJtzxKaS7NuHUg14ZaOQ+nti0CQMGDEFKfLwu63dFEz4pncsylToNWKIndwn2uNN5llnJ5I5cUadxp+PaleryKJw829UAM9Dcl9anrtrIIHGnLBUicpw7HdsMoF2kxyAC5F5atmiBRx99RrdAlyuCEhfPR/W8CSdpittUPzk5rVxdhHpLrww0qhlzH2gMoNUr7n8DcakG0PQ+Ueq5T2Qoo1EN7tlTt+8gotqjdwfkemAA7SI24SS9jOjb12XfXVKyCACQkOBcKwB3OifU9ZvlL7dtw6b16zVd53ff/YBPPz2s6TrV6vo2dVd/fvUV/u//PnB1MeotPfpAs8edzpWuxABaPVPdp3N1yaUaQAv088O0aZfhzUWLNF1vbdz+pjRsiFOn/sGk4cNr4duI3E90UJCri+AU8xXEfcJnwIgRIwEAiXFxLi6J67EJJ+nlkdWrcWK3Pv1q2dOmzQB89JFEQECIS76/NtT1bKnmGRmYrHE/wI0aNUJMjD5NjYG6v03dVWhICHw4aqhu2ISzbmIGWj3mzgeAO/VVoSUhBO68cwPylGwuPdavJz8/P7fe74j09L+lS/HBE0+4uhgOc8cMtLlz52LPnn8RFRnp6qK4XNvsbADAiBGzXFwSqm+MRiOC3eSBwIMbNiA1NQ1+3t6uLorDWIvSHuum5J6YVV9XlZY6NrmCbgE0IcRSIcQvQohdytRb9d41Qoj9Qoi9Qogeqvk9lXn7hRBXq+YnCyE+UeZvEUJ46VVuR4wc+TZSU6+Ar6/7Pp3jiUJb7nQDTFRfxYaEoF0r9+krxB0DaEIIeHvzaThgGtTkrbckWrfu4uqiELnM8MGDsXv3Prdqwsc6sPaYgUbuyCUZaLX2Te7rUs9Au11Kma1MrwCAECILQAmAJgB6AtgghPAQQngAWA+gF4AsACOUZQFglbKuVAB/AZikc7mrFB2djezstbwAUyXcI6i+uKVPH7zx4ouuLka9xvMFERHVB+4UQCUyYxPOuutSDqBZMwDAk1LKc1LKHwHsB5CvTPullAeklP8BeBLAAGHayzoDeEb5/MMABrqg3EQ2uVMGCdW+t1aswJ533nF1MZwyr0MHdOnUydXFuCTw/EFERO6MGWjkjqKjTf25tmvbtta+kwE0+y71DLRZQoivhBAPCCFClXnxAA6pljmszLM1PxzACSllqcX8SoQQU4UQnwshPv/j+HEt/w4iomrr1Lw5stLTXV0MqmPKm3C6uBxEREQ1wQAauaPGjbPwzYsv4vrrr3d1UchCvQ2gCSHeEELstjINAHA3gBQA2QCOArhVg/JWSUq5UUqZK6XMjQwP1/vriMpFBgcDAFqmpbm4JETkLkratwcAZCQmurgkRERE1cesGnJXmSkptTq4Ho8U+6Ss24MIGGvyYSllV0eWE0JsAvCS8vIXAOq7hQRlHmzMPw4gRAhhVLLQ1MsT1QlZDRtix8cfo+VffwH//efq4hCRG5jYpQvGLFsGz507gSNHXF0cIqJLApvNa48ZaESOYbDZMa7KLnOEnqNwxqpeDgKwW/n/NgAlQghvIUQygDQAnwL4DECaMuKmF0wDDWyTpqvc2wCGKp8fB+AFvcp9KenS5VYUF7/h6mLUGwUFBfA01igmTUSXGE9PT1cXgYiIqEY4iACRYxhAs6+2+kATQgwTQuwRQpQJIXId/Zyed/urhRDZMHXvchDANACQUu4RQjwF4BsApQBmSikvAIAQYhaA1wF4AHhASrlHWddCAE8KIW4E8D8A9+tY7ktGfv5cXLjg6lIQEREREelr26JFuGPHDiSGhgK//urq4tQrDAoQkZZqKQNtN4DBAO515kO6BdCklGOqeG8FgBVW5r8C4BUr8w/ANEpnrfnu/vuxfldRbX4lERERERHpILtRIzw4fDiwbZuri0JElygGmx1TGwE0KeW3gPO/CfNtbWicmIjw8FRXF4OIiIiIiKjOGda6tauLQHXIpOHD0bt3P1cXo05j+My+2mrCWV3ssImIiIiIiIic8tjs2bjnySeBr75ydVGoDrjv5pvxb0wycOo3VxelzmIGmn3mUTgdFCGE+Fz1eqOUcqP5hRDiDQAxVj53rZSyWv3qM4BGRERE9VJGRgsAQNOm7V1cEiKi+sfTaERYWJiri0FE9YwT2WXHpJQ2BwCQUnbVpEAqDKARERFRvZSb2x733nsEycmxOHjQ1aUhIiKiSxkz0BzjquaZjmAfaERERFRvhYbGuroIRERERAygOaC2+kATQgwSQhwG0AbAy0KI1x35HDPQiIiIiIiIiIh0xPCZY2ppFM6tALY6+zkG0IiIiIiIiIiIyKWcHESg1jGARkRERERERESkIzbhtM/chLOuYh9oREREREREREQae/PNn8v/zwCaY2qjD7TqYgYaEREREREREZHGYmMTy//P8Jlj6nIGGgNoRERERERERETkUnW9CScDaEREREREREREOmITTscwgEZEREREREREdIliAM0+jsJJRERERERERHQJYwDNMcxAIyIiIiIiIiIisoF9oBERERERERERXcKYf+YYBtCIiIiIiIiIiC5RbMJpHzPQiIiIiIiIiIguYQygOYYBNCIiIiIiIiIiIhs4CicRERERERER0SWM+WeOYQYaEREREREREdElik047avrfaAZavJhIcQwIcQeIUSZECLX4r1rhBD7hRB7hRA9VPN7KvP2CyGuVs1PFkJ8oszfIoTwUuZ7K6/3K+8n1aTMRERERERERERU95SVOTa5Qo0CaAB2AxgM4D31TCFEFoASAE0A9ASwQQjhIYTwALAeQC8AWQBGKMsCwCoAt0spUwH8BWCSMn8SgL+U+bcryxERERERERERuQVmoDmm3gbQpJTfSin3WnlrAIAnpZTnpJQ/AtgPIF+Z9kspD0gp/wPwJIABwrQndQbwjPL5hwEMVK3rYeX/zwDoIrjnEREREREREZGbYBjDPvMgAo5MrlDTDDRb4gEcUr0+rMyzNT8cwAkpZanF/ArrUt4/qSxfiRBiqhDicyHE538cP67Rn0JEREREREREVH0Mn9ln7gOtrmag2R1EQAjxBoAYK29dK6V8QfsiVZ+UciOAjQCQm50tXVwcIiIiIiIiIiJyUF0eRMBuAE1K2bUa6/0FQKLqdYIyDzbmHwcQIoQwKllm6uXN6zoshDACCFaWJyIiIiIiIiKq89iE0zF1OYCmVxPObQBKlBE0kwGkAfgUwGcA0pQRN71gGmhgm5RSAngbwFDl8+MAvKBa1zjl/0MBvKUsT0RERERERERU5zGAZl9db8JZowCaEGKQEOIwgDYAXhZCvA4AUso9AJ4C8A2A1wDMlFJeULLLZgF4HcC3AJ5SlgWAhQDmCiH2w9TH2f3K/PsBhCvz5wK4uiZlJiIiIiIiIiKqTQygOaYuB9DsNuGsipRyK4CtNt5bAWCFlfmvAHjFyvwDMI3SaTn/LIBhNSknERERERERERHVXeZROOuqGgXQiIiIiIiIiIiItFCX+0BjAI2IiIiIiIiIiFzK3AdaXcUAGhERERERERERuRwDaERERERERERERDYwA42IiIiIiIiIiMgOBtCIiIiIiIiIiIhs4CicREREREREREREdjADjYiIiIiIiIiIyAb2gUZERERERERERGQHA2hERERERERERERVYACNiIiIiIiIiIjIBg4iQEREREREREREVAX2gUZERERERERERGQHA2hEREREREREREQ2MAONiIiIiIiIiIjIjrocQDO4ugBERERERERERERlZY5NNSGEWCOE+E4I8ZUQYqsQIsSRzzGARkRERERERERELmUehdORqYa2A2gqpWwOYB+Aaxz5EANoRERERERERETkUuY+0PTOQJNS/p+U0hyG2wEgwZHPsQ80IiIiIiIiIiJyOSeCYxFCiM9VrzdKKTdW4ysnAtjiyIIMoBERERERERERkcs5EUA7JqXMtfWmEOINADFW3rpWSvmCssy1AEoBPObIFzKARkRERERERERELmVuwqnNumTXqt4XQowH0BdAFymldGSdNeoDTQgxTAixRwhRJoTIVc1PEkL8K4TYpUz3qN5rJYT4WgixXwixTgghlPlhQojtQojvlX9DlflCWW6/MkJCy5qUmYiIiIiIiIiI6p5aGoWzJ4AFAPpLKc84+rmaDiKwG8BgAO9Zee8HKWW2Mk1Xzb8bwBQAacrUU5l/NYA3pZRpAN5UXgNAL9WyU5XPExERERERERFRPVGLo3DeBSAQwHbLpK+q1KgJp5TyWwBQksjsEkLEAgiSUu5QXj8CYCCAVwEMANBRWfRhAO8AWKjMf0RJqdshhAgRQsRKKY/WpOxERERERERERFR3aNWEsypSytTqfK6mGWhVSRZC/E8I8a4QolCZFw/gsGqZw8o8AIhWBcV+BRCt+swhG5+pQAgxVQjxuRDi8z+OH9fkjyAiIiIiIiIiIn2Z+0DTuwlnddnNQHNk5AIrjgJoIKU8LoRoBeB5IUQTRwslpZRCCIc6cbP43EYAGwEgNzvb6c8TEREREREREZFruCo45gi7ATR7IxfY+Mw5AOeU/+8UQvwAIB3ALwASVIsmKPMA4Ddz00ylqefvyvxfACTa+AwREREREREREbk5LUfh1IMuTTiFEJFCCA/l/41gGgDggNJE85QQorUy+uZYAOYstm0Axin/H2cxf6wyGmdrACfZ/xkRERERERERUf1SS4MIVEuNBhEQQgwCcCeASAAvCyF2SSl7ACgCsEwIcR5AGYDpUso/lY/NAPAQAF+YBg94VZl/M4CnhBCTAPwEYLgy/xUAvQHsB3AGwISalJmIiIiIiIiIiOqWup6BVtNROLcC2Gpl/rMAnrXxmc8BNLUy/ziALlbmSwAza1JOIiIiIiIiIiKq2+ptAI2IiIiIiIiIiKim6nUGGhERERERERERkRYYQCMiIiIiIiIiIqoCA2hEREREREREREQ2SOm6ETYdwQAaERERERERERG5FPtAIyIiIiIiIiIisoMBNCIiIiIiIiIioiowgEZERERERERERGQDm3ASERERERERERHZUZcDaAZXF4CIiIiIiIiIqD4KD2/k6iK4DfMonI5MrsAAGhERERERERGRDhYs+BIZGb+6uhhuo6zMsckV2ISTiIiIiIiIiEgH3t4BMBoDXF0Mt8A+0IiIiIiIiIiIiOxgAI2IiIiIiIiIiMgGZqARERERERERERHZ4aoBAhwhpJSuLoMuhBCnAex1dTmIXCQCwDFXF4LIRbj/06WM+z9d6ngM0KWM+797aiiljHR1IeoCIcRrMO3HjjgmpeypZ3ks1ecA2udSylxXl4PIFbj/06WM+z9dyrj/06WOxwBdyrj/E+nL4OoCEBERERERERER1WUMoBEREREREREREVWhPgfQNrq6AEQuxP2fLmXc/+lSxv2fLnU8BuhSxv2fSEf1tg80IiIiIiIiIiIiLdTnDDQiIiIiIiIiIqIaYwCNiIiIiIiIiIioCvUygCaE6CmE2CuE2C+EuNrV5SHSgxDioBDiayHELiHE58q8MCHEdiHE98q/ocp8IYRYpxwTXwkhWrq29ETOEUI8IIT4XQixWzXP6f1dCDFOWf57IcQ4V/wtRM6ysf8vFUL8olwDdgkheqveu0bZ//cKIXqo5rN+RG5HCJEohHhbCPGNEGKPEOIKZT6vAVTvVbH/8xpA5AL1rg80IYQHgH0AugE4DOAzACOklN+4tGBEGhNCHASQK6U8ppq3GsCfUsqblQtjqJRyoXJRvRxAbwAFAO6QUha4otxE1SGEKALwN4BH/r+9uweRqwrDOP5/MWoRBRVhiVEwSCzEIn4QBC1SrVqtNhILvxC0SAprG0UbC7W1EAMRNCGgwRSixspKjQmCxjSLH5iwJsWKHwhK4mNxz8qy7AwZ3d1h7vx/zdw5Myxn4bnznnmZc2+SW9vYSHmvqmuAL4A7gQDHgTuS/DyGf0m6aAPy/zzwe5KXV7z3FuAAsBO4DvgYuLm97PpIE6eqtgBbkpyoqivpPrsfAB7HGqCeG5L/h7AGSBuuj79A2wnMJ/k2yV/AQWBuzHOSNsocsL8d76crsEvjb6bzKXBVK8jSREjyCbC4YnjUvN8LHE2y2L4wHQXuW//ZS//PgPwPMgccTPJnku+Aebq1kesjTaQkC0lOtOPfgFPAVqwBmgJD8j+INUBaR31soG0Fflz2/DTDP2SkSRXgo6o6XlVPtbGZJAvt+Cdgph17XqiPRs2754H6Zm/borZvafsa5l89VlU3ArcBn2EN0JRZkX+wBkgbro8NNGla3JPkduB+YE/b4vOvdPuz+7VHWxrAvGsKvQbcBOwAFoBXxjsdaX1V1RXAO8AzSX5d/po1QH23Sv6tAdIY9LGBdga4Ydnz69uY1CtJzrTHc8Bhup9mn13amtkez7W3e16oj0bNu+eBeiPJ2SQXkvwNvE5XA8D8q4eq6lK65sFbSd5tw9YATYXV8m8NkMajjw20Y8D2qtpWVZcBu4EjY56TtKaqanO7kChVtRmYBb6my/rSXaUeA95rx0eAR9udqe4Cflm27UGaVKPm/UNgtqqublsdZtuYNHFWXMfyQboaAF3+d1fV5VW1DdgOfI7rI02oqirgDeBUkleXvWQNUO8Nyr81QBqPTeOewFpLcr6q9tIVxEuAfUlOjnla0lqbAQ53NZVNwNtJPqiqY8ChqnoS+IHuDj0A79PdjWoe+AN4YuOnLP13VXUA2AVcW1WngeeAlxgh70kWq+pFukUkwAtJLvbC7NLYDMj/rqraQbdt7XvgaYAkJ6vqEPANcB7Yk+RC+zuujzSJ7gYeAb6qqi/b2LNYAzQdBuX/YWuAtPGqu2SAJEmSJEmSpNX0cQunJEmSJEmStGZsoEmSJEmSJElD2ECTJEmSJEmShrCBJkmSJEmSJA1hA02SJEmSJEkawgaaJEmSJEmSNIQNNEmSJEmSJGmIfwC89TMYP3T25QAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################################\n", - "#################################################\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "#################################################\n", - "#################################################\n" - ] - } - ], - "source": [ - "\n", - "layer_name_murmur = \"conv1d_311\"\n", - "\n", - "layer_name_clinical = \"conv1d_253\"\n", - "num_data = 5\n", - " \n", - "for example in val_data[:num_data]:\n", - " exp_clinical = grad_cam(layer_name_clinical, np.expand_dims(example,0), clinical_model)\n", - " exp_murmur = grad_cam(layer_name_murmur, np.expand_dims(example,0), murmur_model)\n", - " idx = 0\n", - " for i,j in enumerate(reversed(example)):\n", - " if not j == 0:\n", - " idx = i\n", - " break\n", - " plt.figure(figsize=(24,4))\n", - " plt.title(\"Interpreted by outcome model\")\n", - " plt.imshow(exp_clinical,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", - " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", - " plt.plot(example,'k') \n", - " plt.xlim(0,len(example[:-idx]))\n", - " plt.colorbar()\n", - " plt.show()\n", - "\n", - " plt.figure(figsize=(24,4))\n", - " plt.title(\"Interpreted by murmur model\")\n", - " plt.imshow(exp_murmur,cmap='bwr', aspect=\"auto\", interpolation='nearest',extent=[0,val_data.shape[1],round(example.min()*1.05),round(example.max()*1.05)],\n", - " vmin=exp.min(), vmax=exp.max(), alpha=1.0)\n", - " plt.plot(example,'k') \n", - " plt.xlim(0,len(example[:-idx]))\n", - " plt.colorbar()\n", - " plt.show()\n", - " print(\"#################################################\")\n", - " print(\"#################################################\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "5Pc_vnj1HBkl", - "outputId": "033cee4e-657f-4a50-8dd0-8e8ff4020974" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Finding data files...\n", - "Extracting features and labels from the Challenge data...\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/942 [00:00 Date: Mon, 19 Sep 2022 16:14:37 +0200 Subject: [PATCH 03/51] Do changes in order to be able to run on Google Colab --- code/reproduce_results.py | 2 +- code/utils/utils.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index 44fcb68..fca5e78 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -7,7 +7,7 @@ def main(): - datafolder = '../data/ptbxl/' + datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' datafolder_icbeb = '../data/ICBEB/' outputfolder = '../output/' diff --git a/code/utils/utils.py b/code/utils/utils.py index e9e1df3..5a426ec 100644 --- a/code/utils/utils.py +++ b/code/utils/utils.py @@ -114,7 +114,7 @@ def apply_thresholds(preds, thresholds): # DATA PROCESSING STUFF def load_dataset(path, sampling_rate, release=False): - if path.split('/')[-2] == 'ptbxl': + if path.split('/')[-2] == 'ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1': # load and convert annotation data Y = pd.read_csv(path+'ptbxl_database.csv', index_col='ecg_id') Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x)) From f95b8194a5c88a25ee00cf02f4c14b92ac5b229d Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 19 Sep 2022 22:44:39 +0200 Subject: [PATCH 04/51] Update PTB_XL_experiments.ipynb --- PTB_XL_experiments.ipynb | 324 +++++++++++++++++++++++---------------- 1 file changed, 192 insertions(+), 132 deletions(-) diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb index 31abeea..41df774 100644 --- a/PTB_XL_experiments.ipynb +++ b/PTB_XL_experiments.ipynb @@ -2,14 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", - "outputId": "1f063c50-8a54-43bd-ae08-f4ac35625188" + "outputId": "9e800e18-abdb-4ce7-d8eb-ee5935eebad6" }, "outputs": [ { @@ -17,31 +17,37 @@ "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wget in /usr/local/lib/python3.7/dist-packages (3.2)\n", + "Collecting wget\n", + " Downloading wget-3.2.zip (10 kB)\n", "Collecting wfdb\n", " Downloading wfdb-4.0.0-py3-none-any.whl (161 kB)\n", - "\u001b[K |████████████████████████████████| 161 kB 34.3 MB/s \n", - "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", + "\u001b[K |████████████████████████████████| 161 kB 8.6 MB/s \n", + "\u001b[?25hRequirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Installing collected packages: wfdb\n", - "Successfully installed wfdb-4.0.0\n" + "Building wheels for collected packages: wget\n", + " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=ee227b7f370d03528b84282322c8c954f9f7907e99701a344a1c9c982713fa62\n", + " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", + "Successfully built wget\n", + "Installing collected packages: wget, wfdb\n", + "Successfully installed wfdb-4.0.0 wget-3.2\n" ] } ], @@ -84,32 +90,44 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "T0cGBrFsdJFb", "metadata": { "colab": { - "base_uri": "https://localhost:8080/" + "base_uri": "https://localhost:8080/", + "height": 445 }, "id": "T0cGBrFsdJFb", - "outputId": "8c082799-0e73-4194-967f-e713c67eb0f3" + "outputId": "54409fea-952f-4d22-a634-83c4ff070ece" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2022-09-19 09:55:46-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2022-09-19 12:34:28-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 11.9MB/s in 2m 30s \n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 12.2MB/s in 2m 35s \n", "\n", - "2022-09-19 09:58:18 (11.7 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "2022-09-19 12:37:04 (11.3 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", "\n" ] + }, + { + "output_type": "error", + "ename": "FileExistsError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mFileExistsError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./data/\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mFileExistsError\u001b[0m: [Errno 17] File exists: './data/'" + ] } ], "source": [ @@ -122,6 +140,19 @@ " zip_ref.extractall(\"./data/\")" ] }, + { + "cell_type": "code", + "source": [ + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ], + "metadata": { + "id": "ICe12Y7yxFKg" + }, + "id": "ICe12Y7yxFKg", + "execution_count": 6, + "outputs": [] + }, { "cell_type": "code", "source": [ @@ -130,13 +161,13 @@ ], "metadata": { "id": "V-j1oLL4Li10", - "outputId": "85592370-6f11-4ac1-c768-53ae41bc148c", + "outputId": "2b82b802-75ea-43bb-81cd-d5e745498803", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "V-j1oLL4Li10", - "execution_count": 5, + "execution_count": 7, "outputs": [ { "output_type": "stream", @@ -145,10 +176,10 @@ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", - "\u001b[K |████████████████████████████████| 181 kB 26.6 MB/s \n", + "\u001b[K |████████████████████████████████| 181 kB 9.3 MB/s \n", "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", - "\u001b[K |████████████████████████████████| 63 kB 1.9 MB/s \n", + "\u001b[K |████████████████████████████████| 63 kB 2.1 MB/s \n", "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", "Collecting smmap<6,>=3.0.1\n", " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", @@ -168,7 +199,7 @@ "id": "aLEwloYTLpue" }, "id": "aLEwloYTLpue", - "execution_count": 6, + "execution_count": 8, "outputs": [] }, { @@ -178,13 +209,13 @@ ], "metadata": { "id": "wrApvEoJLPYq", - "outputId": "01270847-76dd-4744-8ead-e7695e6b7d37", + "outputId": "20b543b7-0b4d-4ee8-a910-95bdd9ae2ad0", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "wrApvEoJLPYq", - "execution_count": 7, + "execution_count": 9, "outputs": [ { "output_type": "execute_result", @@ -194,39 +225,38 @@ ] }, "metadata": {}, - "execution_count": 7 + "execution_count": 9 } ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", - "outputId": "b06ee695-48f9-4195-d336-83580dbeb637" + "outputId": "e75df091-5a67-404a-8306-09af8266a40f" }, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ - "['records500',\n", + "['example_physionet.py',\n", " 'LICENSE.txt',\n", + " 'SHA256SUMS.txt',\n", + " 'scp_statements.csv',\n", " 'ptbxl_database.csv',\n", " 'RECORDS',\n", - " 'raw500.npy',\n", - " 'scp_statements.csv',\n", - " 'SHA256SUMS.txt',\n", " 'records100',\n", - " 'example_physionet.py']" + " 'records500']" ] }, "metadata": {}, - "execution_count": 5 + "execution_count": 10 } ], "source": [ @@ -240,14 +270,13 @@ ], "metadata": { "id": "fRteqX8GY5Nw", - "outputId": "ca36248d-cc59-41e8-a52d-ef34882725d9", + "outputId": "b2d5a085-da0d-43cf-ca17-9efbbb1aa9bf", "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 + "base_uri": "https://localhost:8080/" } }, "id": "fRteqX8GY5Nw", - "execution_count": 101, + "execution_count": 11, "outputs": [ { "output_type": "stream", @@ -255,77 +284,71 @@ "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting fastai==1.0.61\n", - " Using cached fastai-1.0.61-py3-none-any.whl (239 kB)\n", - "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", - "Requirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.0)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.7.3)\n", - "Requirement already satisfied: nvidia-ml-py3 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (7.352.0)\n", + " Downloading fastai-1.0.61-py3-none-any.whl (239 kB)\n", + "\u001b[K |████████████████████████████████| 239 kB 7.5 MB/s \n", + "\u001b[?25hCollecting nvidia-ml-py3\n", + " Downloading nvidia-ml-py3-7.352.0.tar.gz (19 kB)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.23.0)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (6.0)\n", "Requirement already satisfied: numexpr in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.8.3)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (0.13.1+cu113)\n", - "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (6.0)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.23.0)\n", "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.12.1+cu113)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (21.3)\n", - "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.21.6)\n", + "Collecting bottleneck\n", + " Downloading Bottleneck-1.3.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (355 kB)\n", + "\u001b[K |████████████████████████████████| 355 kB 71.9 MB/s \n", + "\u001b[?25hRequirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.7.3)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.2.2)\n", + "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.21.6)\n", + "Requirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.3)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (21.3)\n", "Requirement already satisfied: spacy>=2.0.18 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.4.1)\n", - "Requirement already satisfied: bottleneck in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (7.1.2)\n", - "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", + "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (8.1.0)\n", + "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", - "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", - "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.9 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.10)\n", "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.11.3)\n", - "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", - "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.64.1)\n", - "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", - "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.6)\n", - "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", - "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", - "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", - "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.8)\n", "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", + "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", + "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", + "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.6)\n", + "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", + "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.9 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.10)\n", + "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", + "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", + "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from catalogue<2.1.0,>=2.0.6->spacy>=2.0.18->fastai==1.0.61) (3.8.1)\n", "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->fastai==1.0.61) (3.0.9)\n", "Requirement already satisfied: smart-open<6.0.0,>=5.2.1 in /usr/local/lib/python3.7/dist-packages (from pathy>=0.3.5->spacy>=2.0.18->fastai==1.0.61) (5.2.1)\n", + "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (1.24.3)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2022.6.15)\n", - "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (1.25.11)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (3.0.4)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /usr/local/lib/python3.7/dist-packages (from thinc<8.2.0,>=8.1.0->spacy>=2.0.18->fastai==1.0.61) (0.7.8)\n", "Requirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.7/dist-packages (from typer<0.5.0,>=0.3.0->spacy>=2.0.18->fastai==1.0.61) (7.1.2)\n", "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->spacy>=2.0.18->fastai==1.0.61) (2.0.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (2.8.2)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->fastai==1.0.61) (1.15.0)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->fastai==1.0.61) (2022.2.1)\n", - "Installing collected packages: fastai\n", + "Building wheels for collected packages: nvidia-ml-py3\n", + " Building wheel for nvidia-ml-py3 (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for nvidia-ml-py3: filename=nvidia_ml_py3-7.352.0-py3-none-any.whl size=19190 sha256=c733fc9ed3e73cc02f2fce149091ded44991eeb4f2663fe2ccd84472ba1d7206\n", + " Stored in directory: /root/.cache/pip/wheels/df/99/da/c34f202dc8fd1dffd35e0ecf1a7d7f8374ca05fbcbaf974b83\n", + "Successfully built nvidia-ml-py3\n", + "Installing collected packages: nvidia-ml-py3, bottleneck, fastai\n", " Attempting uninstall: fastai\n", " Found existing installation: fastai 2.7.9\n", " Uninstalling fastai-2.7.9:\n", " Successfully uninstalled fastai-2.7.9\n", - "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n", - "fastbook 0.0.28 requires fastai>=2.6, but you have fastai 1.0.61 which is incompatible.\u001b[0m\n", - "Successfully installed fastai-1.0.61\n" + "Successfully installed bottleneck-1.3.5 fastai-1.0.61 nvidia-ml-py3-7.352.0\n" ] - }, - { - "output_type": "display_data", - "data": { - "application/vnd.colab-display-data+json": { - "pip_warning": { - "packages": [ - "fastai" - ] - } - } - }, - "metadata": {} } ] }, @@ -336,21 +359,20 @@ ], "metadata": { "id": "goTGyvV2fbtK", - "outputId": "eb453683-169e-478a-8cc0-3d095e4cdd16", + "outputId": "b48b57a7-e9ab-4590-fcb8-55219bb61b67", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "goTGyvV2fbtK", - "execution_count": 94, + "execution_count": 12, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: fastprogress in /usr/local/lib/python3.7/dist-packages (1.0.0)\n", - "Requirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from fastprogress) (1.21.6)\n" + "Requirement already satisfied: fastprogress in /usr/local/lib/python3.7/dist-packages (1.0.3)\n" ] } ] @@ -358,51 +380,71 @@ { "cell_type": "code", "source": [ - "!pip install -r requirements.txt" + "import fastai" ], "metadata": { - "id": "XYPnyQaRcBP1", - "outputId": "01092444-0ea3-45ca-8126-d224259c02f5", - "colab": { - "base_uri": "https://localhost:8080/" - } + "id": "EpL88UONKFJz" }, - "id": "XYPnyQaRcBP1", - "execution_count": 93, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "\u001b[31mERROR: Could not find a version that satisfies the requirement lame==3.100 (from versions: none)\u001b[0m\n", - "\u001b[31mERROR: No matching distribution found for lame==3.100\u001b[0m\n" - ] - } - ] + "id": "EpL88UONKFJz", + "execution_count": 51, + "outputs": [] }, { "cell_type": "code", "source": [ - "import fastai" + "from github_repo.code import *\n" ], "metadata": { - "id": "trF1gPYQY_lC" + "id": "IpjW6eVLMGJQ" }, - "id": "trF1gPYQY_lC", - "execution_count": 102, + "id": "IpjW6eVLMGJQ", + "execution_count": 53, "outputs": [] }, { "cell_type": "code", "source": [ - "from github_repo.code import *\n" + "from IPython.display import clear_output, display, HTML" ], "metadata": { - "id": "IpjW6eVLMGJQ" + "id": "xDIdqSZiIdZr" }, - "id": "IpjW6eVLMGJQ", - "execution_count": 109, + "id": "xDIdqSZiIdZr", + "execution_count": 54, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "IN_NOTEBOOK = True" + ], + "metadata": { + "id": "jW9VaPuDIlU1" + }, + "id": "jW9VaPuDIlU1", + "execution_count": 55, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "comment out line 179 and 168" + ], + "metadata": { + "id": "eHQk_njaK7u6" + }, + "id": "eHQk_njaK7u6" + }, + { + "cell_type": "code", + "source": [ + "from fastprogress import fastprogress" + ], + "metadata": { + "id": "qkyKwZjZLAGG" + }, + "id": "qkyKwZjZLAGG", + "execution_count": null, "outputs": [] }, { @@ -412,38 +454,56 @@ ], "metadata": { "id": "48KVqw_QMq2H", - "outputId": "d3540340-36f7-4788-dca0-68312cf6be14", + "outputId": "de76255f-d4d2-4fdf-decd-6d34f59a786f", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "48KVqw_QMq2H", - "execution_count": 111, + "execution_count": 57, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "tcmalloc: large alloc 2096357376 bytes == 0x4c8a000 @ 0x7fce324b81e7 0x4b2150 0x5ac2ec 0x5e3d6d 0x58ee7f 0x590c9f 0x591039 0x4fb96a 0x4fc108 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6\n", - "tcmalloc: large alloc 2096357376 bytes == 0x81bc8000 @ 0x7fce324b81e7 0x4b2150 0x5ac2ec 0x4fc11a 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fce320b5c87 0x5b561a\n", - "tcmalloc: large alloc 2096357376 bytes == 0x4c8a000 @ 0x7fce324b81e7 0x7fce2fdc90ce 0x7fce2fe1fcf5 0x7fce2fe1fe08 0x7fce2feb20b9 0x7fce2feb4a25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fce320b5c87 0x5b561a\n", - "tcmalloc: large alloc 1674338304 bytes == 0xffc34000 @ 0x7fce324b81e7 0x7fce2fdc90ce 0x7fce2fe1fcf5 0x7fce2fe1fe08 0x7fce2feb20b9 0x7fce2feb4a25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fce320b5c87 0x5b561a\n", + "tcmalloc: large alloc 2096357376 bytes == 0x878c000 @ 0x7f6db97cb1e7 0x4b2150 0x5ac2ec 0x5e3d6d 0x58ee7f 0x590c9f 0x591039 0x4fb96a 0x4fc108 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6\n", + "tcmalloc: large alloc 2096357376 bytes == 0x856ca000 @ 0x7f6db97cb1e7 0x4b2150 0x5ac2ec 0x4fc11a 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f6db93c8c87 0x5b561a\n", + "tcmalloc: large alloc 2096357376 bytes == 0x878c000 @ 0x7f6db97cb1e7 0x7f6db70dc0ce 0x7f6db7132cf5 0x7f6db7132e08 0x7f6db71c50b9 0x7f6db71c7a25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f6db93c8c87 0x5b561a\n", + "tcmalloc: large alloc 1674338304 bytes == 0x9e944000 @ 0x7f6db97cb1e7 0x7f6db70dc0ce 0x7f6db7132cf5 0x7f6db7132e08 0x7f6db71c50b9 0x7f6db71c7a25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f6db93c8c87 0x5b561a\n", + "Training from scratch...\n", + "model: fastai_xresnet1d101\n", + "\n", + "\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "\n", + "\n", + "model: fastai_xresnet1d101\n", + "\n", + "\n", "Traceback (most recent call last):\n", - " File \"/content/github_repo/code/reproduce_results.py\", line 61, in \n", + " File \"/content/github_repo/code/reproduce_results.py\", line 59, in \n", " main()\n", - " File \"/content/github_repo/code/reproduce_results.py\", line 42, in main\n", + " File \"/content/github_repo/code/reproduce_results.py\", line 40, in main\n", " e.perform()\n", - " File \"/content/github_repo/code/experiments/scp_experiment.py\", line 101, in perform\n", - " from models.fastai_model import fastai_model\n", - " File \"/content/github_repo/code/models/fastai_model.py\", line 14, in \n", - " from models.resnet1d import resnet1d18,resnet1d34,resnet1d50,resnet1d101,resnet1d152,resnet1d_wang,resnet1d,wrn1d_22\n", - " File \"/content/github_repo/code/models/resnet1d.py\", line 7, in \n", - " from models.basic_conv1d import create_head1d\n", - " File \"/content/github_repo/code/models/basic_conv1d.py\", line 47, in \n", - " class AdaptiveConcatPool1d(nn.Module):\n", - " File \"/content/github_repo/code/models/basic_conv1d.py\", line 49, in AdaptiveConcatPool1d\n", - " def __init__(self, sz:Optional[int]=None):\n", - "NameError: name 'Optional' is not defined\n" + " File \"/content/github_repo/code/experiments/scp_experiment.py\", line 114, in perform\n", + " model.predict(self.X_train).dump(mpath+'y_train_pred.npy')\n", + " File \"/content/github_repo/code/models/fastai_model.py\", line 294, in predict\n", + " preds,targs=learn.get_preds()\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 341, in get_preds\n", + " activ=activ, loss_func=lf, n_batch=n_batch, pbar=pbar)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 44, in get_preds\n", + " zip(*validate(model, dl, cb_handler=cb_handler, pbar=pbar, average=False, n_batch=n_batch))]\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 57, in validate\n", + " for xb,yb in progress_bar(dl, parent=pbar, leave=(pbar is not None)):\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 39, in __iter__\n", + " if self.total != 0: self.update(0)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 59, in update\n", + " self.update_bar(0)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 81, in update_bar\n", + " self.on_update(val, f'{pct}[{val}/{tot} {elapsed_t}{self.lt}{remaining_t}{end}]')\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 135, in on_update\n", + " if self.display: self.out.update(HTML(self.progress))\n", + "AttributeError: 'NoneType' object has no attribute 'update'\n" ] } ] From c6b98e8d1ee15ef27914a0f6f6104ce63c7d7cd1 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 28 Sep 2022 08:21:30 +0200 Subject: [PATCH 05/51] set output folder and change NB --- PTB_XL_experiments.ipynb | 285 ++++++++++++++++---------------------- code/reproduce_results.py | 2 +- 2 files changed, 118 insertions(+), 169 deletions(-) diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb index 41df774..31b11e5 100644 --- a/PTB_XL_experiments.ipynb +++ b/PTB_XL_experiments.ipynb @@ -9,7 +9,7 @@ "base_uri": "https://localhost:8080/" }, "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", - "outputId": "9e800e18-abdb-4ce7-d8eb-ee5935eebad6" + "outputId": "a8529608-c6e6-4953-c668-8a24a766f717" }, "outputs": [ { @@ -21,29 +21,29 @@ " Downloading wget-3.2.zip (10 kB)\n", "Collecting wfdb\n", " Downloading wfdb-4.0.0-py3-none-any.whl (161 kB)\n", - "\u001b[K |████████████████████████████████| 161 kB 8.6 MB/s \n", - "\u001b[?25hRequirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", + "\u001b[K |████████████████████████████████| 161 kB 6.8 MB/s \n", + "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", "Building wheels for collected packages: wget\n", " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=ee227b7f370d03528b84282322c8c954f9f7907e99701a344a1c9c982713fa62\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=a27195dc8e550da2e78dc90ef51eab933ab8068a738b0c3506c81a0f6b1e3cd7\n", " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", "Successfully built wget\n", "Installing collected packages: wget, wfdb\n", @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319", "metadata": { "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319" @@ -90,44 +90,32 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "T0cGBrFsdJFb", "metadata": { "colab": { - "base_uri": "https://localhost:8080/", - "height": 445 + "base_uri": "https://localhost:8080/" }, "id": "T0cGBrFsdJFb", - "outputId": "54409fea-952f-4d22-a634-83c4ff070ece" + "outputId": "779fb5f3-11dd-44fa-a177-a54dc2caeda8" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2022-09-19 12:34:28-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2022-09-28 06:06:31-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 12.2MB/s in 2m 35s \n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 16.2MB/s in 3m 24s \n", "\n", - "2022-09-19 12:37:04 (11.3 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "2022-09-28 06:09:56 (8.60 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", "\n" ] - }, - { - "output_type": "error", - "ename": "FileExistsError", - "evalue": "ignored", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileExistsError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msystem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmkdir\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./data/\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFileExistsError\u001b[0m: [Errno 17] File exists: './data/'" - ] } ], "source": [ @@ -150,7 +138,7 @@ "id": "ICe12Y7yxFKg" }, "id": "ICe12Y7yxFKg", - "execution_count": 6, + "execution_count": 5, "outputs": [] }, { @@ -161,13 +149,13 @@ ], "metadata": { "id": "V-j1oLL4Li10", - "outputId": "2b82b802-75ea-43bb-81cd-d5e745498803", + "outputId": "daa77680-b5ab-49fe-d82f-973433b4273b", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "V-j1oLL4Li10", - "execution_count": 7, + "execution_count": 6, "outputs": [ { "output_type": "stream", @@ -176,10 +164,10 @@ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", - "\u001b[K |████████████████████████████████| 181 kB 9.3 MB/s \n", + "\u001b[K |████████████████████████████████| 181 kB 9.5 MB/s \n", "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", - "\u001b[K |████████████████████████████████| 63 kB 2.1 MB/s \n", + "\u001b[K |████████████████████████████████| 63 kB 1.9 MB/s \n", "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", "Collecting smmap<6,>=3.0.1\n", " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", @@ -199,7 +187,7 @@ "id": "aLEwloYTLpue" }, "id": "aLEwloYTLpue", - "execution_count": 8, + "execution_count": 7, "outputs": [] }, { @@ -209,13 +197,13 @@ ], "metadata": { "id": "wrApvEoJLPYq", - "outputId": "20b543b7-0b4d-4ee8-a910-95bdd9ae2ad0", + "outputId": "7c51457d-f377-4238-cb9d-c6941a247c07", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "wrApvEoJLPYq", - "execution_count": 9, + "execution_count": 8, "outputs": [ { "output_type": "execute_result", @@ -225,20 +213,20 @@ ] }, "metadata": {}, - "execution_count": 9 + "execution_count": 8 } ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", - "outputId": "e75df091-5a67-404a-8306-09af8266a40f" + "outputId": "052d4acc-7ac8-4278-f506-5a81978e035a" }, "outputs": [ { @@ -246,17 +234,17 @@ "data": { "text/plain": [ "['example_physionet.py',\n", - " 'LICENSE.txt',\n", - " 'SHA256SUMS.txt',\n", " 'scp_statements.csv',\n", - " 'ptbxl_database.csv',\n", - " 'RECORDS',\n", " 'records100',\n", - " 'records500']" + " 'RECORDS',\n", + " 'LICENSE.txt',\n", + " 'ptbxl_database.csv',\n", + " 'records500',\n", + " 'SHA256SUMS.txt']" ] }, "metadata": {}, - "execution_count": 10 + "execution_count": 9 } ], "source": [ @@ -266,82 +254,85 @@ { "cell_type": "code", "source": [ - "!pip install fastai==1.0.61" + "!pip install git+https://github.com/Bsingstad/fastai.git" ], "metadata": { "id": "fRteqX8GY5Nw", - "outputId": "b2d5a085-da0d-43cf-ca17-9efbbb1aa9bf", + "outputId": "882734c1-22a4-48eb-b0a6-0572960f9c87", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "fRteqX8GY5Nw", - "execution_count": 11, + "execution_count": 10, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting fastai==1.0.61\n", - " Downloading fastai-1.0.61-py3-none-any.whl (239 kB)\n", - "\u001b[K |████████████████████████████████| 239 kB 7.5 MB/s \n", - "\u001b[?25hCollecting nvidia-ml-py3\n", - " Downloading nvidia-ml-py3-7.352.0.tar.gz (19 kB)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.23.0)\n", - "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (6.0)\n", - "Requirement already satisfied: numexpr in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.8.3)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", - "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (0.13.1+cu113)\n", - "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.12.1+cu113)\n", + "Collecting git+https://github.com/Bsingstad/fastai.git\n", + " Cloning https://github.com/Bsingstad/fastai.git to /tmp/pip-req-build-ynfe9k62\n", + " Running command git clone -q https://github.com/Bsingstad/fastai.git /tmp/pip-req-build-ynfe9k62\n", "Collecting bottleneck\n", " Downloading Bottleneck-1.3.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (355 kB)\n", - "\u001b[K |████████████████████████████████| 355 kB 71.9 MB/s \n", - "\u001b[?25hRequirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.7.3)\n", + "\u001b[K |████████████████████████████████| 355 kB 9.5 MB/s \n", + "\u001b[?25hRequirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.3)\n", + "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.2.2)\n", + "Requirement already satisfied: numexpr in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.8.3)\n", "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.21.6)\n", - "Requirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.3)\n", + "Collecting nvidia-ml-py3\n", + " Downloading nvidia-ml-py3-7.352.0.tar.gz (19 kB)\n", + "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (21.3)\n", - "Requirement already satisfied: spacy>=2.0.18 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.4.1)\n", "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (7.1.2)\n", - "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (6.0)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.23.0)\n", + "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.7.3)\n", + "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.12.1+cu113)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (0.13.1+cu113)\n", + "Requirement already satisfied: spacy>=2.0.18 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.4.1)\n", + "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", + "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", + "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", + "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", + "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (8.1.0)\n", - "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", - "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.11.3)\n", + "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.64.1)\n", + "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.8)\n", - "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", - "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", - "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", - "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.6)\n", + "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.11.3)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", + "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.9 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.10)\n", - "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", - "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", - "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from catalogue<2.1.0,>=2.0.6->spacy>=2.0.18->fastai==1.0.61) (3.8.1)\n", "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->fastai==1.0.61) (3.0.9)\n", "Requirement already satisfied: smart-open<6.0.0,>=5.2.1 in /usr/local/lib/python3.7/dist-packages (from pathy>=0.3.5->spacy>=2.0.18->fastai==1.0.61) (5.2.1)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", + "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (3.0.4)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (1.24.3)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2022.6.15)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (3.0.4)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /usr/local/lib/python3.7/dist-packages (from thinc<8.2.0,>=8.1.0->spacy>=2.0.18->fastai==1.0.61) (0.7.8)\n", "Requirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.7/dist-packages (from typer<0.5.0,>=0.3.0->spacy>=2.0.18->fastai==1.0.61) (7.1.2)\n", "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->spacy>=2.0.18->fastai==1.0.61) (2.0.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (2.8.2)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (1.4.4)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (2.8.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->fastai==1.0.61) (1.15.0)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->fastai==1.0.61) (2022.2.1)\n", - "Building wheels for collected packages: nvidia-ml-py3\n", + "Building wheels for collected packages: fastai, nvidia-ml-py3\n", + " Building wheel for fastai (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for fastai: filename=fastai-1.0.61-py3-none-any.whl size=239248 sha256=6b23758da907a971bc97106c2b36526f0d4c262900f2d1bebc6f3580ad145330\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-k7g3i9qm/wheels/52/1e/77/2c94d45e1e2b8c802fbe90de3282e719283c1941fa945f3c95\n", " Building wheel for nvidia-ml-py3 (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for nvidia-ml-py3: filename=nvidia_ml_py3-7.352.0-py3-none-any.whl size=19190 sha256=c733fc9ed3e73cc02f2fce149091ded44991eeb4f2663fe2ccd84472ba1d7206\n", + " Created wheel for nvidia-ml-py3: filename=nvidia_ml_py3-7.352.0-py3-none-any.whl size=19190 sha256=58874d9cf6f88d05c1ede1e766a184d4d269a23958612582039333a7289c6324\n", " Stored in directory: /root/.cache/pip/wheels/df/99/da/c34f202dc8fd1dffd35e0ecf1a7d7f8374ca05fbcbaf974b83\n", - "Successfully built nvidia-ml-py3\n", + "Successfully built fastai nvidia-ml-py3\n", "Installing collected packages: nvidia-ml-py3, bottleneck, fastai\n", " Attempting uninstall: fastai\n", " Found existing installation: fastai 2.7.9\n", @@ -352,31 +343,6 @@ } ] }, - { - "cell_type": "code", - "source": [ - "!pip install fastprogress" - ], - "metadata": { - "id": "goTGyvV2fbtK", - "outputId": "b48b57a7-e9ab-4590-fcb8-55219bb61b67", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "id": "goTGyvV2fbtK", - "execution_count": 12, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: fastprogress in /usr/local/lib/python3.7/dist-packages (1.0.3)\n" - ] - } - ] - }, { "cell_type": "code", "source": [ @@ -386,7 +352,7 @@ "id": "EpL88UONKFJz" }, "id": "EpL88UONKFJz", - "execution_count": 51, + "execution_count": 1, "outputs": [] }, { @@ -398,7 +364,7 @@ "id": "IpjW6eVLMGJQ" }, "id": "IpjW6eVLMGJQ", - "execution_count": 53, + "execution_count": 12, "outputs": [] }, { @@ -410,41 +376,19 @@ "id": "xDIdqSZiIdZr" }, "id": "xDIdqSZiIdZr", - "execution_count": 54, + "execution_count": 13, "outputs": [] }, { "cell_type": "code", "source": [ - "IN_NOTEBOOK = True" + "os.mkdir(\"../../content/output/\")" ], "metadata": { - "id": "jW9VaPuDIlU1" + "id": "Q8fTH7i-v8SY" }, - "id": "jW9VaPuDIlU1", - "execution_count": 55, - "outputs": [] - }, - { - "cell_type": "markdown", - "source": [ - "comment out line 179 and 168" - ], - "metadata": { - "id": "eHQk_njaK7u6" - }, - "id": "eHQk_njaK7u6" - }, - { - "cell_type": "code", - "source": [ - "from fastprogress import fastprogress" - ], - "metadata": { - "id": "qkyKwZjZLAGG" - }, - "id": "qkyKwZjZLAGG", - "execution_count": null, + "id": "Q8fTH7i-v8SY", + "execution_count": 4, "outputs": [] }, { @@ -454,56 +398,61 @@ ], "metadata": { "id": "48KVqw_QMq2H", - "outputId": "de76255f-d4d2-4fdf-decd-6d34f59a786f", + "outputId": "1e3560ee-3cd8-4f44-c957-c5f060c80300", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "48KVqw_QMq2H", - "execution_count": 57, + "execution_count": 14, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "tcmalloc: large alloc 2096357376 bytes == 0x878c000 @ 0x7f6db97cb1e7 0x4b2150 0x5ac2ec 0x5e3d6d 0x58ee7f 0x590c9f 0x591039 0x4fb96a 0x4fc108 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6\n", - "tcmalloc: large alloc 2096357376 bytes == 0x856ca000 @ 0x7f6db97cb1e7 0x4b2150 0x5ac2ec 0x4fc11a 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f6db93c8c87 0x5b561a\n", - "tcmalloc: large alloc 2096357376 bytes == 0x878c000 @ 0x7f6db97cb1e7 0x7f6db70dc0ce 0x7f6db7132cf5 0x7f6db7132e08 0x7f6db71c50b9 0x7f6db71c7a25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f6db93c8c87 0x5b561a\n", - "tcmalloc: large alloc 1674338304 bytes == 0x9e944000 @ 0x7f6db97cb1e7 0x7f6db70dc0ce 0x7f6db7132cf5 0x7f6db7132e08 0x7f6db71c50b9 0x7f6db71c7a25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f6db93c8c87 0x5b561a\n", + "100% 21837/21837 [00:53<00:00, 411.67it/s]\n", + "tcmalloc: large alloc 2096357376 bytes == 0x8534e000 @ 0x7fede75b41e7 0x7fede4e050ce 0x7fede4e61715 0x7fede4e61d1b 0x7fede4f02333 0x58eb9c 0x51b4e6 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fede71b1c87 0x5b561a\n", + "tcmalloc: large alloc 2096357376 bytes == 0x10228c000 @ 0x7fede75b41e7 0x4b2150 0x5ac2ec 0x7fede4ef5b8d 0x58ef1c 0x5901a3 0x7fede4ef6a69 0x58ef1c 0x590c9f 0x591039 0x50310c 0x5efbad 0x58eb9c 0x51babb 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de\n", + "tcmalloc: large alloc 2096357376 bytes == 0x10228c000 @ 0x7fede75b41e7 0x7fede4e050ce 0x7fede4e5bcf5 0x7fede4e5be08 0x7fede4eee0b9 0x7fede4ef0a25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fede71b1c87 0x5b561a\n", + "tcmalloc: large alloc 1674338304 bytes == 0x9e5c4000 @ 0x7fede75b41e7 0x7fede4e050ce 0x7fede4e5bcf5 0x7fede4e5be08 0x7fede4eee0b9 0x7fede4ef0a25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fede71b1c87 0x5b561a\n", "Training from scratch...\n", "model: fastai_xresnet1d101\n", - "\n", - "\n", + " 71% 97/136 [00:19<00:07, 5.09it/s]\n", "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "\n", - "\n", - "model: fastai_xresnet1d101\n", - "\n", - "\n", + "100% 136/136 [00:15<00:00, 8.68it/s]\n", + "100% 120/120 [00:03<00:00, 30.82it/s]\n", + " 18% 25/136 [00:03<00:14, 7.45it/s]\n", "Traceback (most recent call last):\n", " File \"/content/github_repo/code/reproduce_results.py\", line 59, in \n", " main()\n", " File \"/content/github_repo/code/reproduce_results.py\", line 40, in main\n", " e.perform()\n", - " File \"/content/github_repo/code/experiments/scp_experiment.py\", line 114, in perform\n", - " model.predict(self.X_train).dump(mpath+'y_train_pred.npy')\n", - " File \"/content/github_repo/code/models/fastai_model.py\", line 294, in predict\n", - " preds,targs=learn.get_preds()\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 341, in get_preds\n", - " activ=activ, loss_func=lf, n_batch=n_batch, pbar=pbar)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 44, in get_preds\n", - " zip(*validate(model, dl, cb_handler=cb_handler, pbar=pbar, average=False, n_batch=n_batch))]\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 57, in validate\n", - " for xb,yb in progress_bar(dl, parent=pbar, leave=(pbar is not None)):\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 39, in __iter__\n", - " if self.total != 0: self.update(0)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 59, in update\n", - " self.update_bar(0)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 81, in update_bar\n", - " self.on_update(val, f'{pct}[{val}/{tot} {elapsed_t}{self.lt}{remaining_t}{end}]')\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastprogress/fastprogress.py\", line 135, in on_update\n", - " if self.display: self.out.update(HTML(self.progress))\n", - "AttributeError: 'NoneType' object has no attribute 'update'\n" + " File \"/content/github_repo/code/experiments/scp_experiment.py\", line 112, in perform\n", + " model.fit(self.X_train, self.y_train, self.X_val, self.y_val)\n", + " File \"/content/github_repo/code/models/fastai_model.py\", line 236, in fit\n", + " learn.fit_one_cycle(self.epochs,self.lr)#slice(self.lr) if self.discriminative_lrs else self.lr)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/train.py\", line 23, in fit_one_cycle\n", + " learn.fit(cyc_len, max_lr, wd=wd, callbacks=callbacks)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 203, in fit\n", + " fit(epochs, self, metrics=self.metrics, callbacks=self.callbacks+callbacks)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 104, in fit\n", + " loss = loss_batch(learn.model, xb, yb, learn.loss_func, learn.opt, cb_handler)\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 36, in loss_batch\n", + " if not cb_handler.on_backward_end(): opt.step()\n", + " File \"/usr/local/lib/python3.7/dist-packages/fastai/callback.py\", line 57, in step\n", + " self.opt.step()\n", + " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/optimizer.py\", line 113, in wrapper\n", + " return func(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.7/dist-packages/torch/autograd/grad_mode.py\", line 27, in decorate_context\n", + " return func(*args, **kwargs)\n", + " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\", line 171, in step\n", + " capturable=group['capturable'])\n", + " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\", line 226, in adam\n", + " capturable=capturable)\n", + " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\", line 305, in _single_tensor_adam\n", + " denom = (exp_avg_sq.sqrt() / bias_correction2_sqrt).add_(eps)\n", + "KeyboardInterrupt\n", + "^C\n" ] } ] diff --git a/code/reproduce_results.py b/code/reproduce_results.py index fca5e78..53828b1 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -9,7 +9,7 @@ def main(): datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' datafolder_icbeb = '../data/ICBEB/' - outputfolder = '../output/' + outputfolder = '../../content/output/' models = [ conf_fastai_xresnet1d101, From 4869a96478690d504b11cace346c40d47500935a Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 28 Sep 2022 08:26:21 +0200 Subject: [PATCH 06/51] override hardcoded folders --- code/reproduce_results.py | 4 ++-- code/utils/utils.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index 53828b1..db04680 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -41,7 +41,7 @@ def main(): e.evaluate() # generate greate summary table - utils.generate_ptbxl_summary_table() + utils.generate_ptbxl_summary_table(folder = '../../content/output/') ########################################## # EXPERIMENT BASED ICBEB DATA @@ -53,7 +53,7 @@ def main(): e.evaluate() # generate greate summary table - utils.ICBEBE_table() + utils.ICBEBE_table(folder='../../content/output/') if __name__ == "__main__": main() diff --git a/code/utils/utils.py b/code/utils/utils.py index 5a426ec..d8bb613 100644 --- a/code/utils/utils.py +++ b/code/utils/utils.py @@ -335,7 +335,7 @@ def apply_standardizer(X, ss): # DOCUMENTATION STUFF -def generate_ptbxl_summary_table(selection=None, folder='../output/'): +def generate_ptbxl_summary_table(selection=None, folder: str="./your/path/to/ptbxl/"): exps = ['exp0', 'exp1', 'exp1.1', 'exp1.1.1', 'exp2', 'exp3'] metric1 = 'macro_auc' @@ -405,7 +405,7 @@ def generate_ptbxl_summary_table(selection=None, folder='../output/'): md_source += '| ' + row[0].replace('fastai_', '') + ' | ' + row[1] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \n' print(md_source) -def ICBEBE_table(selection=None, folder='../output/'): +def ICBEBE_table(selection=None, folder:str="./your/path/to/icbeb/"): cols = ['macro_auc', 'F_beta_macro', 'G_beta_macro'] if selection is None: From 2a9b41c7647e5ccf63feaca112a505c08005528d Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 28 Sep 2022 15:52:00 +0200 Subject: [PATCH 07/51] Make it possible to store results in google drive --- PTB_XL_experiments.ipynb | 4053 ++++++++++++++++++++++++++++++++++++- code/reproduce_results.py | 6 +- 2 files changed, 3970 insertions(+), 89 deletions(-) diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb index 31b11e5..0b3978d 100644 --- a/PTB_XL_experiments.ipynb +++ b/PTB_XL_experiments.ipynb @@ -9,7 +9,7 @@ "base_uri": "https://localhost:8080/" }, "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", - "outputId": "a8529608-c6e6-4953-c668-8a24a766f717" + "outputId": "e7ea69a2-70fb-444a-9d9b-2b962c56ef12" }, "outputs": [ { @@ -21,29 +21,29 @@ " Downloading wget-3.2.zip (10 kB)\n", "Collecting wfdb\n", " Downloading wfdb-4.0.0-py3-none-any.whl (161 kB)\n", - "\u001b[K |████████████████████████████████| 161 kB 6.8 MB/s \n", - "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", + "\u001b[K |████████████████████████████████| 161 kB 13.5 MB/s \n", + "\u001b[?25hRequirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", "Building wheels for collected packages: wget\n", " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=a27195dc8e550da2e78dc90ef51eab933ab8068a738b0c3506c81a0f6b1e3cd7\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=0218240348ccec295705f719dfa125819a26052dbb9d86110fa8b1fdc244dc19\n", " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", "Successfully built wget\n", "Installing collected packages: wget, wfdb\n", @@ -57,7 +57,20 @@ }, { "cell_type": "code", - "execution_count": 3, + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ], + "metadata": { + "id": "JXL0zlq8Wdpl" + }, + "id": "JXL0zlq8Wdpl", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 2, "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319", "metadata": { "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319" @@ -97,23 +110,23 @@ "base_uri": "https://localhost:8080/" }, "id": "T0cGBrFsdJFb", - "outputId": "779fb5f3-11dd-44fa-a177-a54dc2caeda8" + "outputId": "21ff2faf-7c26-45d3-f422-302521d7d752" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2022-09-28 06:06:31-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2022-09-28 06:27:07-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 16.2MB/s in 3m 24s \n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 6.21MB/s in 3m 40s \n", "\n", - "2022-09-28 06:09:56 (8.60 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "2022-09-28 06:30:47 (8.00 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", "\n" ] } @@ -149,7 +162,7 @@ ], "metadata": { "id": "V-j1oLL4Li10", - "outputId": "daa77680-b5ab-49fe-d82f-973433b4273b", + "outputId": "e3432168-e2f3-422e-a5c0-e5c9b5f6c3e1", "colab": { "base_uri": "https://localhost:8080/" } @@ -164,10 +177,10 @@ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", - "\u001b[K |████████████████████████████████| 181 kB 9.5 MB/s \n", + "\u001b[K |████████████████████████████████| 181 kB 14.9 MB/s \n", "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", - "\u001b[K |████████████████████████████████| 63 kB 1.9 MB/s \n", + "\u001b[K |████████████████████████████████| 63 kB 2.0 MB/s \n", "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", "Collecting smmap<6,>=3.0.1\n", " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", @@ -197,7 +210,7 @@ ], "metadata": { "id": "wrApvEoJLPYq", - "outputId": "7c51457d-f377-4238-cb9d-c6941a247c07", + "outputId": "b9336107-9b65-4860-e7b0-8a7ba5559685", "colab": { "base_uri": "https://localhost:8080/" } @@ -226,7 +239,7 @@ "base_uri": "https://localhost:8080/" }, "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", - "outputId": "052d4acc-7ac8-4278-f506-5a81978e035a" + "outputId": "00f6632b-41af-46ad-bd53-7a246374639f" }, "outputs": [ { @@ -258,7 +271,7 @@ ], "metadata": { "id": "fRteqX8GY5Nw", - "outputId": "882734c1-22a4-48eb-b0a6-0572960f9c87", + "outputId": "1725f25e-f9b3-48c5-ca99-ce226db5fc3f", "colab": { "base_uri": "https://localhost:8080/" } @@ -272,11 +285,11 @@ "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting git+https://github.com/Bsingstad/fastai.git\n", - " Cloning https://github.com/Bsingstad/fastai.git to /tmp/pip-req-build-ynfe9k62\n", - " Running command git clone -q https://github.com/Bsingstad/fastai.git /tmp/pip-req-build-ynfe9k62\n", + " Cloning https://github.com/Bsingstad/fastai.git to /tmp/pip-req-build-j7eyrvwm\n", + " Running command git clone -q https://github.com/Bsingstad/fastai.git /tmp/pip-req-build-j7eyrvwm\n", "Collecting bottleneck\n", " Downloading Bottleneck-1.3.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (355 kB)\n", - "\u001b[K |████████████████████████████████| 355 kB 9.5 MB/s \n", + "\u001b[K |████████████████████████████████| 355 kB 16.1 MB/s \n", "\u001b[?25hRequirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.3)\n", "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.2.2)\n", @@ -293,44 +306,44 @@ "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.12.1+cu113)\n", "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (0.13.1+cu113)\n", "Requirement already satisfied: spacy>=2.0.18 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.4.1)\n", - "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", - "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", - "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", - "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", - "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (8.1.0)\n", - "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", + "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.64.1)\n", - "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", - "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.8)\n", + "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (8.1.0)\n", "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.6)\n", + "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", + "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.11.3)\n", - "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", - "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", - "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", + "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.9 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.10)\n", + "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", + "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", + "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", + "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", + "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.8)\n", + "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from catalogue<2.1.0,>=2.0.6->spacy>=2.0.18->fastai==1.0.61) (3.8.1)\n", "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->fastai==1.0.61) (3.0.9)\n", "Requirement already satisfied: smart-open<6.0.0,>=5.2.1 in /usr/local/lib/python3.7/dist-packages (from pathy>=0.3.5->spacy>=2.0.18->fastai==1.0.61) (5.2.1)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2022.6.15)\n", "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (3.0.4)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (1.24.3)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2022.6.15)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /usr/local/lib/python3.7/dist-packages (from thinc<8.2.0,>=8.1.0->spacy>=2.0.18->fastai==1.0.61) (0.7.8)\n", "Requirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.7/dist-packages (from typer<0.5.0,>=0.3.0->spacy>=2.0.18->fastai==1.0.61) (7.1.2)\n", "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->spacy>=2.0.18->fastai==1.0.61) (2.0.1)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (1.4.4)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (1.4.4)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->fastai==1.0.61) (1.15.0)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->fastai==1.0.61) (2022.2.1)\n", "Building wheels for collected packages: fastai, nvidia-ml-py3\n", " Building wheel for fastai (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for fastai: filename=fastai-1.0.61-py3-none-any.whl size=239248 sha256=6b23758da907a971bc97106c2b36526f0d4c262900f2d1bebc6f3580ad145330\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-k7g3i9qm/wheels/52/1e/77/2c94d45e1e2b8c802fbe90de3282e719283c1941fa945f3c95\n", + " Created wheel for fastai: filename=fastai-1.0.61-py3-none-any.whl size=239248 sha256=e42f2470cde0579ffac1f4706677ddd364f449a9b9a295f589acfac5608dbaaa\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-64udcezx/wheels/52/1e/77/2c94d45e1e2b8c802fbe90de3282e719283c1941fa945f3c95\n", " Building wheel for nvidia-ml-py3 (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for nvidia-ml-py3: filename=nvidia_ml_py3-7.352.0-py3-none-any.whl size=19190 sha256=58874d9cf6f88d05c1ede1e766a184d4d269a23958612582039333a7289c6324\n", + " Created wheel for nvidia-ml-py3: filename=nvidia_ml_py3-7.352.0-py3-none-any.whl size=19190 sha256=c00b69db274e57522a7b6f1257eff0c260ea2b5c4b2d62fcb8bb372aef391030\n", " Stored in directory: /root/.cache/pip/wheels/df/99/da/c34f202dc8fd1dffd35e0ecf1a7d7f8374ca05fbcbaf974b83\n", "Successfully built fastai nvidia-ml-py3\n", "Installing collected packages: nvidia-ml-py3, bottleneck, fastai\n", @@ -352,7 +365,7 @@ "id": "EpL88UONKFJz" }, "id": "EpL88UONKFJz", - "execution_count": 1, + "execution_count": 11, "outputs": [] }, { @@ -382,13 +395,13 @@ { "cell_type": "code", "source": [ - "os.mkdir(\"../../content/output/\")" + "os.mkdir(\"../../content/drive/output/\")" ], "metadata": { "id": "Q8fTH7i-v8SY" }, "id": "Q8fTH7i-v8SY", - "execution_count": 4, + "execution_count": 14, "outputs": [] }, { @@ -398,61 +411,3929 @@ ], "metadata": { "id": "48KVqw_QMq2H", - "outputId": "1e3560ee-3cd8-4f44-c957-c5f060c80300", + "outputId": "121ff7f7-4466-4b20-a65b-d94ea67dd04f", "colab": { "base_uri": "https://localhost:8080/" } }, "id": "48KVqw_QMq2H", - "execution_count": 14, + "execution_count": null, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "100% 21837/21837 [00:53<00:00, 411.67it/s]\n", - "tcmalloc: large alloc 2096357376 bytes == 0x8534e000 @ 0x7fede75b41e7 0x7fede4e050ce 0x7fede4e61715 0x7fede4e61d1b 0x7fede4f02333 0x58eb9c 0x51b4e6 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fede71b1c87 0x5b561a\n", - "tcmalloc: large alloc 2096357376 bytes == 0x10228c000 @ 0x7fede75b41e7 0x4b2150 0x5ac2ec 0x7fede4ef5b8d 0x58ef1c 0x5901a3 0x7fede4ef6a69 0x58ef1c 0x590c9f 0x591039 0x50310c 0x5efbad 0x58eb9c 0x51babb 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de\n", - "tcmalloc: large alloc 2096357376 bytes == 0x10228c000 @ 0x7fede75b41e7 0x7fede4e050ce 0x7fede4e5bcf5 0x7fede4e5be08 0x7fede4eee0b9 0x7fede4ef0a25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fede71b1c87 0x5b561a\n", - "tcmalloc: large alloc 1674338304 bytes == 0x9e5c4000 @ 0x7fede75b41e7 0x7fede4e050ce 0x7fede4e5bcf5 0x7fede4e5be08 0x7fede4eee0b9 0x7fede4ef0a25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7fede71b1c87 0x5b561a\n", + "100% 21837/21837 [01:01<00:00, 357.00it/s]\n", + "tcmalloc: large alloc 2096357376 bytes == 0x84250000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a791d715 0x7f16a791dd1b 0x7f16a79be333 0x58eb9c 0x51b4e6 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", + "tcmalloc: large alloc 2096357376 bytes == 0x10118e000 @ 0x7f16aa0701e7 0x4b2150 0x5ac2ec 0x7f16a79b1b8d 0x58ef1c 0x5901a3 0x7f16a79b2a69 0x58ef1c 0x590c9f 0x591039 0x50310c 0x5efbad 0x58eb9c 0x51babb 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de\n", + "tcmalloc: large alloc 2096357376 bytes == 0x10118e000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a7917cf5 0x7f16a7917e08 0x7f16a79aa0b9 0x7f16a79aca25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", + "tcmalloc: large alloc 1674338304 bytes == 0x84250000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a7917cf5 0x7f16a7917e08 0x7f16a79aa0b9 0x7f16a79aca25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", "Training from scratch...\n", "model: fastai_xresnet1d101\n", - " 71% 97/136 [00:19<00:07, 5.09it/s]\n", + " 71% 96/136 [00:17<00:07, 5.48it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 136/136 [00:12<00:00, 11.14it/s]\n", + "100% 120/120 [00:03<00:00, 32.50it/s]\n", + "100% 136/136 [00:11<00:00, 11.38it/s]\n", + "100% 120/120 [00:03<00:00, 31.59it/s]\n", + "100% 136/136 [00:12<00:00, 10.85it/s]\n", + "100% 120/120 [00:03<00:00, 32.81it/s]\n", + "100% 136/136 [00:12<00:00, 11.27it/s]\n", + "100% 120/120 [00:03<00:00, 33.32it/s]\n", + "100% 136/136 [00:12<00:00, 11.30it/s]\n", + "100% 120/120 [00:03<00:00, 32.64it/s]\n", + "100% 136/136 [00:12<00:00, 11.24it/s]\n", + "100% 120/120 [00:03<00:00, 32.84it/s]\n", + "100% 136/136 [00:12<00:00, 11.27it/s]\n", + "100% 120/120 [00:03<00:00, 32.87it/s]\n", + "100% 136/136 [00:12<00:00, 10.92it/s]\n", + "100% 120/120 [00:03<00:00, 32.57it/s]\n", + "100% 136/136 [00:12<00:00, 11.00it/s]\n", + "100% 120/120 [00:03<00:00, 32.63it/s]\n", + "100% 136/136 [00:12<00:00, 11.03it/s]\n", + "100% 120/120 [00:03<00:00, 30.98it/s]\n", + "100% 136/136 [00:12<00:00, 11.02it/s]\n", + "100% 120/120 [00:03<00:00, 32.16it/s]\n", + "100% 136/136 [00:12<00:00, 11.11it/s]\n", + "100% 120/120 [00:03<00:00, 31.54it/s]\n", + "100% 136/136 [00:12<00:00, 11.25it/s]\n", + "100% 120/120 [00:03<00:00, 31.64it/s]\n", + "100% 136/136 [00:12<00:00, 11.14it/s]\n", + "100% 120/120 [00:03<00:00, 32.65it/s]\n", + "100% 136/136 [00:12<00:00, 10.85it/s]\n", + "100% 120/120 [00:03<00:00, 30.97it/s]\n", + "100% 136/136 [00:12<00:00, 10.84it/s]\n", + "100% 120/120 [00:03<00:00, 33.12it/s]\n", + "100% 136/136 [00:12<00:00, 11.31it/s]\n", + "100% 120/120 [00:03<00:00, 33.04it/s]\n", + "100% 136/136 [00:12<00:00, 11.00it/s]\n", + "100% 120/120 [00:03<00:00, 31.11it/s]\n", + "100% 136/136 [00:12<00:00, 11.07it/s]\n", + "100% 120/120 [00:04<00:00, 29.54it/s]\n", + "100% 136/136 [00:12<00:00, 11.12it/s]\n", + "100% 120/120 [00:03<00:00, 33.24it/s]\n", + "100% 136/136 [00:12<00:00, 11.03it/s]\n", + "100% 120/120 [00:03<00:00, 32.71it/s]\n", + "100% 136/136 [00:12<00:00, 11.04it/s]\n", + "100% 120/120 [00:03<00:00, 33.22it/s]\n", + "100% 136/136 [00:12<00:00, 11.03it/s]\n", + "100% 120/120 [00:03<00:00, 32.08it/s]\n", + "100% 136/136 [00:12<00:00, 11.01it/s]\n", + "100% 120/120 [00:03<00:00, 32.82it/s]\n", + "100% 136/136 [00:12<00:00, 11.14it/s]\n", + "100% 120/120 [00:03<00:00, 33.26it/s]\n", + "100% 136/136 [00:12<00:00, 11.30it/s]\n", + "100% 120/120 [00:03<00:00, 33.13it/s]\n", + "100% 136/136 [00:12<00:00, 11.08it/s]\n", + "100% 120/120 [00:03<00:00, 31.86it/s]\n", + "100% 136/136 [00:12<00:00, 11.07it/s]\n", + "100% 120/120 [00:03<00:00, 32.96it/s]\n", + "100% 136/136 [00:12<00:00, 11.06it/s]\n", + "100% 120/120 [00:03<00:00, 32.10it/s]\n", + "100% 136/136 [00:12<00:00, 11.27it/s]\n", + "100% 120/120 [00:03<00:00, 31.37it/s]\n", + "100% 136/136 [00:12<00:00, 11.24it/s]\n", + "100% 120/120 [00:03<00:00, 31.34it/s]\n", + "100% 136/136 [00:12<00:00, 11.25it/s]\n", + "100% 120/120 [00:03<00:00, 33.35it/s]\n", + "100% 136/136 [00:12<00:00, 10.84it/s]\n", + "100% 120/120 [00:03<00:00, 33.03it/s]\n", + "100% 136/136 [00:12<00:00, 11.07it/s]\n", + "100% 120/120 [00:03<00:00, 31.80it/s]\n", + "100% 136/136 [00:12<00:00, 10.61it/s]\n", + "100% 120/120 [00:03<00:00, 32.00it/s]\n", + "100% 136/136 [00:11<00:00, 11.41it/s]\n", + "100% 120/120 [00:03<00:00, 32.14it/s]\n", + "100% 136/136 [00:12<00:00, 11.11it/s]\n", + "100% 120/120 [00:03<00:00, 32.09it/s]\n", + "100% 136/136 [00:12<00:00, 11.22it/s]\n", + "100% 120/120 [00:03<00:00, 31.52it/s]\n", + "100% 136/136 [00:12<00:00, 10.98it/s]\n", + "100% 120/120 [00:03<00:00, 32.45it/s]\n", + "100% 136/136 [00:12<00:00, 10.93it/s]\n", + "100% 120/120 [00:03<00:00, 31.74it/s]\n", + "100% 136/136 [00:12<00:00, 11.08it/s]\n", + "100% 120/120 [00:03<00:00, 32.84it/s]\n", + "100% 136/136 [00:12<00:00, 11.14it/s]\n", + "100% 120/120 [00:03<00:00, 32.75it/s]\n", + "100% 136/136 [00:12<00:00, 10.83it/s]\n", + "100% 120/120 [00:03<00:00, 32.96it/s]\n", + "100% 136/136 [00:12<00:00, 11.15it/s]\n", + "100% 120/120 [00:03<00:00, 32.48it/s]\n", + "100% 136/136 [00:12<00:00, 11.02it/s]\n", + "100% 120/120 [00:03<00:00, 32.92it/s]\n", + "100% 136/136 [00:12<00:00, 10.99it/s]\n", + "100% 120/120 [00:03<00:00, 31.80it/s]\n", + "100% 136/136 [00:12<00:00, 11.02it/s]\n", + "100% 120/120 [00:03<00:00, 32.32it/s]\n", + "100% 136/136 [00:12<00:00, 11.15it/s]\n", + "100% 120/120 [00:03<00:00, 32.48it/s]\n", + "100% 136/136 [00:12<00:00, 10.81it/s]\n", + "100% 120/120 [00:03<00:00, 31.91it/s]\n", + "100% 136/136 [00:12<00:00, 11.07it/s]\n", + "100% 120/120 [00:03<00:00, 33.34it/s]\n", + "model: fastai_xresnet1d101\n", + "100% 954/954 [00:26<00:00, 35.90it/s]\n", + "aggregating predictions...\n", + "model: fastai_xresnet1d101\n", + "100% 120/120 [00:03<00:00, 31.33it/s]\n", + "aggregating predictions...\n", + "model: fastai_xresnet1d101\n", + "100% 121/121 [00:03<00:00, 32.11it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_resnet1d_wang\n", + " 71% 96/136 [00:21<00:09, 4.37it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 52.45it/s]\n", + "100% 136/136 [00:29<00:00, 4.59it/s]\n", + "100% 120/120 [00:02<00:00, 52.08it/s]\n", + "100% 136/136 [00:29<00:00, 4.55it/s]\n", + "100% 120/120 [00:02<00:00, 51.70it/s]\n", + "100% 136/136 [00:29<00:00, 4.58it/s]\n", + "100% 120/120 [00:02<00:00, 51.36it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.49it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.01it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 49.62it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 49.72it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.60it/s]\n", + "100% 136/136 [00:29<00:00, 4.55it/s]\n", + "100% 120/120 [00:02<00:00, 51.68it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 50.97it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.30it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.71it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.04it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 53.11it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 52.68it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 51.63it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.85it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.64it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.01it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.05it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 52.89it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.51it/s]\n", + "100% 136/136 [00:29<00:00, 4.58it/s]\n", + "100% 120/120 [00:02<00:00, 52.88it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 52.01it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 51.52it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 48.83it/s]\n", + "100% 136/136 [00:29<00:00, 4.55it/s]\n", + "100% 120/120 [00:02<00:00, 50.32it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.81it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 51.06it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 51.98it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 51.28it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 51.75it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.21it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 51.33it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 52.08it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.74it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 53.01it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.44it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 53.08it/s]\n", + "100% 136/136 [00:29<00:00, 4.58it/s]\n", + "100% 120/120 [00:02<00:00, 53.16it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 53.97it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 54.23it/s]\n", + "100% 136/136 [00:29<00:00, 4.58it/s]\n", + "100% 120/120 [00:02<00:00, 51.71it/s]\n", + "100% 136/136 [00:29<00:00, 4.56it/s]\n", + "100% 120/120 [00:02<00:00, 52.56it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 53.88it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 53.58it/s]\n", + "100% 136/136 [00:29<00:00, 4.58it/s]\n", + "100% 120/120 [00:02<00:00, 52.72it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 53.81it/s]\n", + "100% 136/136 [00:29<00:00, 4.57it/s]\n", + "100% 120/120 [00:02<00:00, 52.84it/s]\n", + "model: fastai_resnet1d_wang\n", + "100% 954/954 [00:15<00:00, 61.59it/s]\n", + "aggregating predictions...\n", + "model: fastai_resnet1d_wang\n", + "100% 120/120 [00:02<00:00, 51.85it/s]\n", + "aggregating predictions...\n", + "model: fastai_resnet1d_wang\n", + "100% 121/121 [00:02<00:00, 52.59it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_lstm\n", + " 70% 95/136 [00:09<00:03, 10.40it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 136/136 [00:11<00:00, 12.10it/s]\n", + "100% 120/120 [00:03<00:00, 31.84it/s]\n", + "100% 136/136 [00:10<00:00, 12.48it/s]\n", + "100% 120/120 [00:03<00:00, 32.50it/s]\n", + "100% 136/136 [00:10<00:00, 12.68it/s]\n", + "100% 120/120 [00:03<00:00, 32.93it/s]\n", + "100% 136/136 [00:10<00:00, 12.73it/s]\n", + "100% 120/120 [00:03<00:00, 32.81it/s]\n", + "100% 136/136 [00:10<00:00, 12.68it/s]\n", + "100% 120/120 [00:03<00:00, 32.64it/s]\n", + "100% 136/136 [00:10<00:00, 12.56it/s]\n", + "100% 120/120 [00:03<00:00, 32.52it/s]\n", + "100% 136/136 [00:10<00:00, 12.52it/s]\n", + "100% 120/120 [00:03<00:00, 32.61it/s]\n", + "100% 136/136 [00:10<00:00, 12.58it/s]\n", + "100% 120/120 [00:03<00:00, 32.75it/s]\n", + "100% 136/136 [00:10<00:00, 12.57it/s]\n", + "100% 120/120 [00:03<00:00, 32.83it/s]\n", + "100% 136/136 [00:10<00:00, 12.61it/s]\n", + "100% 120/120 [00:03<00:00, 32.72it/s]\n", + "100% 136/136 [00:10<00:00, 12.64it/s]\n", + "100% 120/120 [00:03<00:00, 32.82it/s]\n", + "100% 136/136 [00:10<00:00, 12.63it/s]\n", + "100% 120/120 [00:03<00:00, 32.92it/s]\n", + "100% 136/136 [00:10<00:00, 12.59it/s]\n", + "100% 120/120 [00:03<00:00, 32.71it/s]\n", + "100% 136/136 [00:10<00:00, 12.57it/s]\n", + "100% 120/120 [00:03<00:00, 32.68it/s]\n", + "100% 136/136 [00:10<00:00, 12.58it/s]\n", + "100% 120/120 [00:03<00:00, 32.82it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.55it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.52it/s]\n", + "100% 136/136 [00:10<00:00, 12.54it/s]\n", + "100% 120/120 [00:03<00:00, 32.71it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.57it/s]\n", + "100% 136/136 [00:10<00:00, 12.59it/s]\n", + "100% 120/120 [00:03<00:00, 32.32it/s]\n", + "100% 136/136 [00:10<00:00, 12.55it/s]\n", + "100% 120/120 [00:03<00:00, 32.63it/s]\n", + "100% 136/136 [00:10<00:00, 12.52it/s]\n", + "100% 120/120 [00:03<00:00, 32.19it/s]\n", + "100% 136/136 [00:10<00:00, 12.50it/s]\n", + "100% 120/120 [00:03<00:00, 32.53it/s]\n", + "100% 136/136 [00:10<00:00, 12.54it/s]\n", + "100% 120/120 [00:03<00:00, 32.67it/s]\n", + "100% 136/136 [00:10<00:00, 12.49it/s]\n", + "100% 120/120 [00:03<00:00, 32.53it/s]\n", + "100% 136/136 [00:10<00:00, 12.50it/s]\n", + "100% 120/120 [00:03<00:00, 32.59it/s]\n", + "100% 136/136 [00:10<00:00, 12.51it/s]\n", + "100% 120/120 [00:03<00:00, 32.78it/s]\n", + "100% 136/136 [00:10<00:00, 12.56it/s]\n", + "100% 120/120 [00:03<00:00, 32.55it/s]\n", + "100% 136/136 [00:10<00:00, 12.57it/s]\n", + "100% 120/120 [00:03<00:00, 32.45it/s]\n", + "100% 136/136 [00:10<00:00, 12.54it/s]\n", + "100% 120/120 [00:03<00:00, 32.13it/s]\n", + "100% 136/136 [00:10<00:00, 12.48it/s]\n", + "100% 120/120 [00:03<00:00, 32.22it/s]\n", + "100% 136/136 [00:10<00:00, 12.51it/s]\n", + "100% 120/120 [00:03<00:00, 32.48it/s]\n", + "100% 136/136 [00:10<00:00, 12.51it/s]\n", + "100% 120/120 [00:03<00:00, 32.35it/s]\n", + "100% 136/136 [00:10<00:00, 12.52it/s]\n", + "100% 120/120 [00:03<00:00, 32.45it/s]\n", + "100% 136/136 [00:10<00:00, 12.54it/s]\n", + "100% 120/120 [00:03<00:00, 32.36it/s]\n", + "100% 136/136 [00:10<00:00, 12.56it/s]\n", + "100% 120/120 [00:03<00:00, 32.46it/s]\n", + "100% 136/136 [00:10<00:00, 12.52it/s]\n", + "100% 120/120 [00:03<00:00, 32.36it/s]\n", + "100% 136/136 [00:10<00:00, 12.55it/s]\n", + "100% 120/120 [00:03<00:00, 32.44it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.49it/s]\n", + "100% 136/136 [00:10<00:00, 12.55it/s]\n", + "100% 120/120 [00:03<00:00, 32.31it/s]\n", + "100% 136/136 [00:10<00:00, 12.55it/s]\n", + "100% 120/120 [00:03<00:00, 32.51it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.25it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.58it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.69it/s]\n", + "100% 136/136 [00:10<00:00, 12.55it/s]\n", + "100% 120/120 [00:03<00:00, 32.51it/s]\n", + "100% 136/136 [00:10<00:00, 12.57it/s]\n", + "100% 120/120 [00:03<00:00, 32.49it/s]\n", + "100% 136/136 [00:10<00:00, 12.57it/s]\n", + "100% 120/120 [00:03<00:00, 32.65it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.50it/s]\n", + "100% 136/136 [00:10<00:00, 12.53it/s]\n", + "100% 120/120 [00:03<00:00, 32.66it/s]\n", + "100% 136/136 [00:10<00:00, 12.52it/s]\n", + "100% 120/120 [00:03<00:00, 32.46it/s]\n", + "model: fastai_lstm\n", + "100% 954/954 [00:26<00:00, 36.67it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm\n", + "100% 120/120 [00:03<00:00, 31.71it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm\n", + "100% 121/121 [00:03<00:00, 31.49it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_lstm_bidir\n", + " 72% 98/136 [00:18<00:07, 5.23it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.82it/s]\n", + "100% 136/136 [00:24<00:00, 5.45it/s]\n", + "100% 120/120 [00:07<00:00, 15.68it/s]\n", + "100% 136/136 [00:25<00:00, 5.39it/s]\n", + "100% 120/120 [00:07<00:00, 15.69it/s]\n", + "100% 136/136 [00:25<00:00, 5.41it/s]\n", + "100% 120/120 [00:07<00:00, 15.81it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.78it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.81it/s]\n", + "100% 136/136 [00:25<00:00, 5.39it/s]\n", + "100% 120/120 [00:07<00:00, 15.83it/s]\n", + "100% 136/136 [00:25<00:00, 5.43it/s]\n", + "100% 120/120 [00:07<00:00, 15.88it/s]\n", + "100% 136/136 [00:24<00:00, 5.45it/s]\n", + "100% 120/120 [00:07<00:00, 15.85it/s]\n", + "100% 136/136 [00:25<00:00, 5.41it/s]\n", + "100% 120/120 [00:07<00:00, 15.81it/s]\n", + "100% 136/136 [00:25<00:00, 5.42it/s]\n", + "100% 120/120 [00:07<00:00, 15.81it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.77it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.82it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.82it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.81it/s]\n", + "100% 136/136 [00:25<00:00, 5.39it/s]\n", + "100% 120/120 [00:07<00:00, 15.81it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.72it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.73it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.75it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.69it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.74it/s]\n", + "100% 136/136 [00:25<00:00, 5.39it/s]\n", + "100% 120/120 [00:07<00:00, 15.71it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.64it/s]\n", + "100% 136/136 [00:25<00:00, 5.36it/s]\n", + "100% 120/120 [00:07<00:00, 15.61it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.69it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.64it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.66it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.69it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.65it/s]\n", + "100% 136/136 [00:25<00:00, 5.41it/s]\n", + "100% 120/120 [00:07<00:00, 15.74it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.64it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.70it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.75it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.70it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.70it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.64it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.73it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.71it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.72it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.71it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.71it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.71it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.71it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.70it/s]\n", + "100% 136/136 [00:25<00:00, 5.39it/s]\n", + "100% 120/120 [00:07<00:00, 15.75it/s]\n", + "100% 136/136 [00:25<00:00, 5.40it/s]\n", + "100% 120/120 [00:07<00:00, 15.74it/s]\n", + "100% 136/136 [00:25<00:00, 5.36it/s]\n", + "100% 120/120 [00:07<00:00, 15.58it/s]\n", + "100% 136/136 [00:25<00:00, 5.38it/s]\n", + "100% 120/120 [00:07<00:00, 15.68it/s]\n", + "100% 136/136 [00:25<00:00, 5.37it/s]\n", + "100% 120/120 [00:07<00:00, 15.62it/s]\n", + "100% 136/136 [00:25<00:00, 5.35it/s]\n", + "100% 120/120 [00:07<00:00, 15.63it/s]\n", + "model: fastai_lstm_bidir\n", + "100% 954/954 [00:57<00:00, 16.55it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm_bidir\n", + "100% 120/120 [00:07<00:00, 15.40it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm_bidir\n", + "100% 121/121 [00:07<00:00, 15.16it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_fcn_wang\n", + " 71% 96/136 [00:21<00:08, 4.55it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 52.21it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 52.79it/s]\n", + "100% 136/136 [00:28<00:00, 4.70it/s]\n", + "100% 120/120 [00:02<00:00, 53.22it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.72it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.03it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.58it/s]\n", + "100% 136/136 [00:28<00:00, 4.70it/s]\n", + "100% 120/120 [00:02<00:00, 53.65it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.14it/s]\n", + "100% 136/136 [00:28<00:00, 4.70it/s]\n", + "100% 120/120 [00:02<00:00, 53.79it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.83it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.50it/s]\n", + "100% 136/136 [00:28<00:00, 4.70it/s]\n", + "100% 120/120 [00:02<00:00, 52.88it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 52.65it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 54.29it/s]\n", + "100% 136/136 [00:28<00:00, 4.70it/s]\n", + "100% 120/120 [00:02<00:00, 53.90it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 54.69it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.59it/s]\n", + "100% 136/136 [00:28<00:00, 4.70it/s]\n", + "100% 120/120 [00:02<00:00, 53.65it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 54.62it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.31it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.72it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.68it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 54.14it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.14it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 52.76it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.48it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 54.36it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.23it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.69it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.97it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 49.46it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 52.70it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.37it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 54.31it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 54.18it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 54.69it/s]\n", + "100% 136/136 [00:28<00:00, 4.71it/s]\n", + "100% 120/120 [00:02<00:00, 53.19it/s]\n", + "100% 136/136 [00:28<00:00, 4.73it/s]\n", + "100% 120/120 [00:02<00:00, 52.75it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 51.64it/s]\n", + "100% 136/136 [00:28<00:00, 4.73it/s]\n", + "100% 120/120 [00:02<00:00, 51.83it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.04it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 52.51it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 52.66it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 51.80it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 54.49it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.52it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.99it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 54.35it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.17it/s]\n", + "100% 136/136 [00:28<00:00, 4.72it/s]\n", + "100% 120/120 [00:02<00:00, 53.37it/s]\n", + "model: fastai_fcn_wang\n", + "100% 954/954 [00:14<00:00, 64.46it/s]\n", + "aggregating predictions...\n", + "model: fastai_fcn_wang\n", + "100% 120/120 [00:02<00:00, 52.97it/s]\n", + "aggregating predictions...\n", + "model: fastai_fcn_wang\n", + "100% 121/121 [00:02<00:00, 52.77it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_inception1d\n", + " 71% 97/136 [00:07<00:02, 13.37it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 136/136 [00:09<00:00, 13.77it/s]\n", + "100% 120/120 [00:04<00:00, 29.29it/s]\n", + "100% 136/136 [00:09<00:00, 13.98it/s]\n", + "100% 120/120 [00:04<00:00, 29.87it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:03<00:00, 30.08it/s]\n", + "100% 136/136 [00:09<00:00, 14.31it/s]\n", + "100% 120/120 [00:03<00:00, 30.14it/s]\n", + "100% 136/136 [00:09<00:00, 14.32it/s]\n", + "100% 120/120 [00:03<00:00, 30.04it/s]\n", + "100% 136/136 [00:09<00:00, 14.25it/s]\n", + "100% 120/120 [00:03<00:00, 30.04it/s]\n", + "100% 136/136 [00:09<00:00, 14.15it/s]\n", + "100% 120/120 [00:04<00:00, 29.79it/s]\n", + "100% 136/136 [00:09<00:00, 14.13it/s]\n", + "100% 120/120 [00:04<00:00, 29.87it/s]\n", + "100% 136/136 [00:09<00:00, 14.17it/s]\n", + "100% 120/120 [00:03<00:00, 30.18it/s]\n", + "100% 136/136 [00:09<00:00, 14.20it/s]\n", + "100% 120/120 [00:03<00:00, 30.01it/s]\n", + "100% 136/136 [00:09<00:00, 14.20it/s]\n", + "100% 120/120 [00:03<00:00, 30.05it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:04<00:00, 29.96it/s]\n", + "100% 136/136 [00:09<00:00, 14.26it/s]\n", + "100% 120/120 [00:04<00:00, 29.99it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:04<00:00, 29.97it/s]\n", + "100% 136/136 [00:09<00:00, 14.21it/s]\n", + "100% 120/120 [00:04<00:00, 29.98it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:03<00:00, 30.04it/s]\n", + "100% 136/136 [00:09<00:00, 14.20it/s]\n", + "100% 120/120 [00:03<00:00, 30.04it/s]\n", + "100% 136/136 [00:09<00:00, 14.19it/s]\n", + "100% 120/120 [00:03<00:00, 30.10it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:03<00:00, 30.25it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:03<00:00, 30.16it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:03<00:00, 30.10it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:03<00:00, 30.12it/s]\n", + "100% 136/136 [00:09<00:00, 14.27it/s]\n", + "100% 120/120 [00:03<00:00, 30.06it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:03<00:00, 30.05it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:04<00:00, 29.97it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:03<00:00, 30.07it/s]\n", + "100% 136/136 [00:09<00:00, 14.20it/s]\n", + "100% 120/120 [00:03<00:00, 30.00it/s]\n", + "100% 136/136 [00:09<00:00, 14.19it/s]\n", + "100% 120/120 [00:04<00:00, 29.96it/s]\n", + "100% 136/136 [00:09<00:00, 14.18it/s]\n", + "100% 120/120 [00:03<00:00, 30.12it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:04<00:00, 29.92it/s]\n", + "100% 136/136 [00:09<00:00, 14.21it/s]\n", + "100% 120/120 [00:03<00:00, 30.11it/s]\n", + "100% 136/136 [00:09<00:00, 14.21it/s]\n", + "100% 120/120 [00:04<00:00, 29.90it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:03<00:00, 30.24it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:04<00:00, 29.98it/s]\n", + "100% 136/136 [00:09<00:00, 14.23it/s]\n", + "100% 120/120 [00:03<00:00, 30.13it/s]\n", + "100% 136/136 [00:09<00:00, 14.20it/s]\n", + "100% 120/120 [00:04<00:00, 29.93it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:03<00:00, 30.07it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:03<00:00, 30.28it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:03<00:00, 30.22it/s]\n", + "100% 136/136 [00:09<00:00, 14.22it/s]\n", + "100% 120/120 [00:03<00:00, 30.24it/s]\n", + "100% 136/136 [00:09<00:00, 14.26it/s]\n", + "100% 120/120 [00:03<00:00, 30.09it/s]\n", + "100% 136/136 [00:09<00:00, 14.20it/s]\n", + "100% 120/120 [00:03<00:00, 30.06it/s]\n", + "100% 136/136 [00:09<00:00, 14.21it/s]\n", + "100% 120/120 [00:04<00:00, 29.99it/s]\n", + "100% 136/136 [00:09<00:00, 14.21it/s]\n", + "100% 120/120 [00:03<00:00, 30.04it/s]\n", + "100% 136/136 [00:09<00:00, 14.21it/s]\n", + "100% 120/120 [00:04<00:00, 29.99it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:03<00:00, 30.19it/s]\n", + "100% 136/136 [00:09<00:00, 14.19it/s]\n", + "100% 120/120 [00:03<00:00, 30.04it/s]\n", + "100% 136/136 [00:09<00:00, 14.26it/s]\n", + "100% 120/120 [00:03<00:00, 30.27it/s]\n", + "100% 136/136 [00:09<00:00, 14.28it/s]\n", + "100% 120/120 [00:03<00:00, 30.12it/s]\n", + "100% 136/136 [00:09<00:00, 14.24it/s]\n", + "100% 120/120 [00:03<00:00, 30.26it/s]\n", + "model: fastai_inception1d\n", + "100% 954/954 [00:28<00:00, 33.74it/s]\n", + "aggregating predictions...\n", + "model: fastai_inception1d\n", + "100% 120/120 [00:04<00:00, 29.34it/s]\n", + "aggregating predictions...\n", + "model: fastai_inception1d\n", + "100% 121/121 [00:04<00:00, 29.37it/s]\n", + "aggregating predictions...\n", + "2022-09-28 08:59:01.369909: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:39] Overriding allow_growth setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n", + "2022-09-28 08:59:01.863160: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 60276096 exceeds 10% of free system memory.\n", + "Epoch 1/30\n", + "122/137 [=========================>....] - ETA: 0s - loss: 0.2488\n", + "Epoch 1: val_loss improved from inf to 0.11387, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 2s 4ms/step - loss: 0.2367 - val_loss: 0.1139\n", + "Epoch 2/30\n", + "125/137 [==========================>...] - ETA: 0s - loss: 0.1139\n", + "Epoch 2: val_loss improved from 0.11387 to 0.09819, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.1133 - val_loss: 0.0982\n", + "Epoch 3/30\n", + "123/137 [=========================>....] - ETA: 0s - loss: 0.1000\n", + "Epoch 3: val_loss improved from 0.09819 to 0.09250, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0997 - val_loss: 0.0925\n", + "Epoch 4/30\n", + "122/137 [=========================>....] - ETA: 0s - loss: 0.0934\n", + "Epoch 4: val_loss improved from 0.09250 to 0.08926, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0931 - val_loss: 0.0893\n", + "Epoch 5/30\n", + "125/137 [==========================>...] - ETA: 0s - loss: 0.0888\n", + "Epoch 5: val_loss improved from 0.08926 to 0.08704, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0886 - val_loss: 0.0870\n", + "Epoch 6/30\n", + "120/137 [=========================>....] - ETA: 0s - loss: 0.0855\n", + "Epoch 6: val_loss improved from 0.08704 to 0.08529, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0854 - val_loss: 0.0853\n", + "Epoch 7/30\n", + "126/137 [==========================>...] - ETA: 0s - loss: 0.0830\n", + "Epoch 7: val_loss improved from 0.08529 to 0.08392, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0829 - val_loss: 0.0839\n", + "Epoch 8/30\n", + "127/137 [==========================>...] - ETA: 0s - loss: 0.0805\n", + "Epoch 8: val_loss improved from 0.08392 to 0.08311, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0805 - val_loss: 0.0831\n", + "Epoch 9/30\n", + "123/137 [=========================>....] - ETA: 0s - loss: 0.0791\n", + "Epoch 9: val_loss improved from 0.08311 to 0.08229, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0788 - val_loss: 0.0823\n", + "Epoch 10/30\n", + "128/137 [===========================>..] - ETA: 0s - loss: 0.0772\n", + "Epoch 10: val_loss improved from 0.08229 to 0.08169, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0772 - val_loss: 0.0817\n", + "Epoch 11/30\n", + "120/137 [=========================>....] - ETA: 0s - loss: 0.0758\n", + "Epoch 11: val_loss improved from 0.08169 to 0.08102, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0759 - val_loss: 0.0810\n", + "Epoch 12/30\n", + "122/137 [=========================>....] - ETA: 0s - loss: 0.0743\n", + "Epoch 12: val_loss improved from 0.08102 to 0.08049, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0744 - val_loss: 0.0805\n", + "Epoch 13/30\n", + "125/137 [==========================>...] - ETA: 0s - loss: 0.0737\n", + "Epoch 13: val_loss improved from 0.08049 to 0.07983, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0736 - val_loss: 0.0798\n", + "Epoch 14/30\n", + "121/137 [=========================>....] - ETA: 0s - loss: 0.0726\n", + "Epoch 14: val_loss improved from 0.07983 to 0.07966, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0725 - val_loss: 0.0797\n", + "Epoch 15/30\n", + "128/137 [===========================>..] - ETA: 0s - loss: 0.0717\n", + "Epoch 15: val_loss improved from 0.07966 to 0.07937, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0717 - val_loss: 0.0794\n", + "Epoch 16/30\n", + "127/137 [==========================>...] - ETA: 0s - loss: 0.0708\n", + "Epoch 16: val_loss improved from 0.07937 to 0.07896, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0708 - val_loss: 0.0790\n", + "Epoch 17/30\n", + "123/137 [=========================>....] - ETA: 0s - loss: 0.0705\n", + "Epoch 17: val_loss did not improve from 0.07896\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0702 - val_loss: 0.0790\n", + "Epoch 18/30\n", + "123/137 [=========================>....] - ETA: 0s - loss: 0.0694\n", + "Epoch 18: val_loss improved from 0.07896 to 0.07853, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0695 - val_loss: 0.0785\n", + "Epoch 19/30\n", + "124/137 [==========================>...] - ETA: 0s - loss: 0.0688\n", + "Epoch 19: val_loss improved from 0.07853 to 0.07849, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0690 - val_loss: 0.0785\n", + "Epoch 20/30\n", + "126/137 [==========================>...] - ETA: 0s - loss: 0.0684\n", + "Epoch 20: val_loss improved from 0.07849 to 0.07834, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0683 - val_loss: 0.0783\n", + "Epoch 21/30\n", + "126/137 [==========================>...] - ETA: 0s - loss: 0.0676\n", + "Epoch 21: val_loss improved from 0.07834 to 0.07815, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0678 - val_loss: 0.0781\n", + "Epoch 22/30\n", + "125/137 [==========================>...] - ETA: 0s - loss: 0.0671\n", + "Epoch 22: val_loss improved from 0.07815 to 0.07785, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0672 - val_loss: 0.0778\n", + "Epoch 23/30\n", + "124/137 [==========================>...] - ETA: 0s - loss: 0.0666\n", + "Epoch 23: val_loss improved from 0.07785 to 0.07782, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0668 - val_loss: 0.0778\n", + "Epoch 24/30\n", + "123/137 [=========================>....] - ETA: 0s - loss: 0.0662\n", + "Epoch 24: val_loss improved from 0.07782 to 0.07780, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0662 - val_loss: 0.0778\n", + "Epoch 25/30\n", + "125/137 [==========================>...] - ETA: 0s - loss: 0.0661\n", + "Epoch 25: val_loss did not improve from 0.07780\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0659 - val_loss: 0.0780\n", + "Epoch 26/30\n", + "125/137 [==========================>...] - ETA: 0s - loss: 0.0654\n", + "Epoch 26: val_loss did not improve from 0.07780\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0655 - val_loss: 0.0778\n", + "Epoch 27/30\n", + "124/137 [==========================>...] - ETA: 0s - loss: 0.0653\n", + "Epoch 27: val_loss improved from 0.07780 to 0.07775, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0650 - val_loss: 0.0777\n", + "Epoch 28/30\n", + "126/137 [==========================>...] - ETA: 0s - loss: 0.0647\n", + "Epoch 28: val_loss improved from 0.07775 to 0.07753, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0647 - val_loss: 0.0775\n", + "Epoch 29/30\n", + "122/137 [=========================>....] - ETA: 0s - loss: 0.0646\n", + "Epoch 29: val_loss did not improve from 0.07753\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0643 - val_loss: 0.0780\n", + "Epoch 30/30\n", + "123/137 [=========================>....] - ETA: 0s - loss: 0.0639\n", + "Epoch 30: val_loss did not improve from 0.07753\n", + "137/137 [==============================] - 0s 3ms/step - loss: 0.0641 - val_loss: 0.0776\n", + "2022-09-28 09:08:24.564168: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 60276096 exceeds 10% of free system memory.\n", + "Wavelet+NN\n", + "ensemble\n", + "fastai_fcn_wang\n", + "fastai_inception1d\n", + "fastai_lstm\n", + "fastai_lstm_bidir\n", + "fastai_resnet1d_wang\n", + "fastai_xresnet1d101\n", + "naive\n", + "tcmalloc: large alloc 2096357376 bytes == 0x10118e000 @ 0x7f16aa0701e7 0x4b2150 0x5ac2ec 0x5e3d6d 0x58ee7f 0x590c9f 0x591039 0x4fb96a 0x4fc108 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6\n", + "tcmalloc: large alloc 2096357376 bytes == 0x17e952000 @ 0x7f16aa0701e7 0x4b2150 0x5ac2ec 0x4fc11a 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", + "Training from scratch...\n", + "model: fastai_xresnet1d101\n", + " 71% 95/133 [00:09<00:03, 9.51it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 133/133 [00:12<00:00, 10.26it/s]\n", + "100% 118/118 [00:04<00:00, 28.56it/s]\n", + "100% 133/133 [00:12<00:00, 10.31it/s]\n", + "100% 118/118 [00:04<00:00, 28.81it/s]\n", + "100% 133/133 [00:12<00:00, 10.26it/s]\n", + "100% 118/118 [00:04<00:00, 28.36it/s]\n", + "100% 133/133 [00:12<00:00, 10.35it/s]\n", + "100% 118/118 [00:03<00:00, 29.63it/s]\n", + "100% 133/133 [00:12<00:00, 10.54it/s]\n", + "100% 118/118 [00:04<00:00, 27.96it/s]\n", + "100% 133/133 [00:12<00:00, 10.36it/s]\n", + "100% 118/118 [00:04<00:00, 28.60it/s]\n", + "100% 133/133 [00:12<00:00, 10.49it/s]\n", + "100% 118/118 [00:04<00:00, 28.92it/s]\n", + "100% 133/133 [00:12<00:00, 10.34it/s]\n", + "100% 118/118 [00:04<00:00, 28.53it/s]\n", + "100% 133/133 [00:13<00:00, 10.12it/s]\n", + "100% 118/118 [00:04<00:00, 28.64it/s]\n", + "100% 133/133 [00:13<00:00, 9.99it/s]\n", + "100% 118/118 [00:04<00:00, 26.34it/s]\n", + "100% 133/133 [00:12<00:00, 10.41it/s]\n", + "100% 118/118 [00:04<00:00, 29.17it/s]\n", + "100% 133/133 [00:12<00:00, 10.36it/s]\n", + "100% 118/118 [00:04<00:00, 29.27it/s]\n", + "100% 133/133 [00:12<00:00, 10.33it/s]\n", + "100% 118/118 [00:04<00:00, 29.29it/s]\n", + "100% 133/133 [00:12<00:00, 10.41it/s]\n", + "100% 118/118 [00:04<00:00, 28.23it/s]\n", + "100% 133/133 [00:12<00:00, 10.54it/s]\n", + "100% 118/118 [00:04<00:00, 29.04it/s]\n", + "100% 133/133 [00:12<00:00, 10.32it/s]\n", + "100% 118/118 [00:04<00:00, 28.52it/s]\n", + "100% 133/133 [00:12<00:00, 10.37it/s]\n", + "100% 118/118 [00:04<00:00, 28.75it/s]\n", + "100% 133/133 [00:12<00:00, 10.48it/s]\n", + "100% 118/118 [00:04<00:00, 28.89it/s]\n", + "100% 133/133 [00:12<00:00, 10.46it/s]\n", + "100% 118/118 [00:04<00:00, 28.20it/s]\n", + "100% 133/133 [00:12<00:00, 10.48it/s]\n", + "100% 118/118 [00:04<00:00, 28.60it/s]\n", + "100% 133/133 [00:13<00:00, 10.23it/s]\n", + "100% 118/118 [00:04<00:00, 29.02it/s]\n", + "100% 133/133 [00:13<00:00, 9.67it/s]\n", + "100% 118/118 [00:04<00:00, 28.83it/s]\n", + "100% 133/133 [00:12<00:00, 10.49it/s]\n", + "100% 118/118 [00:04<00:00, 26.16it/s]\n", + "100% 133/133 [00:12<00:00, 10.37it/s]\n", + "100% 118/118 [00:04<00:00, 28.84it/s]\n", + "100% 133/133 [00:12<00:00, 10.35it/s]\n", + "100% 118/118 [00:04<00:00, 28.25it/s]\n", + "100% 133/133 [00:12<00:00, 10.30it/s]\n", + "100% 118/118 [00:04<00:00, 28.33it/s]\n", + "100% 133/133 [00:13<00:00, 10.22it/s]\n", + "100% 118/118 [00:04<00:00, 28.58it/s]\n", + "100% 133/133 [00:12<00:00, 10.31it/s]\n", + "100% 118/118 [00:04<00:00, 29.16it/s]\n", + "100% 133/133 [00:12<00:00, 10.44it/s]\n", + "100% 118/118 [00:04<00:00, 28.14it/s]\n", + "100% 133/133 [00:12<00:00, 10.37it/s]\n", + "100% 118/118 [00:04<00:00, 28.58it/s]\n", + "100% 133/133 [00:12<00:00, 10.50it/s]\n", + "100% 118/118 [00:03<00:00, 29.51it/s]\n", + "100% 133/133 [00:12<00:00, 10.50it/s]\n", + "100% 118/118 [00:04<00:00, 28.68it/s]\n", + "100% 133/133 [00:13<00:00, 9.72it/s]\n", + "100% 118/118 [00:04<00:00, 28.01it/s]\n", + "100% 133/133 [00:12<00:00, 10.40it/s]\n", + "100% 118/118 [00:04<00:00, 28.33it/s]\n", + "100% 133/133 [00:12<00:00, 10.27it/s]\n", + "100% 118/118 [00:04<00:00, 29.35it/s]\n", + "100% 133/133 [00:12<00:00, 10.49it/s]\n", + "100% 118/118 [00:04<00:00, 28.97it/s]\n", + "100% 133/133 [00:12<00:00, 10.28it/s]\n", + "100% 118/118 [00:04<00:00, 28.57it/s]\n", + "100% 133/133 [00:13<00:00, 10.14it/s]\n", + "100% 118/118 [00:04<00:00, 29.09it/s]\n", + "100% 133/133 [00:12<00:00, 10.58it/s]\n", + "100% 118/118 [00:04<00:00, 28.88it/s]\n", + "100% 133/133 [00:12<00:00, 10.41it/s]\n", + "100% 118/118 [00:04<00:00, 28.51it/s]\n", + "100% 133/133 [00:12<00:00, 10.39it/s]\n", + "100% 118/118 [00:04<00:00, 28.89it/s]\n", + "100% 133/133 [00:12<00:00, 10.37it/s]\n", + "100% 118/118 [00:04<00:00, 28.93it/s]\n", + "100% 133/133 [00:12<00:00, 10.59it/s]\n", + "100% 118/118 [00:04<00:00, 29.11it/s]\n", + "100% 133/133 [00:12<00:00, 10.36it/s]\n", + "100% 118/118 [00:04<00:00, 24.48it/s]\n", + "100% 133/133 [00:13<00:00, 10.09it/s]\n", + "100% 118/118 [00:04<00:00, 28.31it/s]\n", + "100% 133/133 [00:12<00:00, 10.46it/s]\n", + "100% 118/118 [00:04<00:00, 28.99it/s]\n", + "100% 133/133 [00:12<00:00, 10.27it/s]\n", + "100% 118/118 [00:04<00:00, 28.74it/s]\n", + "100% 133/133 [00:12<00:00, 10.39it/s]\n", + "100% 118/118 [00:04<00:00, 27.77it/s]\n", + "100% 133/133 [00:12<00:00, 10.33it/s]\n", + "100% 118/118 [00:04<00:00, 28.30it/s]\n", + "100% 133/133 [00:12<00:00, 10.39it/s]\n", + "100% 118/118 [00:04<00:00, 28.00it/s]\n", + "model: fastai_xresnet1d101\n", + "100% 936/936 [00:26<00:00, 35.21it/s]\n", + "aggregating predictions...\n", + "model: fastai_xresnet1d101\n", + "100% 118/118 [00:04<00:00, 28.47it/s]\n", + "aggregating predictions...\n", + "model: fastai_xresnet1d101\n", + "100% 119/119 [00:04<00:00, 29.14it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_resnet1d_wang\n", + " 73% 97/133 [00:22<00:08, 4.29it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.28it/s]\n", + "100% 133/133 [00:29<00:00, 4.52it/s]\n", + "100% 118/118 [00:02<00:00, 43.48it/s]\n", + "100% 133/133 [00:29<00:00, 4.48it/s]\n", + "100% 118/118 [00:02<00:00, 44.09it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.32it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.33it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.87it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 44.11it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.18it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.63it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.94it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.79it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.45it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.75it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.94it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.17it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.36it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.30it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.98it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.10it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.72it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.02it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.29it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.17it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.84it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.38it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.48it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.00it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.79it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.35it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 42.91it/s]\n", + "100% 133/133 [00:29<00:00, 4.48it/s]\n", + "100% 118/118 [00:02<00:00, 43.92it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.45it/s]\n", + "100% 133/133 [00:29<00:00, 4.48it/s]\n", + "100% 118/118 [00:02<00:00, 39.40it/s]\n", + "100% 133/133 [00:29<00:00, 4.48it/s]\n", + "100% 118/118 [00:02<00:00, 42.99it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.10it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.89it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.47it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.07it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:03<00:00, 36.03it/s]\n", + "100% 133/133 [00:29<00:00, 4.48it/s]\n", + "100% 118/118 [00:02<00:00, 42.70it/s]\n", + "100% 133/133 [00:29<00:00, 4.48it/s]\n", + "100% 118/118 [00:02<00:00, 43.27it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.90it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 42.58it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 43.57it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 40.17it/s]\n", + "100% 133/133 [00:29<00:00, 4.50it/s]\n", + "100% 118/118 [00:02<00:00, 43.80it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 44.02it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 40.00it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 42.47it/s]\n", + "100% 133/133 [00:29<00:00, 4.49it/s]\n", + "100% 118/118 [00:02<00:00, 40.60it/s]\n", + "model: fastai_resnet1d_wang\n", + "100% 936/936 [00:16<00:00, 58.03it/s]\n", + "aggregating predictions...\n", + "model: fastai_resnet1d_wang\n", + "100% 118/118 [00:03<00:00, 39.33it/s]\n", + "aggregating predictions...\n", + "model: fastai_resnet1d_wang\n", + "100% 119/119 [00:03<00:00, 39.20it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_lstm\n", + " 74% 99/133 [00:08<00:03, 11.25it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 133/133 [00:11<00:00, 11.49it/s]\n", + "100% 118/118 [00:04<00:00, 28.04it/s]\n", + "100% 133/133 [00:11<00:00, 11.85it/s]\n", + "100% 118/118 [00:04<00:00, 28.37it/s]\n", + "100% 133/133 [00:11<00:00, 12.06it/s]\n", + "100% 118/118 [00:04<00:00, 28.82it/s]\n", + "100% 133/133 [00:11<00:00, 12.05it/s]\n", + "100% 118/118 [00:04<00:00, 26.70it/s]\n", + "100% 133/133 [00:11<00:00, 11.95it/s]\n", + "100% 118/118 [00:04<00:00, 28.41it/s]\n", + "100% 133/133 [00:11<00:00, 11.88it/s]\n", + "100% 118/118 [00:04<00:00, 28.04it/s]\n", + "100% 133/133 [00:11<00:00, 11.89it/s]\n", + "100% 118/118 [00:04<00:00, 27.97it/s]\n", + "100% 133/133 [00:11<00:00, 11.90it/s]\n", + "100% 118/118 [00:04<00:00, 28.39it/s]\n", + "100% 133/133 [00:11<00:00, 12.00it/s]\n", + "100% 118/118 [00:04<00:00, 28.19it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.45it/s]\n", + "100% 133/133 [00:11<00:00, 12.00it/s]\n", + "100% 118/118 [00:04<00:00, 28.21it/s]\n", + "100% 133/133 [00:11<00:00, 11.90it/s]\n", + "100% 118/118 [00:04<00:00, 28.15it/s]\n", + "100% 133/133 [00:11<00:00, 11.93it/s]\n", + "100% 118/118 [00:04<00:00, 28.28it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.59it/s]\n", + "100% 133/133 [00:11<00:00, 11.97it/s]\n", + "100% 118/118 [00:04<00:00, 28.54it/s]\n", + "100% 133/133 [00:11<00:00, 11.95it/s]\n", + "100% 118/118 [00:04<00:00, 28.73it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.49it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.57it/s]\n", + "100% 133/133 [00:11<00:00, 11.99it/s]\n", + "100% 118/118 [00:04<00:00, 28.71it/s]\n", + "100% 133/133 [00:11<00:00, 11.97it/s]\n", + "100% 118/118 [00:04<00:00, 28.62it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.67it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.76it/s]\n", + "100% 133/133 [00:11<00:00, 11.97it/s]\n", + "100% 118/118 [00:04<00:00, 28.46it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.48it/s]\n", + "100% 133/133 [00:11<00:00, 12.00it/s]\n", + "100% 118/118 [00:04<00:00, 28.64it/s]\n", + "100% 133/133 [00:11<00:00, 11.95it/s]\n", + "100% 118/118 [00:04<00:00, 28.41it/s]\n", + "100% 133/133 [00:11<00:00, 11.99it/s]\n", + "100% 118/118 [00:04<00:00, 28.48it/s]\n", + "100% 133/133 [00:11<00:00, 11.99it/s]\n", + "100% 118/118 [00:04<00:00, 28.33it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.59it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.50it/s]\n", + "100% 133/133 [00:11<00:00, 11.99it/s]\n", + "100% 118/118 [00:04<00:00, 28.51it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.59it/s]\n", + "100% 133/133 [00:11<00:00, 11.95it/s]\n", + "100% 118/118 [00:04<00:00, 28.61it/s]\n", + "100% 133/133 [00:11<00:00, 11.97it/s]\n", + "100% 118/118 [00:04<00:00, 28.67it/s]\n", + "100% 133/133 [00:11<00:00, 11.97it/s]\n", + "100% 118/118 [00:04<00:00, 28.82it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.68it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.38it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.61it/s]\n", + "100% 133/133 [00:11<00:00, 12.06it/s]\n", + "100% 118/118 [00:04<00:00, 28.61it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.37it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.46it/s]\n", + "100% 133/133 [00:11<00:00, 11.93it/s]\n", + "100% 118/118 [00:04<00:00, 28.73it/s]\n", + "100% 133/133 [00:11<00:00, 11.96it/s]\n", + "100% 118/118 [00:04<00:00, 28.62it/s]\n", + "100% 133/133 [00:11<00:00, 12.00it/s]\n", + "100% 118/118 [00:04<00:00, 28.59it/s]\n", + "100% 133/133 [00:11<00:00, 11.98it/s]\n", + "100% 118/118 [00:04<00:00, 28.35it/s]\n", + "100% 133/133 [00:11<00:00, 12.03it/s]\n", + "100% 118/118 [00:04<00:00, 28.47it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.58it/s]\n", + "100% 133/133 [00:11<00:00, 12.00it/s]\n", + "100% 118/118 [00:04<00:00, 28.53it/s]\n", + "100% 133/133 [00:11<00:00, 12.01it/s]\n", + "100% 118/118 [00:04<00:00, 28.61it/s]\n", + "100% 133/133 [00:11<00:00, 12.00it/s]\n", + "100% 118/118 [00:04<00:00, 28.79it/s]\n", + "model: fastai_lstm\n", + "100% 936/936 [00:26<00:00, 35.88it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm\n", + "100% 118/118 [00:04<00:00, 28.35it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm\n", + "100% 119/119 [00:04<00:00, 28.30it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_lstm_bidir\n", + " 74% 99/133 [00:19<00:06, 5.13it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.87it/s]\n", + "100% 133/133 [00:24<00:00, 5.35it/s]\n", + "100% 118/118 [00:08<00:00, 14.73it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.65it/s]\n", + "100% 133/133 [00:25<00:00, 5.31it/s]\n", + "100% 118/118 [00:07<00:00, 14.89it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.78it/s]\n", + "100% 133/133 [00:25<00:00, 5.27it/s]\n", + "100% 118/118 [00:07<00:00, 14.79it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.79it/s]\n", + "100% 133/133 [00:25<00:00, 5.31it/s]\n", + "100% 118/118 [00:07<00:00, 14.81it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.88it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.80it/s]\n", + "100% 133/133 [00:25<00:00, 5.30it/s]\n", + "100% 118/118 [00:07<00:00, 14.76it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.78it/s]\n", + "100% 133/133 [00:25<00:00, 5.30it/s]\n", + "100% 118/118 [00:07<00:00, 14.83it/s]\n", + "100% 133/133 [00:25<00:00, 5.30it/s]\n", + "100% 118/118 [00:07<00:00, 14.76it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.74it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.82it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.80it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:08<00:00, 14.74it/s]\n", + "100% 133/133 [00:25<00:00, 5.30it/s]\n", + "100% 118/118 [00:08<00:00, 14.74it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.81it/s]\n", + "100% 133/133 [00:25<00:00, 5.30it/s]\n", + "100% 118/118 [00:07<00:00, 14.88it/s]\n", + "100% 133/133 [00:25<00:00, 5.27it/s]\n", + "100% 118/118 [00:07<00:00, 14.76it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.78it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.81it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.81it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.78it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.79it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.76it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.82it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.73it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.77it/s]\n", + "100% 133/133 [00:25<00:00, 5.27it/s]\n", + "100% 118/118 [00:07<00:00, 14.82it/s]\n", + "100% 133/133 [00:25<00:00, 5.26it/s]\n", + "100% 118/118 [00:07<00:00, 14.76it/s]\n", + "100% 133/133 [00:25<00:00, 5.27it/s]\n", + "100% 118/118 [00:08<00:00, 14.73it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.80it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.72it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.70it/s]\n", + "100% 133/133 [00:25<00:00, 5.29it/s]\n", + "100% 118/118 [00:07<00:00, 14.77it/s]\n", + "100% 133/133 [00:25<00:00, 5.30it/s]\n", + "100% 118/118 [00:07<00:00, 14.87it/s]\n", + "100% 133/133 [00:25<00:00, 5.27it/s]\n", + "100% 118/118 [00:07<00:00, 14.79it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.64it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.73it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.78it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.71it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.75it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.76it/s]\n", + "100% 133/133 [00:25<00:00, 5.27it/s]\n", + "100% 118/118 [00:07<00:00, 14.77it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:08<00:00, 14.73it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.80it/s]\n", + "100% 133/133 [00:25<00:00, 5.28it/s]\n", + "100% 118/118 [00:07<00:00, 14.77it/s]\n", + "model: fastai_lstm_bidir\n", + "100% 936/936 [00:56<00:00, 16.45it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm_bidir\n", + "100% 118/118 [00:08<00:00, 14.69it/s]\n", + "aggregating predictions...\n", + "model: fastai_lstm_bidir\n", + "100% 119/119 [00:08<00:00, 14.39it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_fcn_wang\n", + " 73% 97/133 [00:21<00:08, 4.47it/s]\n", + "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", + "100% 133/133 [00:28<00:00, 4.65it/s]\n", + "100% 118/118 [00:02<00:00, 43.58it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.49it/s]\n", + "100% 133/133 [00:28<00:00, 4.62it/s]\n", + "100% 118/118 [00:02<00:00, 44.56it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.09it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.73it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.72it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.87it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.11it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.59it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.85it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.50it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 43.96it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.69it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.47it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 43.55it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.77it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.77it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.46it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.93it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.60it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 43.56it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.21it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.15it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.92it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.24it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.53it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.03it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.34it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.68it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.44it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.02it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.88it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.09it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.88it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.16it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.82it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.63it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.63it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 43.72it/s]\n", + "100% 133/133 [00:28<00:00, 4.65it/s]\n", + "100% 118/118 [00:02<00:00, 43.33it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 43.02it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 43.20it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.85it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 42.68it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 44.21it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 43.75it/s]\n", + "100% 133/133 [00:28<00:00, 4.64it/s]\n", + "100% 118/118 [00:02<00:00, 44.32it/s]\n", + "100% 133/133 [00:28<00:00, 4.63it/s]\n", + "100% 118/118 [00:02<00:00, 45.10it/s]\n", + "100% 133/133 [00:28<00:00, 4.65it/s]\n", + "100% 118/118 [00:02<00:00, 42.85it/s]\n", + "100% 133/133 [00:28<00:00, 4.65it/s]\n", + "100% 118/118 [00:02<00:00, 43.57it/s]\n", + "model: fastai_fcn_wang\n", + "100% 936/936 [00:15<00:00, 61.09it/s]\n", + "aggregating predictions...\n", + "model: fastai_fcn_wang\n", + "100% 118/118 [00:02<00:00, 43.08it/s]\n", + "aggregating predictions...\n", + "model: fastai_fcn_wang\n", + "100% 119/119 [00:02<00:00, 44.31it/s]\n", + "aggregating predictions...\n", + "Training from scratch...\n", + "model: fastai_inception1d\n", + " 74% 98/133 [00:07<00:02, 12.72it/s]\n", "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:15<00:00, 8.68it/s]\n", - "100% 120/120 [00:03<00:00, 30.82it/s]\n", - " 18% 25/136 [00:03<00:14, 7.45it/s]\n", - "Traceback (most recent call last):\n", - " File \"/content/github_repo/code/reproduce_results.py\", line 59, in \n", - " main()\n", - " File \"/content/github_repo/code/reproduce_results.py\", line 40, in main\n", - " e.perform()\n", - " File \"/content/github_repo/code/experiments/scp_experiment.py\", line 112, in perform\n", - " model.fit(self.X_train, self.y_train, self.X_val, self.y_val)\n", - " File \"/content/github_repo/code/models/fastai_model.py\", line 236, in fit\n", - " learn.fit_one_cycle(self.epochs,self.lr)#slice(self.lr) if self.discriminative_lrs else self.lr)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/train.py\", line 23, in fit_one_cycle\n", - " learn.fit(cyc_len, max_lr, wd=wd, callbacks=callbacks)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 203, in fit\n", - " fit(epochs, self, metrics=self.metrics, callbacks=self.callbacks+callbacks)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 104, in fit\n", - " loss = loss_batch(learn.model, xb, yb, learn.loss_func, learn.opt, cb_handler)\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/basic_train.py\", line 36, in loss_batch\n", - " if not cb_handler.on_backward_end(): opt.step()\n", - " File \"/usr/local/lib/python3.7/dist-packages/fastai/callback.py\", line 57, in step\n", - " self.opt.step()\n", - " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/optimizer.py\", line 113, in wrapper\n", - " return func(*args, **kwargs)\n", - " File \"/usr/local/lib/python3.7/dist-packages/torch/autograd/grad_mode.py\", line 27, in decorate_context\n", - " return func(*args, **kwargs)\n", - " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\", line 171, in step\n", - " capturable=group['capturable'])\n", - " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\", line 226, in adam\n", - " capturable=capturable)\n", - " File \"/usr/local/lib/python3.7/dist-packages/torch/optim/adam.py\", line 305, in _single_tensor_adam\n", - " denom = (exp_avg_sq.sqrt() / bias_correction2_sqrt).add_(eps)\n", - "KeyboardInterrupt\n", - "^C\n" + "100% 133/133 [00:10<00:00, 13.19it/s]\n", + "100% 118/118 [00:04<00:00, 26.66it/s]\n", + "100% 133/133 [00:09<00:00, 13.37it/s]\n", + "100% 118/118 [00:04<00:00, 26.97it/s]\n", + "100% 133/133 [00:09<00:00, 13.56it/s]\n", + "100% 118/118 [00:04<00:00, 27.31it/s]\n", + "100% 133/133 [00:09<00:00, 13.71it/s]\n", + "100% 118/118 [00:04<00:00, 27.15it/s]\n", + "100% 133/133 [00:09<00:00, 13.60it/s]\n", + "100% 118/118 [00:04<00:00, 26.99it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 26.89it/s]\n", + "100% 133/133 [00:09<00:00, 13.49it/s]\n", + "100% 118/118 [00:04<00:00, 26.86it/s]\n", + "100% 133/133 [00:09<00:00, 13.46it/s]\n", + "100% 118/118 [00:04<00:00, 26.95it/s]\n", + "100% 133/133 [00:09<00:00, 13.54it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.63it/s]\n", + "100% 118/118 [00:04<00:00, 26.95it/s]\n", + "100% 133/133 [00:09<00:00, 13.54it/s]\n", + "100% 118/118 [00:04<00:00, 26.89it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 27.12it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 27.03it/s]\n", + "100% 133/133 [00:09<00:00, 13.58it/s]\n", + "100% 118/118 [00:04<00:00, 27.18it/s]\n", + "100% 133/133 [00:09<00:00, 13.57it/s]\n", + "100% 118/118 [00:04<00:00, 26.90it/s]\n", + "100% 133/133 [00:09<00:00, 13.50it/s]\n", + "100% 118/118 [00:04<00:00, 26.91it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.08it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.52it/s]\n", + "100% 118/118 [00:04<00:00, 27.23it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.08it/s]\n", + "100% 133/133 [00:09<00:00, 13.54it/s]\n", + "100% 118/118 [00:04<00:00, 27.21it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 26.87it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 27.04it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 27.10it/s]\n", + "100% 133/133 [00:09<00:00, 13.56it/s]\n", + "100% 118/118 [00:04<00:00, 27.23it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.22it/s]\n", + "100% 133/133 [00:09<00:00, 13.57it/s]\n", + "100% 118/118 [00:04<00:00, 26.89it/s]\n", + "100% 133/133 [00:09<00:00, 13.54it/s]\n", + "100% 118/118 [00:04<00:00, 27.16it/s]\n", + "100% 133/133 [00:09<00:00, 13.57it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 26.94it/s]\n", + "100% 133/133 [00:09<00:00, 13.56it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.32it/s]\n", + "100% 133/133 [00:09<00:00, 13.57it/s]\n", + "100% 118/118 [00:04<00:00, 26.98it/s]\n", + "100% 133/133 [00:09<00:00, 13.57it/s]\n", + "100% 118/118 [00:04<00:00, 27.10it/s]\n", + "100% 133/133 [00:09<00:00, 13.58it/s]\n", + "100% 118/118 [00:04<00:00, 26.98it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 26.94it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.60it/s]\n", + "100% 118/118 [00:04<00:00, 27.24it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.56it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.52it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 26.93it/s]\n", + "100% 133/133 [00:09<00:00, 13.54it/s]\n", + "100% 118/118 [00:04<00:00, 27.15it/s]\n", + "100% 133/133 [00:09<00:00, 13.58it/s]\n", + "100% 118/118 [00:04<00:00, 27.09it/s]\n", + "100% 133/133 [00:09<00:00, 13.57it/s]\n", + "100% 118/118 [00:04<00:00, 27.29it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.07it/s]\n", + "100% 133/133 [00:09<00:00, 13.56it/s]\n", + "100% 118/118 [00:04<00:00, 27.04it/s]\n", + "100% 133/133 [00:09<00:00, 13.59it/s]\n", + "100% 118/118 [00:04<00:00, 27.05it/s]\n", + "100% 133/133 [00:09<00:00, 13.54it/s]\n", + "100% 118/118 [00:04<00:00, 27.11it/s]\n", + "100% 133/133 [00:09<00:00, 13.55it/s]\n", + "100% 118/118 [00:04<00:00, 27.09it/s]\n", + "model: fastai_inception1d\n", + "100% 936/936 [00:28<00:00, 33.14it/s]\n", + "aggregating predictions...\n", + "model: fastai_inception1d\n", + "100% 118/118 [00:04<00:00, 26.32it/s]\n", + "aggregating predictions...\n", + "model: fastai_inception1d\n", + "100% 119/119 [00:04<00:00, 26.28it/s]\n", + "aggregating predictions...\n", + "2022-09-28 11:38:28.361399: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 59135616 exceeds 10% of free system memory.\n", + "Epoch 1/30\n", + "134/134 [==============================] - ETA: 0s - loss: 0.2110\n", + "Epoch 1: val_loss improved from inf to 0.10371, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 1s 4ms/step - loss: 0.2110 - val_loss: 0.1037\n", + "Epoch 2/30\n", + "125/134 [==========================>...] - ETA: 0s - loss: 0.1069\n", + "Epoch 2: val_loss improved from 0.10371 to 0.09109, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.1065 - val_loss: 0.0911\n", + "Epoch 3/30\n", + "125/134 [==========================>...] - ETA: 0s - loss: 0.0943\n", + "Epoch 3: val_loss improved from 0.09109 to 0.08612, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0942 - val_loss: 0.0861\n", + "Epoch 4/30\n", + "126/134 [===========================>..] - ETA: 0s - loss: 0.0878\n", + "Epoch 4: val_loss improved from 0.08612 to 0.08316, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0875 - val_loss: 0.0832\n", + "Epoch 5/30\n", + "122/134 [==========================>...] - ETA: 0s - loss: 0.0836\n", + "Epoch 5: val_loss improved from 0.08316 to 0.08116, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0834 - val_loss: 0.0812\n", + "Epoch 6/30\n", + "123/134 [==========================>...] - ETA: 0s - loss: 0.0799\n", + "Epoch 6: val_loss improved from 0.08116 to 0.07985, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0800 - val_loss: 0.0798\n", + "Epoch 7/30\n", + "122/134 [==========================>...] - ETA: 0s - loss: 0.0778\n", + "Epoch 7: val_loss improved from 0.07985 to 0.07853, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0777 - val_loss: 0.0785\n", + "Epoch 8/30\n", + "124/134 [==========================>...] - ETA: 0s - loss: 0.0753\n", + "Epoch 8: val_loss improved from 0.07853 to 0.07768, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0754 - val_loss: 0.0777\n", + "Epoch 9/30\n", + "124/134 [==========================>...] - ETA: 0s - loss: 0.0734\n", + "Epoch 9: val_loss improved from 0.07768 to 0.07687, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0735 - val_loss: 0.0769\n", + "Epoch 10/30\n", + "117/134 [=========================>....] - ETA: 0s - loss: 0.0720\n", + "Epoch 10: val_loss improved from 0.07687 to 0.07677, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0718 - val_loss: 0.0768\n", + "Epoch 11/30\n", + "119/134 [=========================>....] - ETA: 0s - loss: 0.0704\n", + "Epoch 11: val_loss improved from 0.07677 to 0.07592, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0705 - val_loss: 0.0759\n", + "Epoch 12/30\n", + "126/134 [===========================>..] - ETA: 0s - loss: 0.0691\n", + "Epoch 12: val_loss improved from 0.07592 to 0.07529, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0691 - val_loss: 0.0753\n", + "Epoch 13/30\n", + "120/134 [=========================>....] - ETA: 0s - loss: 0.0681\n", + "Epoch 13: val_loss did not improve from 0.07529\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0681 - val_loss: 0.0755\n", + "Epoch 14/30\n", + "123/134 [==========================>...] - ETA: 0s - loss: 0.0671\n", + "Epoch 14: val_loss improved from 0.07529 to 0.07491, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0672 - val_loss: 0.0749\n", + "Epoch 15/30\n", + "119/134 [=========================>....] - ETA: 0s - loss: 0.0664\n", + "Epoch 15: val_loss improved from 0.07491 to 0.07460, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0662 - val_loss: 0.0746\n", + "Epoch 16/30\n", + "125/134 [==========================>...] - ETA: 0s - loss: 0.0652\n", + "Epoch 16: val_loss improved from 0.07460 to 0.07441, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0652 - val_loss: 0.0744\n", + "Epoch 17/30\n", + "119/134 [=========================>....] - ETA: 0s - loss: 0.0641\n", + "Epoch 17: val_loss improved from 0.07441 to 0.07425, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0644 - val_loss: 0.0742\n", + "Epoch 18/30\n", + "121/134 [==========================>...] - ETA: 0s - loss: 0.0636\n", + "Epoch 18: val_loss improved from 0.07425 to 0.07413, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0639 - val_loss: 0.0741\n", + "Epoch 19/30\n", + "123/134 [==========================>...] - ETA: 0s - loss: 0.0633\n", + "Epoch 19: val_loss did not improve from 0.07413\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0633 - val_loss: 0.0742\n", + "Epoch 20/30\n", + "121/134 [==========================>...] - ETA: 0s - loss: 0.0627\n", + "Epoch 20: val_loss improved from 0.07413 to 0.07383, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0628 - val_loss: 0.0738\n", + "Epoch 21/30\n", + "126/134 [===========================>..] - ETA: 0s - loss: 0.0620\n", + "Epoch 21: val_loss improved from 0.07383 to 0.07378, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0619 - val_loss: 0.0738\n", + "Epoch 22/30\n", + "123/134 [==========================>...] - ETA: 0s - loss: 0.0619\n", + "Epoch 22: val_loss did not improve from 0.07378\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0617 - val_loss: 0.0739\n", + "Epoch 23/30\n", + "121/134 [==========================>...] - ETA: 0s - loss: 0.0614\n", + "Epoch 23: val_loss did not improve from 0.07378\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0610 - val_loss: 0.0739\n", + "Epoch 24/30\n", + "114/134 [========================>.....] - ETA: 0s - loss: 0.0607\n", + "Epoch 24: val_loss did not improve from 0.07378\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0606 - val_loss: 0.0741\n", + "Epoch 25/30\n", + "123/134 [==========================>...] - ETA: 0s - loss: 0.0602\n", + "Epoch 25: val_loss did not improve from 0.07378\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0601 - val_loss: 0.0739\n", + "Epoch 26/30\n", + "124/134 [==========================>...] - ETA: 0s - loss: 0.0599\n", + "Epoch 26: val_loss improved from 0.07378 to 0.07366, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0598 - val_loss: 0.0737\n", + "Epoch 27/30\n", + "124/134 [==========================>...] - ETA: 0s - loss: 0.0594\n", + "Epoch 27: val_loss did not improve from 0.07366\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0593 - val_loss: 0.0737\n", + "Epoch 28/30\n", + "118/134 [=========================>....] - ETA: 0s - loss: 0.0588\n", + "Epoch 28: val_loss did not improve from 0.07366\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0590 - val_loss: 0.0737\n", + "Epoch 29/30\n", + "124/134 [==========================>...] - ETA: 0s - loss: 0.0580\n", + "Epoch 29: val_loss did not improve from 0.07366\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0582 - val_loss: 0.0739\n", + "Epoch 30/30\n", + "122/134 [==========================>...] - ETA: 0s - loss: 0.0578\n", + "Epoch 30: val_loss did not improve from 0.07366\n", + "134/134 [==============================] - 0s 3ms/step - loss: 0.0579 - val_loss: 0.0740\n", + "2022-09-28 11:47:43.228052: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 59135616 exceeds 10% of free system memory.\n", + "Wavelet+NN\n", + "ensemble\n", + "fastai_fcn_wang\n", + "fastai_inception1d\n", + "fastai_lstm\n", + "fastai_lstm_bidir\n", + "fastai_resnet1d_wang\n", + "fastai_xresnet1d101\n", + "naive\n", + "Process ForkPoolWorker-5351:\n", + "Process ForkPoolWorker-5539:\n", + "Process ForkPoolWorker-5537:\n", + "Process ForkPoolWorker-5536:\n", + "Process ForkPoolWorker-5345:\n", + "Process ForkPoolWorker-5307:\n", + "Process ForkPoolWorker-5533:\n", + "Process ForkPoolWorker-5535:\n", + "Process ForkPoolWorker-5344:\n", + "Process ForkPoolWorker-5303:\n", + "Process ForkPoolWorker-5352:\n", + "Process ForkPoolWorker-5534:\n", + "Process ForkPoolWorker-5335:\n", + "Process ForkPoolWorker-5342:\n", + "Process ForkPoolWorker-5330:\n", + "Process ForkPoolWorker-5302:\n", + "Process ForkPoolWorker-5350:\n", + "Process ForkPoolWorker-5340:\n", + "Process ForkPoolWorker-5328:\n", + "Process ForkPoolWorker-5349:\n", + "Process ForkPoolWorker-5331:\n", + "Process ForkPoolWorker-5301:\n", + "Process ForkPoolWorker-5319:\n", + "Process ForkPoolWorker-5322:\n", + "Process ForkPoolWorker-5348:\n", + "Process ForkPoolWorker-5313:\n", + "Process ForkPoolWorker-5318:\n", + "Process ForkPoolWorker-5310:\n", + "Process ForkPoolWorker-5347:\n", + "Process ForkPoolWorker-5297:\n", + "Process ForkPoolWorker-5314:\n", + "Process ForkPoolWorker-5291:\n", + "Process ForkPoolWorker-5287:\n", + "Process ForkPoolWorker-5346:\n", + "Process ForkPoolWorker-5308:\n", + "Process ForkPoolWorker-5294:\n", + "Process ForkPoolWorker-2581:\n", + "Process ForkPoolWorker-5343:\n", + "Process ForkPoolWorker-5306:\n", + "Process ForkPoolWorker-5290:\n", + "Process ForkPoolWorker-2565:\n", + "Process ForkPoolWorker-5341:\n", + "Process ForkPoolWorker-5285:\n", + "Process ForkPoolWorker-5304:\n", + "Process ForkPoolWorker-2551:\n", + "Process ForkPoolWorker-5339:\n", + "Process ForkPoolWorker-2528:\n", + "Process ForkPoolWorker-5276:\n", + "Process ForkPoolWorker-5300:\n", + "Process ForkPoolWorker-2521:\n", + "Process ForkPoolWorker-5338:\n", + "Process ForkPoolWorker-2584:\n", + "Process ForkPoolWorker-5295:\n", + "Process ForkPoolWorker-2499:\n", + "Process ForkPoolWorker-5337:\n", + "Process ForkPoolWorker-2579:\n", + "Process ForkPoolWorker-5292:\n", + "Process ForkPoolWorker-5280:\n", + "Process ForkPoolWorker-5336:\n", + "Process ForkPoolWorker-2585:\n", + "Process ForkPoolWorker-2577:\n", + "Process ForkPoolWorker-5289:\n", + "Process ForkPoolWorker-5541:\n", + "Process ForkPoolWorker-5334:\n", + "Process ForkPoolWorker-2552:\n", + "Process ForkPoolWorker-2573:\n", + "Process ForkPoolWorker-5288:\n", + "Process ForkPoolWorker-2527:\n", + "Process ForkPoolWorker-5333:\n", + "Process ForkPoolWorker-2519:\n", + "Process ForkPoolWorker-2569:\n", + "Process ForkPoolWorker-5286:\n", + "Process ForkPoolWorker-5540:\n", + "Process ForkPoolWorker-2529:\n", + "Process ForkPoolWorker-5321:\n", + "Process ForkPoolWorker-5299:\n", + "Process ForkPoolWorker-2502:\n", + "Process ForkPoolWorker-5296:\n", + "Process ForkPoolWorker-2578:\n", + "Process ForkPoolWorker-5309:\n", + "Process ForkPoolWorker-2511:\n", + "Process ForkPoolWorker-2559:\n", + "Process ForkPoolWorker-2570:\n", + "Process ForkPoolWorker-2498:\n", + "Process ForkPoolWorker-5327:\n", + "Process ForkPoolWorker-5332:\n", + "Process ForkPoolWorker-2556:\n", + "Process ForkPoolWorker-5542:\n", + "Process ForkPoolWorker-2518:\n", + "Process ForkPoolWorker-5281:\n", + "Process ForkPoolWorker-5311:\n", + "Process ForkPoolWorker-5329:\n", + "Process ForkPoolWorker-2516:\n", + "Process ForkPoolWorker-5279:\n", + "Process ForkPoolWorker-2558:\n", + "Process ForkPoolWorker-5326:\n", + "Process ForkPoolWorker-2571:\n", + "Process ForkPoolWorker-2515:\n", + "Process ForkPoolWorker-5274:\n", + "Process ForkPoolWorker-5325:\n", + "Process ForkPoolWorker-2503:\n", + "Process ForkPoolWorker-5323:\n", + "Process ForkPoolWorker-2583:\n", + "Process ForkPoolWorker-2582:\n", + "Process ForkPoolWorker-2501:\n", + "Process ForkPoolWorker-5320:\n", + "Process ForkPoolWorker-2560:\n", + "Process ForkPoolWorker-5538:\n", + "Process ForkPoolWorker-2553:\n", + "Process ForkPoolWorker-5317:\n", + "Process ForkPoolWorker-5543:\n", + "Process ForkPoolWorker-2509:\n", + "Process ForkPoolWorker-5316:\n", + "Process ForkPoolWorker-2505:\n", + "Process ForkPoolWorker-2566:\n", + "Process ForkPoolWorker-2500:\n", + "Process ForkPoolWorker-2506:\n", + "Process ForkPoolWorker-2504:\n", + "Process ForkPoolWorker-2497:\n", + "Process ForkPoolWorker-2557:\n", + "Process ForkPoolWorker-2572:\n", + "Process ForkPoolWorker-5315:\n", + "Process ForkPoolWorker-2531:\n", + "Process ForkPoolWorker-2567:\n", + "Process ForkPoolWorker-5265:\n", + "Process ForkPoolWorker-5264:\n", + "Process ForkPoolWorker-2512:\n", + "Process ForkPoolWorker-5312:\n", + "Process ForkPoolWorker-5324:\n", + "Process ForkPoolWorker-5267:\n", + "Process ForkPoolWorker-5283:\n", + "Process ForkPoolWorker-5270:\n", + "Process ForkPoolWorker-2507:\n", + "Process ForkPoolWorker-2532:\n", + "Process ForkPoolWorker-2510:\n", + "Process ForkPoolWorker-2564:\n", + "Process ForkPoolWorker-5305:\n", + "Process ForkPoolWorker-5273:\n", + "Process ForkPoolWorker-5298:\n", + "Process ForkPoolWorker-5293:\n", + "Process ForkPoolWorker-5284:\n", + "Process ForkPoolWorker-5282:\n", + "Process ForkPoolWorker-5278:\n", + "Process ForkPoolWorker-5263:\n", + "Process ForkPoolWorker-5277:\n", + "Process ForkPoolWorker-5275:\n", + "Process ForkPoolWorker-5272:\n", + "Process ForkPoolWorker-5271:\n", + "Process ForkPoolWorker-5269:\n", + "Process ForkPoolWorker-2517:\n", + "Process ForkPoolWorker-2514:\n", + "Process ForkPoolWorker-2520:\n", + "Process ForkPoolWorker-2522:\n", + "Process ForkPoolWorker-2513:\n", + "Process ForkPoolWorker-2523:\n", + "Process ForkPoolWorker-2508:\n", + "Process ForkPoolWorker-2524:\n", + "Process ForkPoolWorker-2525:\n", + "Process ForkPoolWorker-2526:\n", + "Process ForkPoolWorker-2530:\n", + "Process ForkPoolWorker-2554:\n", + "Process ForkPoolWorker-2555:\n", + "Process ForkPoolWorker-2575:\n", + "Process ForkPoolWorker-5268:\n", + "Process ForkPoolWorker-2574:\n", + "Process ForkPoolWorker-5266:\n", + "Process ForkPoolWorker-2568:\n", + "Process ForkPoolWorker-2586:\n", + "Process ForkPoolWorker-2563:\n", + "Process ForkPoolWorker-2580:\n", + "Process ForkPoolWorker-2562:\n", + "Process ForkPoolWorker-2576:\n", + "Process ForkPoolWorker-2561:\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "Traceback (most recent call last):\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", + " res = self._reader.recv_bytes()\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", + " buf = self._recv_bytes(maxlength)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", + " buf = self._recv(4)\n", + " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", + " chunk = read(handle, remaining)\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n", + "KeyboardInterrupt\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", + " self.run()\n", + " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", + " self._target(*self._args, **self._kwargs)\n", + " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", + " task = get()\n", + " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", + " with self._rlock:\n", + " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", + " return self._semlock.__enter__()\n", + "KeyboardInterrupt\n" ] } ] diff --git a/code/reproduce_results.py b/code/reproduce_results.py index db04680..caa6989 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -9,7 +9,7 @@ def main(): datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' datafolder_icbeb = '../data/ICBEB/' - outputfolder = '../../content/output/' + outputfolder = '../../content/drive/output/' models = [ conf_fastai_xresnet1d101, @@ -41,7 +41,7 @@ def main(): e.evaluate() # generate greate summary table - utils.generate_ptbxl_summary_table(folder = '../../content/output/') + utils.generate_ptbxl_summary_table(folder = '../../content/drive/output/') ########################################## # EXPERIMENT BASED ICBEB DATA @@ -53,7 +53,7 @@ def main(): e.evaluate() # generate greate summary table - utils.ICBEBE_table(folder='../../content/output/') + utils.ICBEBE_table(folder='../../content/drive/output/') if __name__ == "__main__": main() From 0f8537d7e7bf0f1b9516d1fdbaf06bde8bbb1cac Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 28 Sep 2022 15:54:43 +0200 Subject: [PATCH 08/51] Update reproduce_results.py --- code/reproduce_results.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index caa6989..fb05df8 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -9,7 +9,7 @@ def main(): datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' datafolder_icbeb = '../data/ICBEB/' - outputfolder = '../../content/drive/output/' + outputfolder = '../../content/drive/MyDrive/PTB-xl-output/' models = [ conf_fastai_xresnet1d101, @@ -41,7 +41,7 @@ def main(): e.evaluate() # generate greate summary table - utils.generate_ptbxl_summary_table(folder = '../../content/drive/output/') + utils.generate_ptbxl_summary_table(folder = '../../content/drive/MyDrive/PTB-xl-output/') ########################################## # EXPERIMENT BASED ICBEB DATA @@ -53,7 +53,7 @@ def main(): e.evaluate() # generate greate summary table - utils.ICBEBE_table(folder='../../content/drive/output/') + utils.ICBEBE_table(folder='../../content/drive/MyDrive/PTB-xl-output/') if __name__ == "__main__": main() From df0a33df26e8b00f90d6185a06531367876e9028 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Tue, 1 Nov 2022 14:45:53 +0100 Subject: [PATCH 09/51] main take folder as arg and add correct args to evaluate in order to reprod results --- code/reproduce_results.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index fb05df8..6738840 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -5,11 +5,10 @@ from configs.wavelet_configs import * -def main(): +def main(datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/', + datafolder_icbeb = '../data/ICBEB/', + outputfolder = '../../content/drive/MyDrive/PTB-xl-output/'): - datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' - datafolder_icbeb = '../data/ICBEB/' - outputfolder = '../../content/drive/MyDrive/PTB-xl-output/' models = [ conf_fastai_xresnet1d101, @@ -38,10 +37,10 @@ def main(): e = SCP_Experiment(name, task, datafolder, outputfolder, models) e.prepare() e.perform() - e.evaluate() + e.evaluate(n_bootstraping_samples=100, bootstrap_eval=True, dumped_bootstraps=False) # generate greate summary table - utils.generate_ptbxl_summary_table(folder = '../../content/drive/MyDrive/PTB-xl-output/') + utils.generate_ptbxl_summary_table(folder = outputfolder) ########################################## # EXPERIMENT BASED ICBEB DATA From 2feb174b006dde7040d914096b9eb5a28ae34121 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Tue, 1 Nov 2022 15:03:12 +0100 Subject: [PATCH 10/51] Add support for using arguments when running file --- PTB_XL_experiments.ipynb | 680 +++++++++++++++++++------------------- code/reproduce_results.py | 13 +- 2 files changed, 347 insertions(+), 346 deletions(-) diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb index 0b3978d..760271c 100644 --- a/PTB_XL_experiments.ipynb +++ b/PTB_XL_experiments.ipynb @@ -13,8 +13,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting wget\n", @@ -57,16 +57,16 @@ }, { "cell_type": "code", - "source": [ - "from google.colab import drive\n", - "drive.mount('/content/drive')" - ], + "execution_count": null, + "id": "JXL0zlq8Wdpl", "metadata": { "id": "JXL0zlq8Wdpl" }, - "id": "JXL0zlq8Wdpl", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] }, { "cell_type": "code", @@ -114,8 +114,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "--2022-09-28 06:27:07-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", @@ -143,36 +143,32 @@ }, { "cell_type": "code", - "source": [ - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ], + "execution_count": 5, + "id": "ICe12Y7yxFKg", "metadata": { "id": "ICe12Y7yxFKg" }, - "id": "ICe12Y7yxFKg", - "execution_count": 5, - "outputs": [] + "outputs": [], + "source": [ + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] }, { "cell_type": "code", - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ], + "execution_count": 6, + "id": "V-j1oLL4Li10", "metadata": { - "id": "V-j1oLL4Li10", - "outputId": "e3432168-e2f3-422e-a5c0-e5c9b5f6c3e1", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "V-j1oLL4Li10", + "outputId": "e3432168-e2f3-422e-a5c0-e5c9b5f6c3e1" }, - "id": "V-j1oLL4Li10", - "execution_count": 6, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", @@ -188,46 +184,50 @@ "Successfully installed GitPython-3.1.27 gitdb-4.0.9 smmap-5.0.0\n" ] } + ], + "source": [ + "!pip install GitPython\n", + "from git import Repo" ] }, { "cell_type": "code", - "source": [ - "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", - "DEST_NAME = 'github_repo'" - ], + "execution_count": 7, + "id": "aLEwloYTLpue", "metadata": { "id": "aLEwloYTLpue" }, - "id": "aLEwloYTLpue", - "execution_count": 7, - "outputs": [] + "outputs": [], + "source": [ + "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", + "DEST_NAME = 'github_repo'" + ] }, { "cell_type": "code", - "source": [ - "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ], + "execution_count": 8, + "id": "wrApvEoJLPYq", "metadata": { - "id": "wrApvEoJLPYq", - "outputId": "b9336107-9b65-4860-e7b0-8a7ba5559685", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "wrApvEoJLPYq", + "outputId": "b9336107-9b65-4860-e7b0-8a7ba5559685" }, - "id": "wrApvEoJLPYq", - "execution_count": 8, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "" ] }, + "execution_count": 8, "metadata": {}, - "execution_count": 8 + "output_type": "execute_result" } + ], + "source": [ + "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" ] }, { @@ -243,7 +243,6 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "['example_physionet.py',\n", @@ -256,8 +255,9 @@ " 'SHA256SUMS.txt']" ] }, + "execution_count": 9, "metadata": {}, - "execution_count": 9 + "output_type": "execute_result" } ], "source": [ @@ -266,22 +266,19 @@ }, { "cell_type": "code", - "source": [ - "!pip install git+https://github.com/Bsingstad/fastai.git" - ], + "execution_count": 10, + "id": "fRteqX8GY5Nw", "metadata": { - "id": "fRteqX8GY5Nw", - "outputId": "1725f25e-f9b3-48c5-ca99-ce226db5fc3f", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "fRteqX8GY5Nw", + "outputId": "1725f25e-f9b3-48c5-ca99-ce226db5fc3f" }, - "id": "fRteqX8GY5Nw", - "execution_count": 10, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting git+https://github.com/Bsingstad/fastai.git\n", @@ -354,74 +351,74 @@ "Successfully installed bottleneck-1.3.5 fastai-1.0.61 nvidia-ml-py3-7.352.0\n" ] } + ], + "source": [ + "!pip install git+https://github.com/Bsingstad/fastai.git" ] }, { "cell_type": "code", - "source": [ - "import fastai" - ], + "execution_count": 11, + "id": "EpL88UONKFJz", "metadata": { "id": "EpL88UONKFJz" }, - "id": "EpL88UONKFJz", - "execution_count": 11, - "outputs": [] + "outputs": [], + "source": [ + "import fastai" + ] }, { "cell_type": "code", - "source": [ - "from github_repo.code import *\n" - ], + "execution_count": 12, + "id": "IpjW6eVLMGJQ", "metadata": { "id": "IpjW6eVLMGJQ" }, - "id": "IpjW6eVLMGJQ", - "execution_count": 12, - "outputs": [] + "outputs": [], + "source": [ + "from github_repo.code import *\n" + ] }, { "cell_type": "code", - "source": [ - "from IPython.display import clear_output, display, HTML" - ], + "execution_count": 13, + "id": "xDIdqSZiIdZr", "metadata": { "id": "xDIdqSZiIdZr" }, - "id": "xDIdqSZiIdZr", - "execution_count": 13, - "outputs": [] + "outputs": [], + "source": [ + "from IPython.display import clear_output, display, HTML" + ] }, { "cell_type": "code", - "source": [ - "os.mkdir(\"../../content/drive/output/\")" - ], + "execution_count": 14, + "id": "Q8fTH7i-v8SY", "metadata": { "id": "Q8fTH7i-v8SY" }, - "id": "Q8fTH7i-v8SY", - "execution_count": 14, - "outputs": [] + "outputs": [], + "source": [ + "os.mkdir('../../content/drive/MyDrive/PTB-xl-output/')" + ] }, { "cell_type": "code", - "source": [ - "!python /content/github_repo/code/reproduce_results.py" - ], + "execution_count": null, + "id": "48KVqw_QMq2H", "metadata": { - "id": "48KVqw_QMq2H", - "outputId": "121ff7f7-4466-4b20-a65b-d94ea67dd04f", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "48KVqw_QMq2H", + "outputId": "121ff7f7-4466-4b20-a65b-d94ea67dd04f" }, - "id": "48KVqw_QMq2H", - "execution_count": null, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "100% 21837/21837 [01:01<00:00, 357.00it/s]\n", "tcmalloc: large alloc 2096357376 bytes == 0x84250000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a791d715 0x7f16a791dd1b 0x7f16a79be333 0x58eb9c 0x51b4e6 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", @@ -4336,6 +4333,9 @@ "KeyboardInterrupt\n" ] } + ], + "source": [ + "!python /content/github_repo/code/reproduce_results.py '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' '../data/ICBEB/' '../../content/drive/MyDrive/PTB-xl-output/'" ] }, { @@ -4366,8 +4366,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Requirement already satisfied: wfdb in /usr/local/lib/python3.7/dist-packages (4.0.0)\n", @@ -4864,8 +4864,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "100%|██████████| 21837/21837 [01:07<00:00, 323.92it/s]\n" ] @@ -5021,16 +5021,16 @@ }, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], "source": [ @@ -5064,26 +5064,26 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "" ] }, + "execution_count": 20, "metadata": {}, - "execution_count": 20 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], "source": [ @@ -5104,14 +5104,14 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "(15944, 1000, 12)" ] }, + "execution_count": 71, "metadata": {}, - "execution_count": 71 + "output_type": "execute_result" } ], "source": [ @@ -5131,14 +5131,14 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "(5486, 1000, 12)" ] }, + "execution_count": 72, "metadata": {}, - "execution_count": 72 + "output_type": "execute_result" } ], "source": [ @@ -5183,28 +5183,28 @@ }, { "cell_type": "code", - "source": [ - "#X = np.expand_dims(X[:,:,1],2)" - ], + "execution_count": null, + "id": "uKN4Lx0y4PYc", "metadata": { "id": "uKN4Lx0y4PYc" }, - "id": "uKN4Lx0y4PYc", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "#X = np.expand_dims(X[:,:,1],2)" + ] }, { "cell_type": "code", - "source": [ - "#v = X[:,:,0] # foo[:, -1] for the last column\n", - "#X[:,:, 0] = (v - v.min()) / (v.max() - v.min())" - ], + "execution_count": null, + "id": "COAefnPG4XM9", "metadata": { "id": "COAefnPG4XM9" }, - "id": "COAefnPG4XM9", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "#v = X[:,:,0] # foo[:, -1] for the last column\n", + "#X[:,:, 0] = (v - v.min()) / (v.max() - v.min())" + ] }, { "cell_type": "code", @@ -5268,14 +5268,14 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "{0: 1.0, 1: 2.88474025974026}" ] }, + "execution_count": 80, "metadata": {}, - "execution_count": 80 + "output_type": "execute_result" } ], "source": [ @@ -5371,6 +5371,12 @@ }, { "cell_type": "code", + "execution_count": null, + "id": "sLVXZL7SgkOJ", + "metadata": { + "id": "sLVXZL7SgkOJ" + }, + "outputs": [], "source": [ "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", "\n", @@ -5460,26 +5466,20 @@ " ])\n", " \n", " return model" - ], - "metadata": { - "id": "sLVXZL7SgkOJ" - }, - "id": "sLVXZL7SgkOJ", - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "code", - "source": [ - "batchsize = 32\n", - "model = build_model((1000,1),1)" - ], + "execution_count": null, + "id": "QEO-kyIs3A2z", "metadata": { "id": "QEO-kyIs3A2z" }, - "id": "QEO-kyIs3A2z", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "batchsize = 32\n", + "model = build_model((1000,1),1)" + ] }, { "cell_type": "code", @@ -5514,8 +5514,8 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Num GPUs Available: 1\n" ] @@ -5581,27 +5581,27 @@ }, { "cell_type": "code", - "source": [ - "#tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)" - ], + "execution_count": null, + "id": "RBztHZVdz0nH", "metadata": { "id": "RBztHZVdz0nH" }, - "id": "RBztHZVdz0nH", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "#tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)" + ] }, { "cell_type": "code", - "source": [ - "ecg_plot = X_test[0,25:125,0]" - ], + "execution_count": null, + "id": "IjwhZio6Azxl", "metadata": { "id": "IjwhZio6Azxl" }, - "id": "IjwhZio6Azxl", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "ecg_plot = X_test[0,25:125,0]" + ] }, { "cell_type": "code", @@ -5617,9 +5617,9 @@ }, "outputs": [ { - "output_type": "error", "ename": "KeyboardInterrupt", "evalue": "ignored", + "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", @@ -5689,41 +5689,32 @@ }, { "cell_type": "code", - "source": [ - "batchsize = 32\n", - "model = build_model((1000,12),1)\n", - "history = model.fit(x=X_train,y=y_train, epochs=20, batch_size=batchsize,\n", - " validation_data=(X_test,y_test),steps_per_epoch=(len(X_train)/batchsize),\n", - " class_weight=class_w_dict, \n", - " callbacks = [plot_losses, tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)],\n", - " verbose = 1, shuffle = True)" - ], + "execution_count": null, + "id": "KzoC-omnK0kn", "metadata": { - "id": "KzoC-omnK0kn", - "outputId": "ab814309-4817-4576-9f3e-e49ae51be0fc", "colab": { "base_uri": "https://localhost:8080/", "height": 376 - } + }, + "id": "KzoC-omnK0kn", + "outputId": "ab814309-4817-4576-9f3e-e49ae51be0fc" }, - "id": "KzoC-omnK0kn", - "execution_count": null, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r448/448 [==============================] - 36s 79ms/step - loss: 0.8209 - binary_accuracy: 0.7257 - ROC: 0.7961 - PRC: 0.5695 - val_loss: 0.5064 - val_binary_accuracy: 0.7633 - val_ROC: 0.8106 - val_PRC: 0.5828 - lr: 0.0010\n", "\n", @@ -5732,185 +5723,191 @@ "296/448 [==================>...........] - ETA: 10s - loss: 0.7829 - binary_accuracy: 0.7488 - ROC: 0.8143 - PRC: 0.6043" ] } + ], + "source": [ + "batchsize = 32\n", + "model = build_model((1000,12),1)\n", + "history = model.fit(x=X_train,y=y_train, epochs=20, batch_size=batchsize,\n", + " validation_data=(X_test,y_test),steps_per_epoch=(len(X_train)/batchsize),\n", + " class_weight=class_w_dict, \n", + " callbacks = [plot_losses, tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)],\n", + " verbose = 1, shuffle = True)" ] }, { "cell_type": "code", - "source": [ - "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv1d_95\").output, model.output])\n" - ], + "execution_count": null, + "id": "XEoxcIU7KrqU", "metadata": { "id": "XEoxcIU7KrqU" }, - "id": "XEoxcIU7KrqU", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv1d_95\").output, model.output])\n" + ] }, { "cell_type": "code", - "source": [ - "plt.figure(figsize=(20,4))\n", - "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" - ], + "execution_count": null, + "id": "JZv28B--LxD3", "metadata": { - "id": "JZv28B--LxD3", - "outputId": "a918e0c5-8083-44ae-c13b-e1db1c78ae1b", "colab": { "base_uri": "https://localhost:8080/", "height": 283 - } + }, + "id": "JZv28B--LxD3", + "outputId": "a918e0c5-8083-44ae-c13b-e1db1c78ae1b" }, - "id": "JZv28B--LxD3", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 139, "metadata": {}, - "execution_count": 139 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } + ], + "source": [ + "plt.figure(figsize=(20,4))\n", + "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" ] }, { "cell_type": "code", - "source": [ - "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv3\").output, model.output])" - ], + "execution_count": null, + "id": "OVce6_vhM1DZ", "metadata": { "id": "OVce6_vhM1DZ" }, - "id": "OVce6_vhM1DZ", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv3\").output, model.output])" + ] }, { "cell_type": "code", - "source": [ - "plt.figure(figsize=(20,4))\n", - "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" - ], + "execution_count": null, + "id": "Q0a7PE_7M5ic", "metadata": { - "id": "Q0a7PE_7M5ic", - "outputId": "8cd9a710-073c-437b-fa16-1a76ef9cb01f", "colab": { "base_uri": "https://localhost:8080/", "height": 285 - } + }, + "id": "Q0a7PE_7M5ic", + "outputId": "8cd9a710-073c-437b-fa16-1a76ef9cb01f" }, - "id": "Q0a7PE_7M5ic", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 210, "metadata": {}, - "execution_count": 210 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } + ], + "source": [ + "plt.figure(figsize=(20,4))\n", + "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" ] }, { "cell_type": "code", - "source": [ - "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv4\").output, model.output])\n" - ], + "execution_count": null, + "id": "GR7LtK8uM6uv", "metadata": { "id": "GR7LtK8uM6uv" }, - "id": "GR7LtK8uM6uv", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv4\").output, model.output])\n" + ] }, { "cell_type": "code", - "source": [ - "plt.figure(figsize=(20,4))\n", - "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" - ], + "execution_count": null, + "id": "sawQr7PPM_Um", "metadata": { - "id": "sawQr7PPM_Um", - "outputId": "466e3d22-9df2-477a-e652-a5191b84e339", "colab": { "base_uri": "https://localhost:8080/", "height": 284 - } + }, + "id": "sawQr7PPM_Um", + "outputId": "466e3d22-9df2-477a-e652-a5191b84e339" }, - "id": "sawQr7PPM_Um", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 73, "metadata": {}, - "execution_count": 73 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } + ], + "source": [ + "plt.figure(figsize=(20,4))\n", + "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" ] }, { "cell_type": "code", - "source": [ - "model.summary()" - ], + "execution_count": null, + "id": "tvxhRKAF54kU", "metadata": { - "id": "tvxhRKAF54kU", - "outputId": "021c15b8-31c3-43cd-d1dc-1bb2743da054", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "tvxhRKAF54kU", + "outputId": "021c15b8-31c3-43cd-d1dc-1bb2743da054" }, - "id": "tvxhRKAF54kU", - "execution_count": null, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Model: \"model_2\"\n", "__________________________________________________________________________________________________\n", @@ -5964,85 +5961,77 @@ "__________________________________________________________________________________________________\n" ] } + ], + "source": [ + "model.summary()" ] }, { "cell_type": "code", - "source": [], + "execution_count": null, + "id": "a4FNE_gF90jd", "metadata": { "id": "a4FNE_gF90jd" }, - "id": "a4FNE_gF90jd", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [] }, { "cell_type": "code", - "source": [ - "model.get_layer(\"conv5\").weights[0][:,:,:].shape[0]" - ], + "execution_count": null, + "id": "SgSG4hEr79Rb", "metadata": { - "id": "SgSG4hEr79Rb", - "outputId": "d9fb4718-6ef2-4232-d654-f79a7c5b3f66", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "SgSG4hEr79Rb", + "outputId": "d9fb4718-6ef2-4232-d654-f79a7c5b3f66" }, - "id": "SgSG4hEr79Rb", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "1" ] }, + "execution_count": 158, "metadata": {}, - "execution_count": 158 + "output_type": "execute_result" } + ], + "source": [ + "model.get_layer(\"conv5\").weights[0][:,:,:].shape[0]" ] }, { "cell_type": "code", - "source": [ - "ecg_plot = X_test[0,25:125,0]" - ], + "execution_count": null, + "id": "5mGSpUU8-oMx", "metadata": { "id": "5mGSpUU8-oMx" }, - "id": "5mGSpUU8-oMx", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [ + "ecg_plot = X_test[0,25:125,0]" + ] }, { "cell_type": "code", - "source": [ - "for layer_name in [\"conv2\", \"conv3\", \"conv4\"]:\n", - " for h in range(3):\n", - " for i in range(len(ecg_plot)-model.get_layer(layer_name).weights[0][:,:,:].shape[0]):\n", - " clear_output(wait=True)\n", - " fig,ax = plt.subplots(figsize=(20,2))\n", - " ax.plot(ecg_plot)\n", - " ax2=ax.twinx()\n", - " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,h], \"r\")\n", - " plt.show()" - ], + "execution_count": null, + "id": "txIQ2HBc7Cru", "metadata": { - "id": "txIQ2HBc7Cru", - "outputId": "131cd2c9-4aad-4783-f621-f797d5c34058", "colab": { "base_uri": "https://localhost:8080/", "height": 433 - } + }, + "id": "txIQ2HBc7Cru", + "outputId": "131cd2c9-4aad-4783-f621-f797d5c34058" }, - "id": "txIQ2HBc7Cru", - "execution_count": null, "outputs": [ { - "output_type": "error", "ename": "KeyboardInterrupt", "evalue": "ignored", + "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", @@ -6070,25 +6059,32 @@ "\u001b[0;31mKeyboardInterrupt\u001b[0m: " ] } + ], + "source": [ + "for layer_name in [\"conv2\", \"conv3\", \"conv4\"]:\n", + " for h in range(3):\n", + " for i in range(len(ecg_plot)-model.get_layer(layer_name).weights[0][:,:,:].shape[0]):\n", + " clear_output(wait=True)\n", + " fig,ax = plt.subplots(figsize=(20,2))\n", + " ax.plot(ecg_plot)\n", + " ax2=ax.twinx()\n", + " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,h], \"r\")\n", + " plt.show()" ] }, { "cell_type": "code", - "source": [ - "np.arange(40)" - ], + "execution_count": null, + "id": "ajaT6gM78Y5I", "metadata": { - "id": "ajaT6gM78Y5I", - "outputId": "6096c0d5-fa0b-434b-a7aa-c8b14bbe16e1", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "ajaT6gM78Y5I", + "outputId": "6096c0d5-fa0b-434b-a7aa-c8b14bbe16e1" }, - "id": "ajaT6gM78Y5I", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", @@ -6096,156 +6092,160 @@ " 34, 35, 36, 37, 38, 39])" ] }, + "execution_count": 144, "metadata": {}, - "execution_count": 144 + "output_type": "execute_result" } + ], + "source": [ + "np.arange(40)" ] }, { "cell_type": "code", - "source": [ - "fig,ax = plt.subplots(figsize=(30,4))\n", - "ax.plot(X_test[0,:,0])\n", - "ax2=ax.twinx()\n", - "ax2.plot(np.arange(40),model.get_layer(\"conv2\").weights[0][:,:,2], \"r\")" - ], + "execution_count": null, + "id": "uveifoEV8OUU", "metadata": { - "id": "uveifoEV8OUU", - "outputId": "08b39943-99fa-4055-d306-b92f784c62d7", "colab": { "base_uri": "https://localhost:8080/", "height": 260 - } + }, + "id": "uveifoEV8OUU", + "outputId": "08b39943-99fa-4055-d306-b92f784c62d7" }, - "id": "uveifoEV8OUU", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 146, "metadata": {}, - "execution_count": 146 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAABtQAAAD4CAYAAAB8BQIWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzde5Qk110n+O+NfD/qXdXd1dXdanW3rJcthC1rwBgwA4Pt8SID9rKGXRafxeM9BsYsA8OYWY6HsQ+cETuzwIBZxscMhuFhGxsYGcvyYBtjy8ayZMmSWlJL3epHdVdXdb0fWfmMiLt/3LiZkVmRWVmZUR1RGd/POX1UXVmVHeqKzoy4v/v9/YSUEkRERERERERERERERETkzQj6AIiIiIiIiIiIiIiIiIjCjAU1IiIiIiIiIiIiIiIiog5YUCMiIiIiIiIiIiIiIiLqgAU1IiIiIiIiIiIiIiIiog5YUCMiIiIiIiIiIiIiIiLqIB70AbQyDENmMpmgD4OIiIiIiIiIiIiIiIhusmKxKKWUoQuEha6glslksL29HfRhEBERERERERERERER0U0mhCgFfQxeQlfhIyIiIiIiIiIiIiIiIgoTFtSIiIiIiIiIiIiIiIiIOmBBjYiIiIiIiIiIiIiIiKgDFtSIiIiIiIiIiIiIiIiIOmBBjYiIiIiIiIiIiIiIiKgDFtSIiIiIiIiIiIiIiIiIOmBBjYiIiIiIiIiIiIiIiKgDFtSI6OAwTeDTnwak9P+5v/IV4P3vB6pV/5+bBlrNsvGJx6/CtvfhvCQiIiIiIiIiIqJQYEGNiA6Oz34WeOAB4IUX/H/uRx8FPvhBwLb9f24aaN+4tIpf/tQzeOrqWtCHQkRERERERERERPuEBTUiOjhWVtR/t7f9f26dTEsk/H9uGmjlmgUAKFVZjCUiIiIiIiIiIhpULKgR0cFRKKj/1mr+P3etBhgGEIv5/9w00Eyn1WPFtAI+EiIiIiIiIiIiItovLKgR0cGxtaX+u18FtWTS/+elgWdaqqBWNZlQIyIiIiIiIiIiGlQsqBHRwbGfCbVqle0eqSemM3evarGgRkRERERERERENKhYUCOig0MX1EzT/+eu1VhQo57ohFqlxoIaERERERERERHRoGJBjYgODrZ8pBDSCbUKE2pEREREREREREQDiwU1Ijo42PKRQqhWT6hZAR8JERERERGFyfkbW5jfKAV9GERERANJCPEmIcSLQogLQoj3dfi6twkhpBDivn7/zK4KarsdmBDinUKIJSHEt5xf72p5fFgIcU0I8Xv9HjARRdh+FtTY8pF6ZNmqoMYZakRERERE5Pbej30Lv/nIi0EfBhER0cARQsQAfAjAmwHcBeDHhRB3eXzdEICfB/CYH3/urgW1bg8MwMellPc6vz7S8tgHAXy576Mlomhjy0cKoZpTSKuaLKgREREREVHDdsXEynY16MMgIiIaRPcDuCClvCilrAL4GIC3enzdBwE8CKDsxx/aTUKt2wPzJIR4DYDDAP5Hb4dIRORgy0cKIdNJqFVYUCMiIiIiIhfLliiU9+H+lYiIiGYAXHX9/przuTohxKsBHJdSfsavP7SbgtquB+Z4mxDiGSHEJ4UQxwFACGEA+E8AfqnTHyCEeLcQ4gkhxBOmaXZ56EQUOWz5SCFUb/nIghoREREREblYtkShwnUuIiKiHsR1zcj59e69fLNTm/p/Afyirwfl0/N8GsBfSCkrQoj/E8AfA/inAH4GwMNSymtCiLbfLKX8MIAPA0Aul5M+HRMRDRq2fKQQ0i0fK6YV8JEQEREREVGYWFKiUGZBjYiIqAemlPK+Do/PATju+v0x53PaEIBXAviSU5s6AuAhIcQDUsonej2obgpqux0YpJQrrt9+BMBvOh9/J4DvFkL8DIA8gKQQoiClfF+vB0xEEcaWjxRCpsWEGhERERER7WTZEuUaN94RERHtg8cB3CaEuBWqXvUOAD+hH5RSbgCY1L8XQnwJwC/1U0wDuiuodTww52CmpZTzzm8fAPCCc9D/q+tr3gngPhbTiKgntg1sb6uP9yuhlkr5/7w08Ey2fCQiIiIiIg+mZWO7YkJKiU6dm4iIiGhvpJSmEOLnAHwOQAzAf5VSPieE+ACAJ6SUD+3Hn7trQa3LA3uvEOIBACaAVQDv3I+DJaII08U0YP8KakND/j8vDTyz3vKRBTUiIiIiImqwpfpVqlnIJv2aukJEREQAIKV8GMDDLZ97f5uvfYMff2ZX7+a7HZiU8lcA/Mouz/FRAB/d8xESEQGNdo8AYO5DD3q2fKQeMaFGREREREReTFvdIxTKJgtqREREA8AI+gCIKIJsG/ihHwI+//nuv2drq/HxfiXUWFCjHuibZCbUou2Rswv4h5eWgj4MCoHPPcdzgYia/fInn8av/s2zQR8GBeTn/vxJ/Ppnng/6MCggzq0Ctir7sCmUiIiIbjpujyGim69SAf72b4FXvxr4gR/o7nvcCbX9Kqglk/4/Lw0802JCjYDf+cJ5TOaT+N5XTAV9KBSw3//SyxhOx3kuEFHdSzcKiBucnRRVz89vYrPMYkpUuRNqREREdPAxoUZE++OjHwXe+17vx3TLRvdctN3sd0GNLR+pRzWnoFaxWFCLskKlxpQiAQBqps1zgQAAf39uEY+eXw76MCgELFuibFpBHwYFpFS1UKnx5x9FUko43eFRYEKNiIhoILCgRkT743OfA373d4HZ2Z2PWc4NZbHY/fOx5SOFlKVbPnKhJNK2KxZTigQAqFk2aiywE4Df/sJ5/H//cCHow6AQMG2Jco2vC1FVrFrcaBFRlq6mAdhiQo2IiGggsKBGRPtDF80+9rGdj4U1ocaWj9SDmnOjXOUCeqQVyiYXywiAWjhncZUAoFxloZ0Uy7ZR5sabyCrVWFCLKks2CmpMqBEREQ0GFtSIaH/ooplfBTUm1CikTKeQxkXT6KqYFqqWjSrbeRGYUKOGUs1C1ZK7fyENPNNiQi2qLGeTBTsZRJM7oVYo78M9LBEREd10LKgR0f7QCbWnngJefNH7Ma+C2r//98AXv7jz8zqhNjLCghqFir5R5s7j6NJD5plSJEAtnLPATgBQrlmo8VwgqOQqCyrRVKyqawReJ0ZTU0GNCTUiIqKBwIIaEe0P01TFLwD46ld3PgZ4F9QefBD4q7/a+XldUBsbY8tHCpWakz7gAnp06QUSngME6IQaU0mkE2p8XSC1qF5mijmSSlX1c6/w5x9JTTPUWFAjIiIaCCyoEdH+sKxGQa1abX6sXUHNsoBSqfG429YWkE6rX34X1KRkQo16ZtpqsZQLJdGlh8yzoEaAKqgxiUCAk1BjQY2grhVqlqy3iaboKDnJxApbfkaS2dTykQU1IiKiQcCCGhHtD9MEMhn1cWtBrV3LR51C8yqoFQpAPq+KXl6P90MfDwtq1AOTCbXI0wk1FlEIUItnLKKQ6SQV+d5AQCOlUub5EDnFekKNP/sostnykYiIaOCwoEZE+8OyVJoM2Jkoa5dQ67ag5ndCTRf82PKReqB3ntoS3HkeUQUm1MilZtk8F6heOGFxlYDGtUKZc9QiRxfUqpbdVFyhaGBCjYiIaPCwoEZE+8OyGgm1bgtqW1vNj7c+NjS0PwU1/XxMqFEP3EU07j6OJr3j2LQlF8siTkqJmsWEGjUKJ3xfIACwLBbUokrPUAPAmYoRZDGhRkRENHBYUCOi/eFu+dhaAOu35SMLahQi7p2nTKVEk3vIPBfLok0vnLG4SnoRncVVAoCaM2+1zDlakVOsNq4ROEctelhQI6J2apaNTz99HVLynoHooGFBjYj2h2UBqZT6uF1CrVptLp51SqgVCvuXUGPLR+qDnqEGMIkQVe4WPjwHoq2pwM5CSqTpJFLN4iIJuWaoMaEWOSXXz7xi8ucfNZazUG4IFtSIqNlXzi/hX/7FU3hhfivoQyGiPWJBjYj2h2kCsZgqgOmClWa5bia3t4G/+itgdnb3lo+5XKOgtrAAvPnNwPLy7sfyR38E/NRPtX+cCTXqg951DjChFlWFSqPIz8WyaHMX0VhQizadRLJs2ZRQoGjSxXa+R0SPu+UjN91Ej379H84kOEONiJroGZvuJDMRHQwsqBF16ZGzC/jahS6KN6RYFhCPeyfK3AWzzU3gx34M+NCHOrd8rFZV4k0/35NPAo88Anzta7sfy5e/DPzpnwLlsvfjfRTUHjk7jy+eu7Hn76PBYdkSMUMAAKoWF8qiaLvimo/CxbJIcydWazwXIs2dSmHbx2izbQndzalU5bkQNcUqE2pRpgtqo5lEU4twIiJ9fcj7R6KDhwU1oi79zhfO4/e/9HLQh3FwuBNqnQpqc3Oq+Lay0jmh1lqgK5XU52dnuzsW2wbOnfN+vMeWjxvFGn7xE0/jD/7h4p6+jwaLaUnkkjEAnI0SVVuuHce8IYo2kwk1cpRrTKWQ4m4Fy5aP0eMurvM6MXp0QW0kk0DVtFlUJaK6mumk13nPQHTgsKBG1CXTsrG41SbhRDvpAlgyubOg5k7xXL2q/ru21jmhpgt08bh6Pp0266agpv/8s2c7P77HhNp/+/plbFctLqBHXM2ykUvFAXABParcLR95DkSb++evb5IpmphQI83d8rPMxfTIcbfyYjEleuoFtazauOnuakDR83997Cn8yO9/FV97mZ2PqDE6gutJRAcPC2pEXbKkxNJWJejDODgsq7uEmi6Ira3tnlBzP1/ABbVS1cIfffUyAF4ARZ1lS2SdhFqFO48jyT1knudAtLlbPrIFbLSVWVAjh+matcqEUvS423zyGiF6TFdCDQDnqEXcM9c28NTsOn7yD7+Ba2vFoA+HAqbbw7OTAdHBw4IaUZdsW2KtWGPxpFum2WjRqFsquh/T9pJQc7d83EtBTT/fs896P95Dy8cnrqxiZbuK4XSciZSIY0KNCmUT8focPZ4DUeZeOK8yoRZp7oIarx2jzWLLx0gr1dwJNb4WRE2j5aO6VyhwjlqkWVJiJJOAZXOzNgE1ZyMerxOJDh4W1Ii6pHeXLRV44dOVTgk19679XhJqphl4Qk1f9EzmU7wAijjTlVDjuRBNWxUT4zlVkOc5EG21poQaz4UoK1WZUCPF/brAglr0FKvueYr8+UeNLqjpzXds+xptpsX7RmrQ9wo8F4gOHhbUiLpk64IadxJ1R88885qh1i6h1kvLx+vXdz6/17EAqvi2ubnzcf39e0io6ZujTDLGhbKIM22JXFLdJHOhJJoKZRbUSHG/H/C9IdrKrtcCplKijQm1aCtWLSTjatmFrwXRUy+oOfcKfA2INltKZBLOqAC+HkRerV5Q4+sC0UHDghpRlyypLoYXN8sBH8kBYVnNLRrdvGaobW4CGxs7H3d/j1fLRymBubnOx+L+8597bufjuuXjHhJq9YJaIsYF9IgzLRtZ3fKR50IkFVwJNd4cR1tTQo3nQqQ1J9TY/jPKOEMt2kpVC2NZdY/BGWrRo9cQ6vOWeW0QaZYtkU4woUaKLqjxdYHo4GFBjahLuoCyyIRad3RCbbeWj4uLjY+vXWt8b6t2CTUAuHKl87HUasDJk+rj55/3fhzYW0FNNhJqvBiOLtuWsCWQ401yZFm2RLFqYSKfAsCUYtSZrlQaWz5GmzuFwLRitDGhFm2lmoXRjN50w59/1FhOQV23fKzwNSDSbOlq+chrg8jjDDWig4sFNaIuWWz5uDfuhJpOgGleBTOgkVbba0FttzlqpgkcPqw+9rnlYzoRQ4UXw5GlZytmk0yoRZUeLj/Blo+ExmsCwHMh6tyFE54L0eZ+XeD8pOgpVi2M6oQaXwsiR98m6iIKU6rRZtkSmfpGTL4fRF295SPXk4gOHBbUiLpkMqG2N50Sau0Kauvr7R/3avk4NqYe262gVqsBuZz6uOLx8+uj5WPWmaEmJds5RZFZ33XK1h1RpQtq9RlqvCGKtCpnqJGj5C6o8VyItOaEGs+FqClVTYxl2RY6qnRCLZ/ivGVyCmps+UiOxgw1ngtEBw0LakRdsusJNc5Q64pOqCWTnVs+AsDwcPPvd0uoSQlsb6uC2tRUdwm1TgW1Hlo+mq4ZalI27z6m6NBtGnRCjTfJ0VMotxTUeEMUaSZnqJHDXTjhuRBt7tcFtnyMnmLVwkgmASHY7i+KGgk1da/Aonq02bKRVuS1AdVMdX3AzRZEBw8LakRd0jOz2PKxS60tGt10wSyubixw+rT345ptqyJaLNb4nq0tIJ0GTpzoLqGWSqlj6VRQ20PLR9vV8hHgBXFUuZOKAM+DKNIJtck8C2rUPEONCbVoK9UsJGICAM+FqNNpdoCL6VFUqlrIJGNIxQ0umkZQazcLFtWjzbRtV8tHvh5Enb4+5LlAdPCwoEbUJYstH/emtUWjm06ojYyo/5450/x4u6/XzweoWWjpNDA+3mgV2U6tpr43lWqevab10PKxnlBjISXS9OJ5PCaQjBucpxdBjZaPKQC8IYo6d2s/vi9EW7lmYTitrit4LkRb0ww1LqZHTqlmIZuMIRWP8ecfQbZs7WbB94Mos+3GhlyeC1Rly0eiA4sFNaIu6YLacqFSTydFzsYG8P737yx4tZJSXS3qhJouWGk6gaZbPe6WUNMFNf18QCOhlskApVLn4zFN9X2plG8tH+s3RzqhxkJKJNWc14K4IdTOY+48j5xSVb0+5VIxGII3RFHX1PLRiui1AgFwCmoZdV3BhFq0WSyoRVbVtGHa0imoMaEWRfq6IBU3EDcEXwMizpKcoUYN9RlqvE4kOnBYUCPqgpQStgRGMgnULIn10i4FpUH1N38DfPCDwJNPdv661gJYu5aPOqE2M6OKY4BKku21oOaVOnOr1borqO2h5aO+OWJCLdosSxfUDKTiBi+GI8iyG+dAkudA5Llbu/F9IdpKNQvDaZVIYHE12urXjIkYypy1Gil60006EUMqwYJaFOnrxJiz+Y5tX6PNsiXihkAiJvh6QPV57FVeGxD1RQjxJiHEi0KIC0KI93k8/q+EEM8LIZ4RQnxBCHFLv38mC2pEXdAXwtMjquizuLVLAWdQnT+v/ru11fnr3C0ak8ndWz5OTABjY+rjsbGdBTX3zDVdUCsUVEEtne4uoaZbPnoV1Hpo+agTamkm1CKtZjdaPqbiMSbUIkjP14wZQDJmsIgScTVX4YSppGgr1+x6Qo2vC9Gm7yNyqTgX0yOmWFP3MNlkXF0nctE0cvR1YtwQSCd4DkSZ7nJkGOq+kdcGVGPLR6K+CSFiAD4E4M0A7gLw40KIu1q+7CkA90kp7wHwSQC/2e+fy4IaURf0hfBYViWYCmWz05cPjsceA154ofH7bgtqugC2W0JNt3wcH+9cUOu35aNOqKXTvrV8rM9QY8uGSDMtppOizq7vPDaQ4kJJ5NU4Q40cpWpjhhqLq9Gmk6tD6TjbvUWMTqhlkzGkE2wNHkWWq4iSTsRYVI+w+iY8IZz7Rr4fRJ2+PmRakagv9wO4IKW8KKWsAvgYgLe6v0BK+fdSyqLz268DONbvH8qCGlEX9IVwNhmxAbI/9mPAgw82fq8LaoVC5+9zJ9S6afnoLqiNjnZXUNveVsW0bls+dkqo1WrquY3uXxJbzwkunEaT6UqoqXQSb4yiRhfXY0KdA5F5fyBPJhNq5FAz1JyWj3xdiDR9zZhnQi1yik5BLZOMOQk1/vyjxmqZt8y2r9FVb//p3DeywE6Nlo88F4g6iAshnnD9enfL4zMArrp+f835XDs/DeCzfR9Uv09AFAX64idy87LcxSope0+o6ZaKmi6QDQ2p/7a2fLRt9UsXuLxaPgJ7a/moZ6h5Fd+q1T2l04DGOZF2zgkunEZTI6EmOBsjomzXzXEqzpaPUafbwKbifD2IunLNQi4ZhxC8Rog6vWCWS8WYUIuYUq2RUFPvC/z5R407oZZKsD18lFmuTXipBDubkKvlI88Fok5MKeV9fjyREOJ/A3AfgO/t97mYUCPqgtXS3i8yN0PuYtWNG41kWr8z1PRMs1xO/b41oeZ+DvfH7oSaPr5MRj1fa6rNTbd87JRQ67GgxpaP0dZIqBncaRhRTQk1FtQir2Y20sssokSXlBKlmoVMMqbSyzwXIq05oRaRewgC0EioNQpqfC2IGndCLZ1gUTXKGnOXBecuE4DGGhLPBaK+zAE47vr9MedzTYQQPwDg/wbwgJTSY2F4b1hQI+qCe5g4EKGWj+l0I9H10kuNz3dbUOs0Qy0WA17xCuDYMTVLzZ1Q01/j9XxxV7BWF9SA9ik1KRsFvE4FtWSy8/9T6/+iLdXFcFy9jFa4WBZJOqGW4KDxyNI3x4ahUklcOI8207ZhCCCd4LD5KKtaNmypzgMumpHefJNLxWHaEibfJyJDz1BLJ5yWj9x4FTl645UhnJaPLKpHlu06F5IssBM4Q43IJ48DuE0IcasQIgngHQAecn+BEOLbAfwXqGLaoh9/KAtqRF3QC6aZqM1QcxfUdLtHYPcZaq0tH2s1VdjSLEsVuN71LuDyZbUS3ZpQcxfUOrV81AW1dnPUdDGuU0Ktl5aPUtZnJgHcVRRV9XSSIZBJxuo7kSk6LOdGKG4Y6uaYi2WRVrOkSqzGDSbUIkzPyUonYjwXaMfGvDKvGSND/9tPxQ2nNTivE6PGbkqocY5elFmu+0a2iSeAM9SI/CClNAH8HIDPAXgBwCeklM8JIT4ghHjA+bL/B0AewF8KIb4lhHiozdN1rasZakKINwH4HQAxAB+RUv6Hlsff6RycjtT9npTyI0KIWwD8NVThLgHgd6WUf9DvQRPdbPriJ5uIWEEtkwFWV9XH58+rotPExN5aPupClZ5jpj+OxwEhVNENAP7ZPwPOngUmJxtf0/p8Xi0f02n1cbuEmk7HxePqa31s+ehOqHGxLJr0zz0eM5BNxuqzMig6nPugesvHMgtqkWZaNhKGQIJt/iJNJxAyiZg6F6Jy3Uie9OabIV1Qq1nIpzjKPAqslnRSZO4hqc69+S4d5xzFKGt0tWCbeFJMJtSIfCGlfBjAwy2fe7/r4x/w+8/cNaEmhIgB+BCANwO4C8CPCyHu8vjSj0sp73V+fcT53DyA75RS3gvgnwB4nxDiqE/HTnTT1Odl6YRaVC6E3TPUzp8HTp1SCbLdCmqtCTWgue2jbvno9l3fBXzykypF5n4OYPcZakD7gpp+nt0Sar22fGRCLdL0a0MiJpBlQi2SLKeVVyzGeQikiux6pmLVlLt/Aw0kvWCaThhIxEV9BzJF046EWojvIzbLNfzaQ8/hysp20IcyEBrzswzV8pHXCJFjSwlDAEIIJ6XIcyCqnFsGZxMeRwUQUK0n1HguEB003bR8vB/ABSnlRSllFcDHALy1myeXUlZdg95SXf55RKFTT6gl1Y1wZHadu1s+XrwInDkDDA3tLaGmC1Xugppu+ehFf76blo+ZzO4FNf3n6oKaV2tIHxJqXESPJr1IGnPauJRYUIscy3VznIpzblbU1WyJRMxAgvP0Iq3kSqix0E7mjoJaOM+HUtXCuz76BD76tct4+NmFoA9nINRbvMU4PyuqTOeeEQATahGnE2pxg4lVUnS3G94zEB083RS4ZgBcdf3+mvO5Vm8TQjwjhPikEOK4/qQQ4rgQ4hnnOR6UUl5v/UYhxLuFEE8IIZ4w3YvoRCHRSKipfzKRmZHjLqhtbqo5Z/n83meoATsTau0Kau62kFo3CbV2M9Tcxbh2CbU+CmoJnVDjRVAkmc5Ww4Sr5aOUTCJEiS0bRdUkiyiRZ1o2EjGBVMxAjQslkaU3V6STMbb/pHpLp3xKdWcI64L6b33+JTx+ZRXJuIFLy7tc61NX6u3+mE6KLMtVUEsl2Bo8yiyrpeUjrw0ir+Zq+cg1BKKDxa/E2KcBnJRS3gPg7wD8sX5ASnnV+fwZAD8lhDjc+s1Syg9LKe+TUt4Xb7fIThQgWzbadSRiIjoXP5lMo1BVLALZ7N4Tat22fNS8Emp+zFDzueWjyYQawd3KRyCbjMOyZXReHwgAYFrNBbXItAQmT6YlEY8JJOIRulagHfSCaToeQypucM5qxB2Ulo/nFrZwz8wI7j0+ikvLbPnoB8u16SYVj8GyZb3AStFg2RJxQ90vphNs8xdljdcDqIQai6uRp68PpWxswCCig6GbgtocgOOu3x9zPlcnpVxxtXb8CIDXtD6Jk0w7C+C7eztUouC4hwmn4rHoXPy4Z6j1UlBzF8Cq1ebH/Wj5uJcZaj4n1GxbOi3emFCLMt3yMW4YyCRUkZhtH6OlPmBcgLtNCVXLRsJQM9RYRImuphlqIW75eH29xB3RN4G+j8g7BbVSSAtqS1sVTA2lcWoyh4tLLKj5wXLeB3SLNwBMqUWMZasZagCQjquEGl93o0lvrjCcNQTeM0SblBI1S9bXEMJ6rUhE3ropqD0O4DYhxK1CiCSAdwB4yP0FQohp128fAPCC8/ljQoiM8/EYgNcDeNGPAye6maymgpoRnZ1l7paPpZIqXnVTUPMqgHXb8nGvCbW9zFBLp1Vhr/UmpoeCWj2hFmNCLcr0LuN4TCCTVBfDRRbUIsWybcQMASHU6wEXyqLNtJwZaiEuotD+08VUfS6Esbh6dbWI73rwi/izx2aDPpSBp+8jRjLqWnO7Es4RB0tbZUwNpXDrZA4r21VsFGu7fxN1pIupxgEoqH3i8at45x99Ax/+8svcHOYjy5aIO/eLKWfhPKznAO2vpjbxvE6MPL0xV6fXeT4QHSy7FtSklCaAnwPwOahC2SeklM8JIT4ghHjA+bL3CiGeE0I8DeC9AN7pfP5OAI85n/8HAP9RSvms3/8TRPvNcvW/T8YjdPGTTqvCVrmsik7ZbHcz1NwFMN1K0V1Qsyz/Wz62m6HW2vIRaE7L6d/vseWjLVVBzTAE4oaIzjlBTfRCSTwmkHUKamHdeU77w7LVewOgZmPwtSDaTNtGPMbZGFG3Y7ZiCF8XLi5vQ0rgtz//UmgLPINCtwYezaprzUIlfNcJpmVjZbuKQ0MpnJrKAwAurTCl1q/G2ADhKqaE7+cPAJ968hoePb+M33j4HB56em73b6CumLaEoa8TQ15Upf1lNc1UZPvPqNOz2PV8Vd43EB0sXQ0sk1I+DIcAS64AACAASURBVODhls+93/XxrwD4FY/v+zsA9/R5jESBq1/8xHRCLSJvdjr9tbam/pvNArat0mCdUma6GOYugPWTUHMn3tzf10vLR0AV3/TH+tiGh72/vw3Tlog7/TuYRIiuekKNLR8jSyfUACDlJNSklBDO4glFS9VSO9G58zja9JpI3BDqGsEKX3uvGxtqI9JyoYo/fPQS3vv9twV8RIPLsm0IAQyl1TVsGAuYK9tVSIl6Qg0ALi4VcO/x0YCP7GAzW7qcAAjt6IC59RL++aum8cVzi3ju+mbQhzMwbNc9Y1oXVWsWkNlbdxQ6+CxXYpXXiVQzmxNqYX1vICJv3bR8JIq8+k5j4cxQC+luooppoVj18SZdp79WV9V/dctHoHNKTSfKwtbyURfRWueo9ThDzXBujpLxcLZzov3XnFBT5y5bPkaLZaNeUEs6i2W1EC6e081hWjaSTkKN7wvRpXcd6zZvYTwXFjZVQe0Nt0/hDx+9VJ/7Rv7Tm7D0DLVCCAtqi5vq2vjQUAonxrOIGQKXlplQ65dlNc/hBsKZTrJsiYWNMo6NZXDn9BCeZ0HNN3pMANBIqJW5cB5J7sRqMm7Alo3NmRQ9OpFWb/lo8TqM6CBhQY2oC6YV/tY9APDzf/EtvOPDX/fvCVsLatlso6DWaY6aV0LN3WbRr5aPmUyjoNau5aNXQq21oNZDy0fTtuu7DdnaK7p0QS1hGK4ZauFbKKP9o9u/Ao2CGl8Posu0JOIGZ6hFnXvRLBELZ1vo+Y0yJvNJ/PTrb8VGqYYvvLAY9CENLL2gnoobiBkilAm1xS11HX1oOI1k3MDxsQwuLrGg1i+raVOmLqaEb9H0xmYZpi0xM5bBXdPDeGF+E7bNzUF+cF8npkPe9pP210GaqUj7T2+20ptteC4QHSwsqBF1wZLN7TrC+GY3u1LE555fwDPXNvzbUepVUMuruQodC2ruhJrXDLV+Wj62m6F2kxNqlo16P/xkLJznBO0/vaswZgi2fIwo093y0dl9HsbFc7o5aq4ZakwqRpfeiGUI1fIxjAm1G5tlHB5O43WnJzE9ksYnv3k16EMaWLrQLoRALhkLZUFtaUtdG08NqWvlWydzuMiEWt8sW0IItYB+ZETds1xba3PPEqC5dXVMM6MZ3HV0GNtVC7OrxYCPajC4E2q6oMaEWjTZrhlq9U14vGeIrNaCGs8FooOFBTWiLlh2+BNqf/bYFeiJPX/3/II/T6rTX14JtU4tH7uZoeZHQi2dbnyum4KaLr75UlBTi6YAQntO0P7TC+aJmEDWSaiVQrjzmPaPV8tHvh5EV82ykYgxoRZ19YRaLLzXjfMbZRwZTiNmCPzoq2fwDy8tYXGzTdqf+uKetZlPxVGohO86YVEX1PKqoHbLRA5XVrYhJTcG9MNyzc+67XAeiZjAs3MbAR/VTnNOke/YWAZ3TY8AAJ6fZ9tHP9heLR+ZUIuk1jUlgF0toqzW0vKRG7SJDhYW1Ii6YNnhTqiVaxY+/sRVvPHuI7j76DD+x3M3/HniTjPUuk2oeRXULMu/GWr6uNoV1LxaPra2h+yh5aMlmxNqYdx9DgBb5RoWN8uhXMwbBJZzkyxEo6DGGWrRYtk2Yq7XAoCtfKLMtCQSuohi2VyMjijTtQs9EQtnW+gbm+V6YuZtrz4GWwJ/8Q2m1PaD6Sqq5FLxUCbUFrfKGMsm6ou8M6MZFKsWNkvhO9aDxGoqpsTwisNDOBvGgpqTUDs6msFth/OIGYJz1Hxiuq4T6y0fQ5xQC2NL0kGhux4ZwjVTMcTnAu2vqqnOh1ySHU6IDiIW1Ii6YDf1v4+FbrH0hflNrBdreOu9M/jBu47gm7Nr9VkIfel1hppXAWyvLR9bv14/5k626eNLp9vPUNu3lo8tM9RCeAG0sFHGaz74edz/G1/AA7/3aOjO20FQc+061zPU2PIxWphQI7eaZSMeM5B0Esxs+xhNdstGrLC9JpRrFla3qzgyrK6jTk3l8f13HMJHv3aJc0D3gbuokkvFsR3Cv+OlrUq93SOgCisAcH0jfO0JDxLTlvViCgC8amYEZ69vhG6zxbW1EsZzSWSTcaQTMZyZyjOh5hOrqeVjeOfoLWyU8Qsf/xbuev8j+MCnn6+3tSf/2M5faXNCLXznAt0cpt2cUAvbtSIRdcaCGlEX9CyMsLZ83CyrG/OpoSTe/KojAIAf+dDX8Pnn+0yq9TpDzWvmWbXa/HivLR+FaDynLpDtNaHmVVDba0LNljDcBbUQ3nQ8NbuGqmXjHa89jnMLW/jzx2aDPqSBY1oSCV1QSzChFkXuVl7JkA8Y/+hXL+Hf/vWzQR/GQKs5rwn6XAhrepn2l+kqqIVxhtriproO0gk1AHjPG05jrVjDxx9nSs1vpi2RcBLMquVj+Apqi1sVHBpqnA/To+rj6+ssqPXDXUwBgLtnRrBerIVujtrcegkzThEVAO6cHsILLKj5wrJlfUyATiWFseXjr/7NWTz87Dxef9sU/utXL+GXP/lM0Ic0cHRCLWa4u1qE6/qAbh59bTiUdgpqIbtWJKLOWFAj6kI9oRbSlo9bZZXCGkon8IrDQ/izd/0TZJIx/OJfPl3fJd2T1hlq7paPnWaouQtgulDlV8tHQBXUEonG7zsV1LpJqFWrPSTUGu17kiGdlfP8/CYMAfzaA3fjdacn8LtfvFAfOk/+UDfJ6q1UpVIMFGvhWyjTChUTNzgjx1eWxI7ZGGG9IfrY41fx54/N4srKdtCHMrBMJ6GmF8/D+N5weXk7dAWeQWO1FNRs2fhcGMw7qSN3Qe2+k+O475Yx/Mk/XgnqsAZWc0ItFs6Wj5vNCbWZekKN1wz9cF8nAiqhBgDPXQ9X28e5tWJTQe30VB7zG2UmVn1g2rI+JkAn1MLY5u/FG5v4wbuP4E/+j/vxw/cexZfPLwV9SAOnkV43kEqwoBZ19ZaPTKgRHUgsqBF1wb3TOJUIX/Fky0mo6d0trzs9ifd872lslGo4v9ih8LWbXls+6mJYPy0f3QU1d8pM/zfTuOnrqqC2W0Kth4KaXhxJxA1UQ9jW6/nrmzg9lUc6EcO/edMdWC9Wcf9vfB4/++dPBn1oA6NmNVp/AqrtYznECbVfe+g5vOU/PxrKVjMHlXvY/GRevcbMhWznOaCKqS/dUK/bn/rmtYCPZnDVnCRKWBNqV1a28X3/6Ut44299GY+eXw76cAaWu6AWxlawC87GimlXQQ0A3nD7FC4tb4ey4HOQua8V1Ay1cL0HSymxVKjgkKugNpVPIRETTKj1yV1MAYA7jgwhZgg8G6I5alJKlVAba9xbnZpSHUkuLXMDTr9s2diEqWeohS2hVrNsXF8v45bxLADgzKE8lgtV3i/4zD1fNRXijVeAel347LPzoT2+QaDvEXRBjeM5iA4WFtSIutC0MBKLhW4nkU6o5VONItVrT44DAB6/vNr7E3sV1LJZ1Xaxmxlq7paPrQW1Xls+Auo5065FoE4z1PTztEuoSdl3QS3MCbW7jw4DAL7t+Cg+/S9fjze8YgqPnF1gX3yfmFajjQsAZJOx0LZ8tG2Jvz+3iOVCBQ8/Ox/04QwM97D5248MIRk38My19YCPaqdnrq7DlsBIJoFPPTnXX3qZ2jItG4mYqCfUwna9MLtahJTAUqGCn//YU6Gb4zModFsnQwgknPeIMCVXF5zU0eHh5oLamUNcRN8P7mvGfAhnqG2WTFRNuymhZhgCh4fTmGdBrS+2q6MFoAoqtx3K47nr4WmnuLpdRblmNyXUbp3MAeBrgR9MqzEmQHcyKIcsoTa3VoJlS5yYUAU1PUNxnglVX+k1JcMI/9zlb11dx3v+7El85tnrQR/KwNIFtXxKrXGF9VwgIm8sqBF1od7yUaiEWth2jxTKJoQAcslGQe34eAaHhlJ4op+CWmvLR11My+f7S6h1avmov94rodauoNZty0f9Pe7im54OvMeCmnvIeCpuoBqyc2J1u4r5jTLucgpqAHD30RH84N1HYNmyvjud+mPaEnGj8VaaScZQDOluznMLW1jZrsIQYEsvH1l2o+VjImbg7qPDePpaeHaea09dVUW+X/rBV2BuvYSvX1oJ+IgGU81SrwmpkCbUVgpqnulP3H8CK9tVXORi6b6wnNR63GkVDoRroWRhs4x8Ko6hdPO1z2knlfLyUh/dDWgHs6nlYzx0CcD5TXUNfailwHp0NIPr67xe7IfZMkMNAI6PZ+tF7TB4cUHd051w0kmAq6C2xPeIfnkl1MK2ljC7WgSAekJNF9SYUPVX8xgRfS6E59rATXc5OjsXnuL/oKkn1JI6oRbOc4GIvLGgRtQF03In1AzULBmq3f2bZRP5VLy++w0AhBB47clxPH55rfcndifUhGjMQxsa6m6GmjuhVq02Ht9ry0f38wF7K6i520V6JdTcLSH3oCmhFjdCtfMcQH2Q+F3TI02f17tPw9iS7iAybXtHQq0U0oTaoxfULIR/8T2n8K2r63g2hEWfg8iy7abFsm87NoqzcxuhmpcEAE9eWcPpqRze/prjSMYMfOlFzsbYDzUnoaaHzYftvWG5oN7/3vjKIwDQ36YbasuSzTPUgHAVVxc2yjg8nNrx+RMTWcQMgZf7aRdOO6g5Wo2EWs2SoVpQP39D/bzPOAVV7ehIGtc3eL3YD1vuLKgdGkphMUQzjf/6qTnkU3G87sxE/XOZZAxHR9LcdOEDd1E1rAm1K7qgNqEKqfX7RRbUfGW5Wj6GPaGmN9Y8H6I07aDRI0PqM9RCdJ1IRLtjQY2oC027iRLhWyTbKpsYTu9MWN13cgxz66XeL4Z10Wpzs5FOA1RBrduEmi7CtSbU/Gz52G1Czaug5m4JuQdNM9RiAjUzXIvn+uL3zumhps/r+Qi8QfKHaTW38skkwlxQW8GZQ3n8i+8+BQD4BhfSfWFJNG1muOfYCIpVCxdCtCAtpcRTV9fx6hNjyCRjeM0tY/gK52ftC9OZoVYvooTsvWGpUEEyZuDeY6MYyyb623RDbVm2hCHU5iZ9LlxYLIQm+TW7WsRxVxpFS8VjODGexctMpfjKnWbPJdW1bJjmqJ2/sQVDAKemck2fPzqawcJGOXQbRA4Ss6XlIwBMDaWwul0NRZF9u2LiM8/O4y2vmkY22by58NRUngU1H7hn7QqnkFIJWTeL2ZVtpOJGfY7i4eE0hGBCzW96Tclwz1e1wnUuaC8vqn/7z89vsj34PjFbZqiFtbgqpcSnvnkNP/vnT+LXHnqO5wORgwW1A05KiV/6y6fxCx//VtCHMtBM2yOeH6KdZVvlGobSOxNWeo7ak1d6XDBzF62yroWX3Vo+djNDbS8Jtd1aPnaaoeZOoHUqqO01oSbDn1A7PJzCRL55BzoTav4ybbu+WAoAmWQ8lC0fyzUL37i0gtefmcRELom4IepJFeqPZdtNi2XfdnwUAPD01fDMUZtdLWJ1u4pvPzEGAHj9bZN4YX4TSyHaIT8IbFvWkyhhXShZ3qpiMp+EYQjcd3KcCbV90ppiB4D3/Ok38a//8ukgDwuAune4slLEyYmc5+Onp3KhKfwNCvf7hF44C1PbxxdvbOHkZK7ejk47OpqBaUteL/TBsu2mTTcAcGhI3cOE4e/1kbMLKFYtvP2+Yzseu3Uyh0tLBS6e9sk9JgAA0nEjdK3drqwUcWI8Wz9Xk05xjfeL/nIn1HRaMUxrSm4XlwowBLBRquF6iFrUDhK9qSIVN5CIidC9LmjPXNvAL/7l0/jqhWV89GuX8YePXgr6kIhCgQW1A+5P/vEKPvnNa3j0Anea7yfbVVDTCyOVEC2SbTktH1vpWRi6L/qeGUYjYZZpDKpGKtXcwrGVO1HWrqDWS0Ktn5aP7RJqfrR8jMVCt6NodrVYn3/glk7EMJlPMqHmE9NqbuWTTcRQqoZnkUz7yFcuolyz8ca7j0AIgYl8EishWMgZBFbLQsmtEzkMpeJ4+lp4Cmo6sfqqGdUC9vVnJgEAX3uZ1w5+qjkzORMxAzlnwPhWOVyvB8uFCiadHeivPTmGyytFLG5xocRvzSl2dd24XbVCMTdpdbuKQsVsmpfkdtpJpTCV5B/3tYK+Xi+EqKD20o0Cbj88tOPzR0fVtTavGXtneSTUdApocTP467DPPDuPE+NZ3HfL2I7HTk3lsFk2sbLd4Z6PdmW1zNFLJ2Ioh2zz3exqEbdMNL8nHB3NsOWrzyyPNaWwbcoFVFLqymoR33FKtYFl28f9oVs+JmIGkjEjdOtJ2vPOKJH//rPfhR+86zD+w2fP1ceLEEUZC2oH2LPXNvDrn3kBybiBpa1KqHrxD5qw7yYqVEzPhFomGcNYNoH5fi6GdeHKnVBLJJoLZK3ciTJdqGpt+djLDLV+Wz7q4qDPLR+T8fBdAM2tlzAz6r1YNjOa4eKIT2q2RNyVUMsmYyiGrOXj5eVt/OcvXsBbXjWN7zytbowm8yksF7hA4gfbRtNCiWEI3Hl0GC/d6JDivcnOLah2XrcdVpssXjkzgpFMAo+y7aOv9LzVuCHqCYQwzckBnIKak1y+z0mxv/tPvolPffNakIc1cNyF9mS88fqwVKgEnva4vKI2WZ2cbF9Qq5o2rq31uBmLdjBdM9TCllAr1yxcWdnGbZ4FNbWZjm3fetdaTAFUy0cAoUiJn53bwH0nxyCE2PGY3ph3iW0f+9J6DqQSRqgKalJKzK4WcWJ8Z8vX6+vBbwIZJJ4FtZCtIQDA7KraVPOWe6YhBAtq+6Xm/OyTMQOpRPg2aGsvLmwhl4zh+FgWH3jrK2HaEl+/uBL0YREFjgW1A+zYWAY/8u0z+OU33g4Aodj1Oqh0y0fDaBTUwrSbSLV89C4IHRnJ9Hdu9FJQcyfKhFBf70609dvy8Rd+AXjPe5qPsV3LR3dLRyFUSs39tb22fHQvlsUEqpYd+CKZVrNs3NgsY2Y07fn4zFiGLTx80truL5MM3wy13/3iBSRjBt7/Q3fVP6cKasEv5AwC07Z3LJaNZRPYLIVjsRQAzi1s4lZXO6+YIfCdpybw2CW2+/OT6dppOlVPIITr2kwV1NTmkm8/Pop//cbbsbJdwb/962dDMc9nUDS1hXauXcZzSdQsiY1Sh+unm2B2VS2Oty6eaqcPqc+z7aN/TFsipmeohSyhdmGxAFvCM6E2PaIKavNcVO+Z6VFQOzTsvD8EXFBb3a5icauCO48Mez5+alJtwmFBrT87EmrxWKhauy0VKihWrR0JNb0BMyz3t4PAku4xIs4m7RCdC9oFZ37aPTOjuHUyh+fnNwI+osGkr7sTcRHqhNoL85u4/cgQDEPg8HAKyZjBtWcisKB2oI3lknjw7ffgrqPqIpiJk/2jB8jGjXAm1LbK3gk1AJgeSfe3u6zfhJrX1/fb8vEnfxL44R9uPJ7JqNSZ7fEzaW3pmEr51vJR7zbWO8xqVjhuOBY2yrClKpx54Q2Sf2pWcyufTCKGUoh2nQLAc9c38NqTYzg83CiwqpaPTKj5wZLYsVg2lE5gqxzsornbuYUt3NGyYHbLRBYLm2W+DvhIb7RJxATSiRhGswncCEFLL822JVYK1XpCTQiBn/2+M/g3b7oDFdPGufnwpCoPOvcC6itnhvE/3TONn3nDaQDBp1IuLxchBHB83PsaQS+iX1ziIrpf3Jtv8vWEmhWKIrZOU99+JL/jseF0HPlUnPeYffBKqOnX4KDb7Z5bUKmTO6Z3FlOBRpKO14v9sWTzvUI2FQ9VO+hZJ7V8orXl40gaVdNmy08f6TEihlAFFCCcBTW9oebUVA53Hx3BM9c2eL+wD/Q1QNwwkIwboew4JqXEuYUt3O7cRwohcHgkhYWQbRgkCgILagNgpt6Ogy9q+0Xf76rdRKoQFKY3vK2yiXybgtqRkXR/b3h6dpp7htpeEmpeX99ry0ejzUuWPjavlJppqu/T39taUOuj5aMhmgtqYUkt6tY8ulVPq5nRDCqmzZZ/PjAtuz4fB1AtH0s1KzQ3HZYtcXF5G2cONS+UTeVToWg9Nggsj4TaUDo8iyXbFRNXVoq440jzgtlkPoWqaYcmJTEITGdTh24De3gojRshuuHcKNVg2hITzmKu9uoTanbOk7NrQRzWQLJciaTRbBK/9xOvxt1H1QzDoAtqs6tFHB3J1K9nW41mExhKxXGNSXbfuGeo6fmKz89v4O5/9zk8E/C8zZduFJCMGbhlYmdiUQiB6ZF0f63jI85rhloiZmA8lwz8tUBvomjdcKNlkjFkEjGsFXm/0A/TkjBc58DxsQyuhqil7hWnoHbL+M4ZagBbvvrJ3fJRiPCmkl5eKmB6JI1cKo77T45hfqOMq6s8D/zWmKGmWoCGZS3J7cZmBRulGu50bbyYHu6zAxbRgGBBbQAcGVGpA17s7B/LWSQzXDPUwnLxU65ZqFo2htu0fDw6ksbqdrX3Xu37lVBrV1AzDNWasbXlo/68F11Q85qjVqs1F8v8Sqi5dhvqHWZhOSfmdiuojWWbvo5617rzOJOMQ0qgHJIE67W1IqqmvaOgNpFPomra2GIxpW+WjXpxXRtKJ1ComvWdqEHS6YM7ppsXzCactn8srPvHPUMNUG29boRgRo62sq2ORbd81KZH0jg8nMJTLKj5Rr03NH+uPjcp4Ha7l1e2d7T2chNCYGYsw4KajyxbIhFrTqh98dwSqqYdeDu9cwubODWVa9oc5MY5Sv0xXRvw3A4NpQJv+XhuYROT+WT9tcnLeC6JVSaU+mK3JNROTuRwba0UioQqAFxZVanl1s4m+j6SYwL8o5vZ6LERqZCmkq6tlXDcWS/4jlNq/jZnZvlPbcwNd3H1BZ1kdm28ONzvhn2iAcGC2gBIxWOYGkqxoLaP9PVu3DVANizxfJ0uaNfy8Ygz/6DnXfK9zlBzF8D20vIRUMWt1oRap4KXPkavhNpuBbVeZ6i5dhsmnV3eYbkI0q8FMx0SagBvkPxguhbJAJVQA4BiNRyFqguLqmVHa0FNtxtiG5/+tc7RA1SbLCmBQgjOg3MLegd6c0Jton4OhKfgc9DpxTF9nXB4OB2qGWpLW+rf+1RLQk0IgVefGMOTs8EmZQaJSqU032bVC2pBJ9RWih0LagBwbCyLayFKUBx0lscMNd1urxjg3FUpJZ65toF7jo20/Zqjoxkm1Ppgu1rEu02FoqC2sx10q7FcAmssqPWldY7eiYksLFuGZu1mdmXbM7Ws37OW+fP3Tb3lo3N5kIyHs4iyXKjUf/5nDuUxkUuyoLYPaq5ON8OZeCg3L+gk8+2u+8jpkTQWNjg2gIgFtQFx1JmJRPujnlBravkYjosf3Vas0ww1oI+WoLpYtdeWj+6CWTIJVKvNj3cqYHkV1DoV4Dol1FrTcH61fHTtNtQFlbDsNJxbL2Eil0Q64f13pgtqXCDp386Emvo7D8sctXpBbWpnuz9A3TBRf7zmo+jX4zC0fTw3v4l8Ko5jLTuPJ5lQ812tnlDTBTW1YBqGpCLQ+Pc+6ZFG+PYTo5hdLfI1wSeWLXd0qR5Ox5GMG4EW1DbLNaxsVz3b+7kdG8tgbo2zVv1i2u5rRjUrRf/VbgeYFL+2VsLqdhX3HBtt+zVHR9JYLvTR6SLiTFcx1W1qKIXlAF8LLFvipRtbTYukXsaySayy5WNf7JbrxJPO6+/llXBsWriyWsSJ8Z2bLEaz6t54PYSL/AeVJRstH4EQF9S2GgU1IQS+49QEvn5xhdcEPqtZsl5Qu/3wEF66UQjNPQOgOmH9/YuLmBnNYCTTWCs7PJxGxbSxXgzPvHCiILCgNiBmRtOh2eU0iJra+7laPoZh9+5WWb2RDaW8C0K6JejCZo/nhy5W7bXlo7uI5f5621a/9lJQ2y3RtpeWj+l0c5Ktx5aPpu1OqIUrtTi3Xt7RtsNtOBNHzBC8CPKB2ZJCyDhFzFKAO87dLiwWMJlPYSTb/Pqg2/0xndQ/W8KjoKb+vvXrc5BeWFALZqKl5RSLqv6rDxd3NlkcHk7DsiVWQrIYVS+o5XcW1PQctaeYUvOFum5svs0SQqj5lQEuos+2mZXT6thYBlsVExul4F/DBoFpNc/a1G0fAWC7Etz1wtPO/LZv61RQczZhcV5Kb2wp4RFQw6GhNJa2gptle2VlG+WavSO93mosm2RCrU+mLest/gDUE8KzK8G2e9XapZZT8RjyqTgLqj5yz1ADVMvHstP6NyzFqnLNwmbZbGoP/h2nxnGdc9R8V3Ul1O6YHkahYoYmJFGqWnj7H3wNj19exbu/51TTY0eG9foirwsoPIQQbxJCvCiEuCCEeJ/H4ykhxMedxx8TQpzs989kQW1AHB1RCbWwvBEPGstGvXiiZ6h988oaXv/g3+PZaxtBHlo9AZHfJaE23+uNcK8tH90FMPfXW87CgZ8tHwNIqNmu3cZhm6s3t1bE0ZH2BTUhBEYzCayXeIPUr9Z0UqPlY0gKaksFnDm0M4mgW74tMZ3UN9O2Q5tQk1Li3Pym54LZeE4XVXkO+MV0Fkr0XM1DQ+r9s+eWyz5bLlQQM9TrfyudUri4VLjZhzWQ1NyknZ8/NJwKdIaaTi2fbmkD3OqYMzuFc9T84U6oAUAu1bgG3g6wNfAz1zaQjBsdU0rTo5zV3Q/T8k6oHRpKoWoFt8P/ueuq5eid051bPnKGWv/slpTioaEU0gkjFAm1QsXEynYVJ9q0AR7NsuWnn+oFNdHYlPvI2Xl833/8Uv3fZND0JjD35qvX3joOAHiSs3Z9VTNtJJ0dF/p9WLfqD9rjl1dxdm4TD/7oPfip151seqy+YZ8bbSgkhBAxAB8C8GYAdwH4cSHEXS1f9tMA1qSUZwD8FoAH+/1zWVAbEEdHMyjXbKwxcbIvLNtuDI9NqH82Z+dUIS3onRn1hFqbglo2GcdIJoH5fls+7jWhtltBzc+WjwHMUHPvNqynFkPQ8lFKieu7JNQAYCSb4OuFD8yW+VmZEBXUpJS4sFjYMT8N9+YVzAAAIABJREFUAMacYkqQ7YYGhW2HN6G2sFnGZtnEHR4LZomYgdFsggk1H+1MqKnFiMWtcNxwLm9VMZ5L1jcIueVTqh0hd6L7w/aYoQYg8ITahcUCYoaotxxrR7eIDUMnhkHQuvkml3Qn1IIrqH3r6jrumh6uX8d60W3Cr3PhrCfqZ7/z8/WZigG9B5+9voFkzMArDu+eUNssm6Fpa38QmS3ngBDqNfhKCApqjdSy93vCeC7J+0UftSbUMsl4vV14WK4V9TXKlKs9+LSzUTfoGbCDpmbZiLtaPgKqVX8Y6DXO7zg1seOxRgescJyzRADuB3BBSnlRSlkF8DEAb235mrcC+GPn408C+H7R2sJnj1hQGxC6HQd3D+4Py0aj5aPzpndxWe3yLQa4sxRoJCCG0+0TVtMj6f4TanudoeYuULlnqHVTwNrPlo+tBbUeWj7a9YthdS7oqH4YbjbXijWUalb9NaGd0UwCG7xB6ptlNS+S6dRPkAkEbWmrgq2yiTNTOwtqiZiBsWwCK9vBH+dBZ7o2XGhhSajpQdLtWjpN5JI8B3xUL6jVZ6jphFo4/o6XCpV6OrWVEAITuSRWmVj0hbsttNvUULAFtfOLWzg5ke1YQAGA40yo+cq0G3NSAFXAziRimBnNBFZQs2yJs3MbuPd4+3aPQGPhjPeYvfFq/wq4CmoBvR6cndvA7UeGdn0tGM85c7R4z9AzS+5MKZ4Yz+JKCFo+zq6qY/Bq+Qg4LT+50cY3tpQQAvU27L/6ljvxm2+7B0Dw9wya3mzpTqgNp+NIxERoWpgPCjVDTZ0LuVQct0xkQ5NQ0+mzQ8M77xsODaUgRB8dsIj2Li6EeML1690tj88AuOr6/TXnc55fI6U0AWwA2Fkx3gMW1AaE3j3IG9/9Ydl2o+WjMyNp2Vl0CnpWkr74apdQA9TN8E2fodZPy8dEYm8tH3XBzOuY9qHlo1kvqKnf67lZ528E3ypLL3jM7FZQyybZ8tEHpi3raRRADRoXIhxt0y4sdW7tNZlPYXmL50C/3C2BNf16vBnwzfELC2qXY7t2XhP5VP29jPpnOruM9c2xXjANS8vHa2vFjulltvbyj90hlbJarAa2Aef8YgG3HeqcSAHUrNWhVJz3FT5pTaidmsrhu85MYDiTwHZA9xEXlwooVi3cc2yk49el4jFM5lMsqPWo9Wev6euEQgAFVSklzs5t4pUznX/2QKOjAYsqvfNKKZ6czGF2tVjfpBkUnZJr1/JxLJvgz95HVss8vdeeHMcbbp8CEPw9g6Y3hboTakIIjGWTWOUmPF/VXDPUAJVS0/duQVvYLGM8l0Q6sXPNLhEzMJlP4QYLanTzmFLK+1y/Phz0AQEsqA2ME85w8TDsdBpEandh87wsrVQLR0Etl2pfcJoeSffe47jXGWruIpb763tJqO3W8rFTQW0fWj7asjmhds+xUbz6xCj+3UNn8ZXzS10/z37Qi1+7FtQyCe429UHrQkk6EcOxsQxeXgr+tfhlZ1aOV8tHAJjIJ9nuzwdWS9tPoJEYDrrl47n5LcyMZtommKfyKZ4DPjJt3fKxkV6ezCdDkVCTUuLqaqmePPIynkty97FPTNt7btLUUApSIpDCZcW0cGWl2PY9wU0IgZmxDFs++qS1PfSDb7sH/+Un70MuGQssoTa7qn62pzxS7K1mRtNs+dgjrzmrQKPtZxA//2trJWyUanjlTOf5aQAwnlUFNW626I2U0rlX2JlQq5g2bgTc5u/KahFj2UTb68SxXBJr27xf9Isld6bXdZv4zVI4/p51Qm0in2z6PDdd+a9m2U0p4Tumh3F5eTvwDfuASqjpThtepkfSbPlIYTIH4Ljr98ecz3l+jRAiDmAEwEo/fygLagNiJJvARC6JS8vBL+IOIncCIW4IuLt7BT0raatcQyYRa9rd0mo0m8R6sQYpe9gF167lo22rX146JdR0AatTgSweby6O7dbycS8JtXS6edZaDy0fWxNqybiBP3rn/Tg+lsVvPvJi18+zH+oJtS5mqLHlY/9Mjzk5p6fy9WJWkC4sFpBPxXGkzcXwZD7FxXMfeO0+T8UNJGIi8PYtLy5s4c7p9mmUiXwSK0yo+UbPwXAvnB8aSmMxBDecy4UqSjULx8eZULsZbCkR8+jKr1tuBtHm7fJyEZYtcdvh3QsoAHBsLMuEmk9a3yeEEIgZArlUPLCEmr5ePDrafsFMmx7JMKHWI685qwCQTan7miB+/noO+Kv2kFDje0NvdACtdePVcWcz9FzAr7GzK8X6xmwvY9kkChUTVTP4sQaDwG5JqAFAOmEgbgR/z6AtFyoYySSQijevvUzkeY3oN9XysbGOcOeRIdhStecO2sJGGdMj7a8PDg/3sWGfyH+PA7hNCHGrECIJ4B0AHmr5mocA/JTz8dsBfFH2tEDewILaADk1lcPFEKQiBpHlmpEjhGhKqQW9g2SrbHZs9wiotIRpy96Kf+0SakD7lFqnhJpu+bjXhFo3LR+rHhd53SbU9tDy0WqZoQaoAtV3np7AXMALDnPrJaQTaj5WJ2PZJLYqHDLeL69iyumpPC4uFwJv43JhqYDTUzm0m7WqWj4Gn5w56Gy5c7FMCIGhdCLQhFrFtPDyUqFtu0dAnQMbpRoXSnyi3xvcbWBPTeXw9LWN+mNBueokjTotnLGg5h/T8p6bNBng3KQLu6SWWx0by7Cg5gMpJWqW3LGgDgC5VHAJtbn1MpIxA5M577mKbkdHM5hfL/W2MS/iWtOJWj4VXELt2bkNxA2BVxzevf3rOAtqfdHJ9dbrxPqs3YD+/Wtz6yUc61RQc37+62z76AvL3llcVfcM8cC7WmhLhQomW9JpADCeS/F1wGdVy663iQeAW6dyABoJ8iDd2OycUDsyzIQahYczE+3nAHwOwAsAPiGlfE4I8QEhxAPOl/0hgAkhxAUA/wrA+/r9c1lQGyC3TuZwkQm1fWG17C5MunaSBJ1QK1R2L6iNZJxWAr1cqLWboQZ0Lqi5E2XJZKPYFbaWjz0k1OoFtZb74+mRNFa3qygH2Ab0+noJM6OZtkUUbTQbrvYSB5XXQsnpqTzKNRvXN4JdiLywWGg7Pw0AJvOqqBrk+ToI2rVzUjfHwS2UvLy4DdOWuP1I+5ZOup0Lb5D9US+ouc6HN79yGsuFCh671FdHib5ddW7Oj3dYOJvIqZ3oFZOvCf1SbZ12fn44wEXU84tbEEK9R3Xj0HAKhYqJYjUcu+YPKl1L92oBmkvGUQxoQf36egnTo+kd7ce8HBlJYbtqBb74fxB5zVkF1PxlIRDIz//s9U3cdnjIczZOK32/sMbrhJ7oZi6t14lBFlQ1KSXmnPvGduotP1lQ84Vl256vB2oTXjheX5e3qk3z07QJtgX3XesMNf1vMejNTBXTwsp2tWNCbWpIbcrkPQOFhZTyYSnlK6SUp6WUv+587v1Syoecj8tSyv9ZSnlGSnm/lPJiv38mC2oD5NRUHsuFSm9FE+rIalkwTbluQEq1YC9+1kvVeu/tdnRBbaOX4kkvCTU/Wj66C2q7tXxMJtsfz24tH/tJqLW02Twyoi6Cgoy/z62XcHSX+WlA45xYZ0GtL94JNbW7LMg5apvlGm5sVjomESad1mO8OepPu3ZOQRfUdLuQ2zvsQJ9wkgmco+YPr/TyP73jELLJGP72mfmgDgtA4+b8WId2wOPO+cACa/8sj3bAQGPebRCLqOcXCzg+lu1qER1otKdc3uL50I/GbEWvhFochQALakdHdr9eBFDfpX6D7Z32zGvOKqBSKblkHIXKzV+MfGlhC3d2SK+7peIx5FNxFlR6VE+oifAV1Fa2q6iaNo52WDQfqxdUeb/oB0vuvG8EEMKE2s6C2lg2ia0y23/6qbWgNpROYDSbCHx+7aIz+7nd2AgAODSk7yH53kDRxYLaALl1Ui3iXmLbR99ZsnnHeZhaPl5eLuLkRPsd54CroNbLzKx2M9SA8LV87Cahlk57t3zsKaHWfEGsd/HMB7jgcH291HHBVBvNsoWHH9QMtZaCmlPECnKOmv6zz3RIIkzUF0tZTOmH6WoJ7DaUCrbl48uLBRgCODnZ/v1haki9DrCo6g/TI6GWScbwA3cexmefnQ+0xe7V1SIm80lkk+3f63RrL87V659lS89d6PrvP4hF1MvL2zjlbPjoht6hvlRgEaUfXslVLZeKoVi1AmmleL3LDVhAY1GN7Z32zvTYeKVlk7GbngDdLNewsFnGmS5nKQLAWC7BhFqP2iXU9OaKIDdeNeYotn8d0C0f13i/6AvLBgyve4aAN+G5LW95F9TG8zwX/FYzd64jhKHdtl7LOtKh2H5oWJ0jYZgTTRQUFtQGyCldUGPbR9/ZLQsjSaegNjOaCbTlY6FiYm69tOs8jL4SakPODsZhV9swPxJqN6vlo1dCzbIaz99Ly0fpvTiiC2oLm8FcBJVrFpYL1a52HI/qhFovRVYCoF4XpNzZxmkil8RIJoGXl4IrqHUzK0f3x1/ZZkGtV1JK2NK7nVPQN8cXlgq4ZSK3Y6i4Wz2hxqKqL6w2s1Lecs801oo1PHllLYjDAqBmqB0b67z5hi1A/WPLNjOzkurf4/ZNTqVIKTG7UsQtHVp+tpoKcN7bIDHryVXvAqtpS1Ru8o5/07KxsFnGzGj7xTI3vagWZAeGg8q2peemG0CllG52QlFvuLrtUHcJNUC1/Vvl/UJP2s1QC+q9wK2rglqW1wV+sm2JmMcKbFhaPpZrqrVvu5aPADdd+cm0bSTizSfEsdFs4AU1vXmmU0FtKq8eW+Q1IkUYC2oD5MREFoYALga4iDuoWhMIqXgMQ+k4poZSKAU4f6ieQtnlpqivgtoP/zDwqU8BZ840PtdPQm0/Wj7uNaEGNNo+9tLy0VKLI62L6EcCTqjpG6OZrhJqLKj1q55GaWnjJITA6alcsAW1pQISMYETHRZPJ9nOq2+dkgdB3xxfWCzU24+2o3cX3tjiIqkfvBJqAHCLkyIPMgk4u1rsOD8N4MKZn0xLeu5Cj8cMpOLGTU+lrBdr2KqYu54Dbiyo+UNfM3YqsN7szXk3tiqwZeeFdLd6y0fuRN8z05aIebT7BICsk1C8mc7XC2p7SaglmVDrkd6E2VpQi8cMZBIxFCrB3YfNrat/z51mqDXuF/nz94MlvQvsw+lgu1po+v1+yiuhluM1ot8sj043KqFWDCS5ri04c+C7SajxGpGijAW1AZKKx3BsLIuLTKj5zmqZkZOKG5gZzTitOoIrqOkUym27tO3oe4baj/5o8+d6SahVnYuvMLR8BHYW1HxIqGWTcYxkEphfD2bBYa6LnYbaaMZp+cgZaj2zOuw6PzSUDnQH30sLWzg5kUPcaxuko15QY0KtZ+0WSgCVUAtqpqlp2bi0vF1vP9pONhnHaDZRL8ZTf9q9JmQT6v0lqOsF07Jxfb2M47tstqjvPuZiSd/aJdSAYFIps6tqHsctE923fJzIpWAILpb0y2wzdxcIbqZeN8kUt3QihtFsgi0fe+C1YKqpGWo392d/YbGAZNzYU3F9PJvkInqPOt0rqBmKwSbUMs6/7XbSiRhyyRhWOUPNF61dj7Sgu1poOm3UMaHG+0bfeLUEPjaWQblmB3otvrBRQTYZw1Cq/frYRC4JIZhQo2hjQW3AnJrK4SJnqPnOsu2mN7t//qojePtrjgVeUDu/qFIou7XwGUrHIQSw6deFWi8JNV1IC0PLR6BRUOul5aPTvsPrgnh6JB18Qq2LBZKhdByGADa447Bnuo2L91yUeGCDxk3LxuOX13DfyfGOX5dJqptkJtR612mhZDitFsps++bvMJxdLaJmyY4z9LSjIxlcD2gTwKAxLe/zIeOkUEo3OZWkzW+UYdly1wXUkUwCMUMwieCDTnOTgnh/uOIU1DqlllvFDIHxXApLBS6W9GO3awUA2L7Jrw17LagBao7awgbPhb1ql0gB1M//ZqdVz9/YwqnJXNvXJy8T+SSWC5VAExMHVafrxHwqFti9AqDnKKYh2pyf2mg2yYSaT6w2m22G03EUqsHcM7jNrqp1RK/rRSbU/OedUFN/90G2fVzYLOHISOfXhnjMwEQuiSV2OaEI66qgJoR4kxDiRSHEBSHE+zwef6cQYkkI8S3n17ucz98rhPhHIcRzQohnhBD/i9//A9RseiTNG999YLXMyHn395zGu777FDLJOMoBtny8sLiFU5P5jikUQB17PhXHpl9ppG4Kau4CmLtAth8tHw1D/bpZLR+dURdeF8RHRtKBzVCbWyvBEJ3j+ZphCIxkEkyo9aHTTfJQ+ubvOtaevraOQsXE689M7vq1k0MpLPM9o2f1c8BzwHgCUt78hVIAeNnZWLPbfE1ALagyoeaPtgm1gNq6aVfXVDHl+C4z1AxDYCybYELNB3aHglo2GcP2TT4XrjoFtePj3RdQALVLnQm1/rQrtAPBJdQaHQ26m6EGqLaPbPm4N+1m7WqquH7zWz7edrj7+WmAeh2omDa2Aiz+HFSdrhPzAd4rALqgtvt7wnguiVUW1Hxhtk2oqXuGQkAbr7SLS9uIGd4jA0azKpHETVf+UZuvWmaoOddp15xr9yDc2Kzg8NDu1wdTQ2leI1Kk7VpQE0LEAHwIwJsB3AXgx4UQd3l86cellPc6vz7ifK4I4H+XUt4N4E0AflsIMerTsZOHkYzaQcQdZP6y27TryCRu/hwMtwuLha4WTAG187ynlo9eumn56E58xWKNwtV+tHzUx1T1uMDbLaHWQ8tHvdvYaz7K9EgmsKHtc+tlHB5OI7FLgVVTOw5ZUOtVu3lJAJBLqQXTIF6LHz2/AiGA152e2PVrJ3JJtu7og/NS0LaoCiCQFi66HfBuLR8BYGY0XV9cpf402gE3vwZnEsEW1K6tqp9vN+mk8VwSq3xN6FunhFo+gITa7EoRU0MpZJPdX+sALKj5odOsTT1D7WYXVa6vlzCWTezpfDgynGbLxz2qt/tsc1meS97chFKxauLaWmlP89MA1cYcABY3+VqwV+3mLQPBtPx0m1sv41gXc7c5Q88/tu2dWA3ynsHt4vI2jo9lkIzvfNGKGQJj2eT/z957x8dxntfCZ7bM9oYFFp0AO0WKpLpkS65yTeKaxIkdJ7Fjx/cmcZL7fSn3OvVLbpqTL44TJ3biOMVyia8t9y7bsiSrUBIlir2AAEH0sgC215l57x8z72IJ7s5OBziY8/vxRxDcHS6xs+/7vM95zjnO0JWBaKVQo05Dm6lQSxeqLW0/NyIV8TmWjw62NZR0Xe8CcJkQMkEIqQH4HIA3Kbk4IeQSIWRM+noOwBKAHq0v1kFnJIJe1HmyqTaEdgQnCC2LnyDr2bSfdaXOY2q1tDUJNSUKNSMtH+lr0qJQo89pMz3aCoKMQq0/5ke6UEOVs/6+mF4rKbJ7pHAUavqwrkZpnYvCCwRVTrD6ZeHxy8s4PBhDQrLmkEN32OdYPuoAJddbE2riurNZhFpv1Ieov7PydiAeQL7CbVrem53QTqHmcjHwe10ob5KifXqtBBcD9CtQo4iEmrMm6AW/5Swfi6rsHil6wg6hphfrDfWtk6E2tapMmdKMvpgf6UIVdd76uuZGhUDa14kAtXy0bl+gsRBqCTXaWHXWAvUQZC0fN88evlLnkS5UMRBTQKgFvY5CzSC0qw3WzwybW4tPLBexs7t91qpTIxoLjheuux8ifi/iQe+mKtTS+SqS4c59BGfoysF2h5IO8iCA6aY/z0jf24iflGwdH2QYZnjjXzIMcxcAFsB4i797H8MwxxmGOc5xjpWAHtBQ2TWn6DEUgtC6EA6wbpQ3iVA7P5+DQIC9vVuQUNto0ejxXJ+hptbysZOCjGXXX08ut/59JZaPXi/QwT++GXJNdGq3uLgJORNX0vJF8EbEg14nQ00HaFOpFbEalppkVk+eFqocTkxlcK8Cu0cASIYdy0c9oIqkdgHjADaFqLq8rFy9TJuq806Omm5Qa7dWa4I4gLM5Ne70agn9sYAi9XIy5HOmjw0A32YKHVhXMFuJ6dWyNkItImaoOc4X2iGvUKMZatbdDxwv4Pmrazg6rM40pi/mByEOqaIGck4GgKRQq3GWfb6urogN2lEVZwVAVCEAwJKTlaMa3Ba1fKRuKkqI9e6wDysFpy4wAgIhLR1utoJCTRAIJtNF7JLJX+5yFGqGopVCDQCGEgFMr26OQq1c41Gs8egOK1OoLeerm57958DBZkG5JEMeXwcwSgg5AuB7AD7Z/JcMw/QD+BSAdxNCrhtrI4R8nBByByHkDo8K2zUH1yMeFCcJHBs3Y8EJ10+PAEDQ6wYnEMunNSt1Hr//5TOIB724Z1dnWzdgExRqzZ9lSqgRot3yUalCbXYWSCaBxx8Xv6/E8lHlurM+cdpaoQYA81lri6B8pY7lfBU7e1QQagEv1py1QjPkMtRok6xg8cHozGwWnEBw984uRY/vCYu5CLxTCGuCXKOUHo6tvgcIIRhfKmC3zIG4GbSZ4uSo6QcvCGCY1gRrwOveNEX71GpJcXZWV4h1GmcGgCetc1IAcX+wUpVQ5XjMZbUTanWeGFc/bkPIDWGFfNTy0br7QU3OajP6orS+dUgVpaA1Qtu1wOcBIbBMvUwz8Oh7qRTU8tEhU9VD9qywiQo1WvMpUa73RHwo1fhNe612QnuFGiXUNm+vXchVUK7zjkLNQnACgbuFHWx32LdpAgk6aNujkFDjBOKIORxsWygh1GYBNCvOhqTvNUAIWSGE0ArrEwBup3/HMEwUwDcB/D4h5Ji+l+ugE+IBkehwCDVjwZM2DTJ2c3JR/ua7F3FuPocPve2ooukRYAso1ACRGFOiUPN6tRNq8/Pic8fH119jJ8tHb2dbtGbIBcxTW5S0xQ3JK2nRxmVXt3Ibl3iQdQogHZDLRQj7N0ehRovgfgUWLgDQHfGBEDiHI42QDZvfJJXiYq6KQpVTrFCjNrFOjpp+cG0mTQEguImK9um1MoYTysiUHV1BZMt1Jy9FJ9pNHQNiE9XKdWF2rQxClGXobYRj9aYfsgo1avlooXr1R2NpxTmrzeiVSJhFJ0dNMeTeewAIWlwnLOYrYN2uhqONUkQDHrAel7MOaIAcoRa2eC9oBs1DVHJeoI115/3Xj3Y9pc20iado9BJkhnO7I6zjbGIg2tWKVteJzaDvb3dEieWjNGzh3BMOtimUEGrPAtjLMMxOhmFYAD8L4GvND5AUaBRvBHBe+j4L4MsAHiCEPGjMS3YgB5qZkyk7jRAjIbTZ7CihZnWT7IcXlvCqm1J45YFexc+JBbzIbaZCDRCJLi0KNSUqMkqo1aR7v1Bo/VwDFGq8jEJt3b7H2iJISRG8EV0hFvkKh9om5HzZAZ0OyYD1uSiUGFPiew6I9m4AsFJ0CmEt6DR5DFh/D1xeEte+PQoVaj0RHzwuxlGoGQC53KwguzkKtUqdx3K+imGFZMoeyUb68nLBzJdle8hnqIn3glU2b194bgYAsK83ovq5TiNVP+oyQ1g+jwtuF4NS1bq14YnLaRwejDVcTZSCWpovOAo1xZBTJwKi5SMAy97/pVwVqagPjAqbewBgGMbJU9QIuTNj2OdBpS6A24RcQkqo9UY7D+Y2BiucprlutOspRRs28ZtHqE1IdZ/ccG5P2I9Mqe70DgwAIURUqLXI2Iz4PJY7nFDQoXBFlo/S+rGUc9YGB9sTHQk1QggH4P0AvguRKPs8IeQswzB/yjDMG6WH/QbDMGcZhjkJ4DcAvEv6/tsAvBTAuxiGeUH6dYvh/wsHDVCFmmPjZiw4obXfdbChULNuwxMEgpm1smI7L4powIsqJ6BihK2IVoUax60TZWZZPlalDT2fX3+NnRRqagk1BU30ksVN9PHlIhgGGEkqn0CnhyjngKQN63lJ12+lmzF1DohFMMMACYWNsm6JeEvnnSEMLVCyFlg9YXh5SVz7lCrU3C4G/XG/Q6gZAE4mN2uzMldpqLlSy0dKxI4tOoSaHsgTah7wAkHVgobUIxeX8LFHxvH2u4ZxeCim+vlOI1U/1lVK19cKDMMgyLot2ydozqpau0cASAS9YD0uR6GmAhKfJrsWABYq1HKVhtJQLVJRH5YcQk01lA1eWV8bLGYriPg9CLKdz8COUtk4cILQsk5cV6htXg9vIl1EkHXLkqz0XnAGMfWDpi20U6htlsUqVaglFRBqdOjK2RscbFco6iITQr4F4FsbvvdHTV9/AMAHWjzv0wA+rfM1OlCBmGThkHVs3AxFW4WaVyJPLGySLeWrqPEChlRa90QlsjVXrsPv7UBOdYIehZoSy0c9hBpVqOXz65ltcoQax6m2fJQ/HEl5GBY3Tq+kixhKBODzKH9vaSbCYq7SsH1zoBxyVj5h6T4oWHxIXilU0RVk2zZvNoIWy459hzbI5SnSyXOrGyWXlwuI+D2NQ68SDMQCmMs4TVK9kFeoebCUt/5nTEPNlVo+DsYDCHjdGJOIWQfaIHcvNCuYdddjMqjUefyvL57G/t4I/vgNhzRdg64jzvSxdlCVUit7aEC8H6wazDs+uQpOIHjxbvWEGsMw6I36GsoWB53RWaFm7TlyMVfB/j71SlVAbJxOrhQNfkX2h7ybhbj+56v1Rg/HKizkKoqz9BxCzTgIAtBitgJ+rwseF7Pplo87u0OyCtbme0FpvICD1pDbH8I+D4o1HoLQPo/XLKSlz3ky1Hk4tz/uh9fNYNxxtXCwTaHE8tHBDQSfx40g63Yy1AwGJwgtNzuqUDNE9aUQ03TaPKGuiIlJhJohOWqUgKq1IW43EmBWWj5ShVqh0FoNZ4Tlo0xuEusWC2Krp4omlguq8tMAp1GmF41CuEWTbLPs/lYKNXQpKIApHDsvfeBkGiUetwt+r8tyleLlpQL2pMKqLJ0G4wEnQ80A8AKBx926tA5skuVjo2ZQOITjcjHYkwo3rEMdaEMnchUwn2z/5JOWEKeRAAAgAElEQVSTWMhV8CdvOqSZuIv6PUgEvU6zRAc65mixbssGL05OZ8EwwC074pqe3xf1O5aPKtDpvW8M4VlUKy7lqo1hOrVIRR3LRy2Qz9oVz9ObolDLVRs2rp2QkAb1nPdfP3jSujZgGAYRv2dzFWrLIqEmB4dcNQ7yg7mb43QDiEO2Eb9HUd3o87ixrzeCM7NZC16ZAwdbDw6hZkMkgqxj+WgwhDYBsuuWjxYSaqvqmmMUphBqW83ysVa7VqFGX5+Flo8Mw1gu0yeENKbK1ID6Xi9vgmrCDpArhBs2PhZPGq4Uq4rz0wAxaD7EujGXdcgULZBbC4DNCZy/vFRUnJ9GMRAPYCFXafx/HGgDJ0eieDfH8nF6tQSfx9Ugz5Vgr0Oo6QZP2tt/riuYzVsbsuU6/umHl/Hy/T24Z1dS83UYhsGBviguLDiKRa2ggxftpszFSXRr9omTMxns6Qk3mnVq0Rv1O5aPKtCpRrDSHrxY5ZCvcpotH3vCfqw52Umq0TgrtBy+M38vaIfFXEUxuep2MUiGWIdEMQB8mxgRQLR93CyFWpXjMbNWwq4O5weHUDMOckOZYf/mxAYAQLpYU3VmuHkghjOzWctygR042EpwCDUbIhbwIlt2LB+NBN/G8pFOblhLqJXBMFBt0WcpoWa05eNGgq7da9po+ahUoWag5SMgWr1Zafm4mKuiVOOxq0cdoZYM+eB2MVh0FGqaIFcIUxsfqwvhlUJNkec5BcMwGEoEMbPmEGpaIDd5DFjvgZ8t1ZEuVLFbYX4axUA8AF4gm2JJaCfwgiCrQtkMhdrUaglDiYAqy5g9vWHMZyubOil9I4MQokihZqbN3+NjaeQqHN7/ij26r3WgP4KLC3kIDuGuCXWJgGDbqFeDrDX7BCEEp2YyODKkTZ0GSAq1XMVpnCmEYkLNgvefZtzI5SPJgQ7hORbh6kDvgVYkSniTsnbFeq+Kvpjye6En4nOyNA2A0EahBkBSqG0OoTa1UoJAgF0dhnNp9rZDqOkHz2+9wVxAtHzsVkOoDcWwVqo7TicOtiUcQs2GiAe9jkLNYLSbJqIKtXLdus1uarWE3ohftX0PJdRyRjTI9CjUtFg+biToWoFlr7d8bKVQ83jE16bH8pF0snCxtolOrZjUWj66XQy6w+y2aqLPrJXwzJVVQ661rlC7fit1uxjJxsnaQjhdqKJbheUjAAwlAg6hphGdyXVr14LL0lqgXqEmDhrMOYchXZBTqAVYz6Yo1GYzZQwqzE+j2JsSM3YclZo2UN6pUxPdzCYq/Szv7dWWl9SMm/qiKNd5TEkOCdsB3z+3aNj7U5eaZt42hFrI57Ekb3UuW0G6UMMtwzHN1+iL+VGpC8iVNy/n50YCPS+0HbqxMGuVKgu1KtRS1CbeaaSrAidzVqAqFMvt4YtV8AJRnKEGSISa897rBi+0V69vpuXjRFrMR+zkduPzuBELeB1y1QA0BnNb1AaRTSLbAamXEFHeS7h5IAoAODObM+slOXCwZeEQajZEIsgiU3IUakainUItaHGYNCDmoQx3qQ+BjUuE2krBgHvDCIWaEkKNTsAqtXxUolADRJWaAZaP7Sb+g1KQrFU4Py8WMAf61TfOUhH/tjocf+QHl/HOf3vaEKWmnEINkIhVC73Pa5yAXIVTpVADKKG2fRqlRmKrWT4uSQ2zAZUKZqp4ns1sH3LdDLSrFQCxcVrjBXC8tXZZ85kKBuPqGqh7JIXjdiHUyjW+0SgsVjndCgwl64L4b5lXJ8xnKwiybkT92qz9mrG/T6wttovt4/RqCe994Dg++/RVQ65Xlz7zrKf1sTtqURP15HQGAHQp1CgZs+DYPioCx8uvBet5iubXCeuEmjaF2nrusvPeq4HcfmC1mwUhBDNrJSxmxT0upYZQCzuEmhHgBdK2fxBiPZviZACI+WkAsFOB241DrhoDRdERm0Ko1ZAMKd8nbuqPwu1inBw1B9sSDqFmQ8SCXmQchZqh4NoUPwGqULOw+JlZLWFY5bQ5ICoXeyI+nJ0zYHpkI6G2sgLcfz8wNSX+WUmGWifLR2BdzabG8pEq1NplqAHXEmo6LB/bNU7DPmuVSefmcuiN+lTJ8yl6oz4sbSPLx4VcBTVOwDdOzem+Fi+ITbL294E1U+cUa9IgRZdqhVoQ+QqHrLNvqEZnOye3pWHzqxrvgX6JUHMUavogr1CTLKLr1t0PlTqPlWIN/TF1BOuOriA8LgaTK0WTXtnWwge/cwH3/OUP8KufeQ73ffBhvPmfntB1vU7rAnU3MHPgYiFXRl/MD6bNJLwa7OuNgGGACwvbY/r4okQcGlIvA6hJhJq3RYYSAEQDXmPs2Dvg5EwGrNulafiKoi/mEGpqIJefBYgkK+t2WTKER2t9NSRKM2je1nYawjMCcvtB2GJbt4cvLOElf/1D/PDiEgCoVqilC1XH+lcn5AavAuzmZO0CwJV0Ad1hH6L+zj0Rh1w1BpzUR5BbG6xWr9Y4AdlyXVVPye91Y28qjNMOoeZgG8Ih1GyIRNCLTLnu+NsbCNHv+vrvBy0m1GqcgPlcBUNd6gk1hmFw+44Enru6pv+FbCTUnnsOePhh4NFHxT/LKdSUWj7Sx7e6XrvX1KxQa2f5CFxPqKlUqHEyfviAdXkYFOfmczjYH9X03J6If1tZPtIDwIPPzei+VqfJ45DFxCpVVVB/e6UYSojN9mlHpaYaDTunLWL/Sodp4kF1QwJhnwexgNch1HSC5zvnZlnZLFnIimt7f0xdA9XtYtAX82N2m1jBTqSLCHjd+P75JTAMg5m1Mqqc9vepky20FY2S+WwFAyqJ1HYIsG7sTIZwYX57KNSode45gwi1hkKtjeVjLOBFvsI1Gu9m4fRMFjf1R+DzqLOMbwZtwC9mt0/dqAd0LWh3XgCsqxUXcxX4va6GlZhadIdZuJjto1B7dnIVXztpwPCdTJ1oZYYeIFqyEQJ86piovu1TURv0RHzgBIKMBeS/ncETeYWalc4mzZhYLirOYnfy9IyB3IB2RHIXsDpTb6Uo9RJUWD4CwM2DMcOGkBw4uJHgEGo2RDzAghcI8psgEbYrxGmi6z8uXrcLHhdj2cT5XKYMQoDhhLYmye0jCUytlvQTKBsJtcVF8XejFWrNhJoWhVpWmpSJbciL2Gj5qFKhJnSYOA1baPVXqfO4vFTAwQFthFoq4sNKsWa5DdlmYblQhc/jwompjG47s06TxyHWY2mYMLVzVW/5KBL0To6aemw1y8fVYg1B1q06YxMQbSIdQk0fRIVa69KaDuBYaeczlxXfT7UWoIBoA7pdAsaX81Xcs6sLl/7s9fjd1+4HIFreaAUNmm/XRLeiiTqfqahqlnbCgf7ItlGojS2KtcH4cgEVA+r7GkcVau0JNQDImdyovrpSwi6V+ZobkZLsAudtTqg9PpbWRapTyGXtUgQtaqIv5qvojWpXrXrcLqQiftu/9xR/971L+L0vndZNdPMyKhTW4wLrcaFg0ZmRZm4v56twMUBShZsBtfx0lEn6IMhkqAVYN0oWulo040q6iF0d8tMoHMtHYyAXHWE12U6Rzou1r1rXo+FEEOlCtVHvOHCwXeAQajYEnUx37LuMAy+Qto0RK+X5VEEyrEGhBgC3jSQAAM/rVam5XOIvSqgtLEgvcFr83YgMNfp4+ruWDLV0Wvw6mbz2sQYp1NoVxEELC+LLSwVwAsHBfm0h86moD4Toax7eKOAFgpVCFW+6ZQAA8OilZV3X4zpYf0b81pIpdKpMzQEZWFeobZccNUIIPvGjCUMOg50tH61VqK0Va0gE1b3/FINxv5OhphMCkbfyAaw9HM9ntCnUAGAwEdg2CrXlfLXRLDQiJ6ihUJOxefO6GdNs3jhewFK+oul9b4dDAzFcXS1tiyba5aU8PC4GAlm3f9QDqlDztslQo4SambaPHC9gIVdp5GVqhc/jRleItbXl4/NTa3jnvz2Nzz87rftanZwMAGkIzyKFWm9E35rQF9sehJogEJyeyaJQ5XQP39F7QNYe3qLhu8tLBdCja0/EB08bkr8VesIOoWYEeNLeySDkc6NU5y13mcqW6lgp1rBTBaFWqvGWkz12g9zARcgnnhmszlD74vOig89oUtm9QEGHbfRmEDtwcKPBIdRsiLjUTKN5Og70gxdI28ZIkHWjZNFkGW2OaT0Q3zwYBetxGWf7KEeotVOomWn5WKutK9QqlfXX1d197WM3KtRUEmpCB5s3K1Up1JJIq0KNHq4XbdwcoVgt1iAQ0ZaAdbt0KzXXyZTWW2nIQqUioF2hFg96EWLd20ahNrZUwJ998zz+9UcTuq/FdyDXxXuAtyxzYq1UQyKkTnFL4SjU9EMuQ61hEW1hhtq8pFBTm6EGAEPxABZylQYZYFfwAsFqsdpoFhqRE0RzMeRt3sxroi8XqhCIOjuvTnjF/hQIAR6+sGjYNbciCCG4vFTAy/b1ABAttfWiLjXU5SwfAXMJtcV8FbxAMKjR4aIZvVG/rWvGr70g2vw9fWVV97U6nRcAIOhzW6Jcnl4tYSCub03oj/kb+4qdMZEuNpx+TkzpOzNzSlxNLDgzCgLBRLqAV9/UC0D8HKtBY9hkG8UEmAFBkI+M4AWCqsUqn4m0SBorVTA75KoxkBu48HncYN0uS7PYv3NmAf/55CTefe8o9vepy1pNNdYH555wsL3gEGo2REJSqGW2uUKNF4hhyjE5hVqQ9aBct6bwoVOBaotgCp/HjSODMfMINaMsH0PSVEw2CxCizvKx1kQkXxU94tHdjUqdx6eemkSmVLteoabS8rHTxGmQ9aDKCZbYKJ6bzyHEujGiUbVIJ4q2QwFEC/9UxGeIXUUnhZrV6qR0oQavm0HUr44gZhgGQ4ngtiHUJpaLAIBvnprXPQXa2fJRsvmziERZLdU1K9QG4gFky3XLpyHtBF4Q2q4Hm2P5WEEi6G2o49RgMBGAQNZz2OyKlaJIPtFmId0T9ewPEp/W9l4AJEtgkz5rtFY0KkMNAG7qj2AoEcB3z9qbUJvPVlCs8Xj5gRQiPo8hOWrrlo+t74eGs4iJhBpVm+pVqAFAX9Rn23WBFwi+dXoegJihpbdGkLP0orBiCC9XqWM+W8E+lU3SjeiPBTCfrdg+p/3UTAaA+L49r5dQk86C7Ww/QxYNYc5ly6jUBbx8fwp3jCRwQOW9MJgIgHW7cHFxe2RpmgVeIGgnDGwMXllYJwLAJek93ZNSSKhR+09HjaQLchlqABD2e1CoWtfP/ccfjmF/bwQfeP1Nqp/rWMI62K5wCDUbgh7MtrNCTRAIfvmB43jLR58w5HqiPL/13wW8bpStUqhly+gO+8C2sY1RgttHEjgzm9OfC9FMqNEMtenppk5SC8tHnl9XqMkRZLt3i7+Pj69fT22GGgBcuQIAWHAH8dP//BT+8Ktn8eBzM7otHztNnIYsaqITQvD0lVXc1B9tG3DcCevT+PZsjjSDFv49ER+6DSDU5HIRgM3Iz6qiK8RqyscYSgS2jeXj5IpIqM1mynh+KqPrWkosHwHrbP4ypRq6VFp+UtCcLUelph0c316hFvCK94JV9QIgvpda8tMAYDAuDmnYPUeN7gM90l6YDLFgGIMUanKEms88a2hKdhipUGMYBq852IfHL6dtTbqPSfZu+1Jh3DQQNUihJsDrZtruzVYo1GYz4v5uhEKtL2Zfhdqzk6tYyldx12gXFnNV3YNGtE6UI9etsIkfkxrm+3v1Emp+lGo8chbmA28GTk5nEGTduG9PN07orBOpQrUdoR72uZG34Oc5Lg2T7e4J4dPvvRt/8ZbDqp7v87hxcCCq++ex3SFr+chKZwYL60RAdLtRM5zrkCfGgNaK7nZZ7D43ihYq1K6ulHDPri5Nfcbt1E9y4KAZDqFmQ6Qk9ZJdpweV4J8fG8fDF5ZwJV3UPUVHCJGmiVp/XAKsNVYdgDg5qzcT47aRBGq8gLNzWX0vppVCLZsFViWLFDmFmtsNyDX99+wRf798WZlFJACw7PUKtclJIJHARx67gouLebhdjJgVptPysdPEqVVN9CfHV3B+PoefvH1I8zW6wyzcLmZbNNEbjdOwHz1hCxRqrAeVujVKRUC0fEyG1Nk9UoiEWtn2U8cAMJkuIuL3gPW48PWTc7quxSuwfwWs88Bf1ZmhBtifQDETneyhAWsVavOZiia7RwANazC756itE2ri2ulxu5AMsVjW0RRozAF1snw0qWlG93MjM9QA4DWHelHjBDymM390K4MSD3t7IzgyGMPp2azuTJAaJ8Ark1VkCaFmoEJtIBbASrFmmd29lfj26XkEvG78z9fvBwAcv6rP9pGWf3IKtRBrvj34pUWJKNZJqFGS3u49hpMzWRwejOGOkQTGlgq6Ppu0ad4uryzi91pSI45LwwK7U2H4vW5V+WkUt+6I49RMxvZW0GaCl7EGD2xCnQiIbjdqhnOpU9J2yFM0Ex0Vaj6vJWQ7INYf+QqHoYQ2x6NkWBpGyzkkq4PtBYdQsyGifi8SQS+urm4PtcFGLOUr+NuHLiHsE2339Ia+0+ibdo2RIOs2LVh+IxaMINR2JAAAxyd12j5uJNQS4nUxOSn+3kxSUXKtmVCTQ38/EAwCY2PKFG3Nr6eZULtyBejuxny2gr2pMLrDLFaLVd2Wj8pVKebeFx97ZBypiA9vvW1Q8zU8bhd2docwtqgvdPtGAG2cdkdY9ER8uptkne8D8Z61arpsIl3UPH2+pzeCQpXbFraPV9JF7OuN4GX7evC9c/rsyzreA6x1CrU6LyBf4XRZPgL2J1DMBCczfLM5lo9lzZk5jfvB5gRrsxUwRU/Er2vgYr2BKm/zZta6sJCtIOB1N4gao3DHSAJRvwePXFwy9LpbCePLRSSCXnSFWLz97h2o8wL+84lJXdcUFWrtj9xRSxRqZXSHWfi96u1fN2KvRMpcsmHdeHExj4MDUdwynEDE58GzOs9KnZwMAGvswS8u5BFk3boJVbqf2DlHrcYJODeXw9HhOG4bEc+2L0xrV2VRhVq7pnnEb42bxfhyAbGAF0mNLgaA2EOo1AVcXNgeto+VOo/f+/JpXJWcLYwALxCZ3GXr60RBIDg/n1eVxZ4IehELeDGxbL89wEp0GtAO+9yWOZxQl5ohjX0Er9uFriDr2IA62HZwCDWbYiQZMnTzv5EwvlQELxC85qAYurtiWNO89d9HA17kTTwEN2M+W9ZNqPVEfBhNBvXnqFECq14HVlaAO+8Uvy/ZLLZVqCnJQ2MYUaV2+bKyzLXm19Ns+Tg1BSSTWCmKNmhdIR9WNirUNFg+Nu6JdgUxS4kU84qgF6YzePxyGu+5byd8Hn0Nkv29kYZ/up2xnK8i7PMgyHrQE/FhpVjTpR7jGofkdlOnkjrJginuhWwFV9JF3L2zS9PzDw/GAEC/cvUGwORKEaPJEA4PxjCbKeuyv+24FlioUKO5qYmQtiZ6T9gHFwMs2dTKqx0EwThVptgoaf13AYuzMQpVDvkKp1mh5ve60R322Z5gpYf/7nAzoebTZflIbaHbZe8CItlu1uTxfE4cvtJi/ysHj9uFu3Z26SYZtjLShWpj+n53TxivO9SHB56aRL6ivc6v8UTWQsnvdcPncZlKqM2slQ1RpwFinh4AXDDADnOrYTYj/pzcLga3jyZwfNIYhZqs5aPP/MHMsaU89vZGNNvDU/RJ+4mdlSnn53Oo8QKODMVws1Qbn9dxr3MNy8fWa0DYZ95e0Izx5QJ294R07Qu37ogDgO5cuRsFZ2az+OzTU/idB08Z5uAhCKTt55Bag5cstFWeXiuhUOVwsF85ocYwDHb3hDDuEGq6sK5Qa782WOVwQgdqtSrUAKl2dhRqDrYZHELNphhNBjGZ3p4KNTpNfXhILILTBX1ZcuuEWuuPSzzgRcYCQq1Y5ZCrcI3DjB7cNpLA81Nr+opDSmAtSZPKGwm1VhlqHCc+h1UwHUcJNaWWj60INY4DuruxUqiiO+xDd5jFSrGF5aNZCjWTiBRCCP76OxfQFWLxc/eM6L7e3t4wrq6WLA9BthrLhWrD1qsn4gMhokWeVjTug7be59apk56+sgIAuGdXUtPzD/RF4HYxOD1rb0KtVOOwmKtiZ3cQw13iWqpHlddpLQhbpFYF1nNTtSrUPG4XukL6iIQbDdlyHUf/5CHdSkUKeYWa1CixyiJaqoW0KtQAMW9pOyjUIj5Pg/AERLWanqZAJztgAOgKs7r2HzksZCuG5qc1466dXbiSLto2J2OteG0O5X9/2W7kKhweeOqq5mvWeQFsB3u1WMCLbMlchZoR+WkAMJwIIsi6ccFmKhVeIJjPVBo/p1uG4xhbKuiq4ZTkKYZZD2qcYKqN3sWFAvalwrqvk4r4wDD2JtSOSwOnd4x0IRbwIhXx4fKSduKAEwQwTPs6MeL3Il+pm265PpspY4fCjKx2GIwHkIr4tk2O2rSk2nnmyiq+8NyMIdfkydZSqJ2dE8liNQo1QBw4mVjensP7RkFJhIh1CjVKqGmvE3oiPl126Tcanricxh985TS+cWrOscHdxnAINZtiRzKE+WwZVc7eDfJWoNPUVHGhW6FG5BVqiSCLTKlm6JR7K9DDi57mGMXtIwmkCzVM6bEFpQQWzU+79VbA5eqsUKvVlBFYe/cCExPrFo5KFGoAUC4D0aaisLtbypZi0RWSGlgGKNRcDNpO+a3bvJnz+fvRWBpPjq/g/a/Y02jY68H+3ggIge0nzZbzFfRIKgT6ux7yoGOGmgXqpOeuruHMbBbHJlYQ8Xtwk4oJw2b4vW7sTYVxZtZ+E+fNuLoirnmj3SEMS1N49MCsBcptP80/EK0V9RFqgNgs204h41fSReSrHL5vEKEmCKTteuB2MWA9LpTq5t8LuUodH/zOBQBi00MrhuL2J9SW8uuDFhQpyRJYa11H1wW5Jnp3iMVaqdZ4rJG4ulJsrG9G466d4tDGs1fsqVBYLdWQaCLUjg7H8coDKfzzo+PIlLQRoKLlo7wqJBbwmqZQI4RgLmOcQs3lYrCvN4ILC/aqF5byFXACafycbh6IgRB96qROGTkAEPRRVYo5Z4bVYg3pQhX7+/TlpwGiyioV8WHBxpaPxydXMdwVaAwl7O0NY0wHoVbnCbxtBm0A0c2izhNUOXMbsrky17CX1QqGYXDrjrh+l5sbBFMr4n1+ZCiGjz0ybsg15TLUqDW42ZmKzTg3l4NbWtPVYHcqjKV8FTkd6u0bEZ97Zgof+NIpQ65FLYHl7GDzFlo+hlg34kHta0RKp136jYbPPH0Vnz42hfd/9gQeNIhwd2AeGIbpYhjmewzDjEm/J1o85haGYZ5iGOYswzCnGIb5mU7XdQg1m2I0GYRA9E3e36iYzZTQE/E18j/0TgB3VKgFvRCI+bZuNAC6L2oMoQbozFHbSKgNDoq/aIZaO0JNqSJszx6RTGtF0LV7PQBQKADJdZVOPdGFcp1HMuxDV4gVCVa9hBohbeX5QPOEmTn3xN99/xKGEgH83D07DLnePumQbXdP/OX8tQo1ALq8vjtlY4RNVqgJAsGvfPo5/NwnnsYPLyzj7p1dsjkdnXB4MIYzs1nTp2Q3E5NpcZpyNBlqTOrO6BgsWB+4kL8HrLDsaCjUNFo+Avqt7m40zElk0bNX9dl6UXCC0FaxCojNEiuUwL/1+ZN45OIy/uSNhxqWVVpAFWp2XhOW81V0byDUeiI+cAJpfKbUQkkTPRn2QSDQTNK0w1qxhnShhr29+tUorXBoIIog68Yzkirablgr1tC1YSjhd1+3H4Uqp7mhWuPkM9QA8SxhFqG2UqyhUhcMI9QA0fbxwkLeVmsDHcikCjXqdKJHud8g12Vs9sLSmcGscySt7dU2zNuhLxawrUKNEIJnJ9dw58i6ffreVASXF7Xf6xwvyOZpRiV7eDOJCUIIClWuYUWvB3eOdmFqtdToS9gZ02sl9EZ9eMnebkyvlnTFBFAIpL3lI3UysNIx5tx8Drt7QqrzNemw1nZTqX3t5Bz+65lpQyISqB2s3BnSSoXaUCKoyxK2J+LDcqFqq7pADulCDbePJBDxe3Buzl4DRjbF/wLwA0LIXgA/kP68ESUAv0AIOQTgdQA+zDBMXO6iDqFmU4wkxUbhdsxRo/731LJlxShCrc3+QkPfzbRqAYA5aRpQax5KM/alIvC6GV0Tdw1CbVGa7O/rA4aHRVUZoN/yce9e8feLF6+/XrvXA1xHqBUj4hqYDLPoDvtQrPHgvKxuy0cZPs1UZdKlxTxOTGXwrheP6s5OoxjpCoJ1u2yfo9ZMqKUooWaAQq2ddUeDTDEpG+GFmQyW8lVky3Us5Cqa7R4pbh6MYaVYw4KNM7SuSHviaHcIPREffB6XLqWuYvtXSwg1cQ/q0hE4v90UapRQm1gu6lazA+L9IKtE8LotsfI5O5vFG48O4BdfPKrrOgMxP2qcYJo14VZAuqVCTRxc0kouK1GoJcPG1KgbcVlSmu8xwN6tFbxuF24fSeDpK8aQ0FsJvECQKdevUagBwIG+KN58yyA++dQkahpUJKJCTYHlo0mE2jpRZJxq8UBfFJlSHYs2ykuhatwhiXhMRXzoDvt0Kfcb5LrsoIW5uUmffWYKAa8bR4a0D1c0oz/qty2hdnWlhHShijtG1wm1PakwijVe8/+Z61AXRPziGdSsswIgWgjyAkHUr0+hBqxbyz9t06GKZkyvljCcCGIoEQQnECwaUB+LWbsdHG4sJNQuLeaxv0+9u8nunhAAYFxPL+kGxBVpMPPTx7TbQFN02h9CPk/js2s2REJNX48xFfGhzpPGedTuWClU0Rv1YV9vBBdt3kOzCd4E4JPS158E8OaNDyCEXCKEjElfzwFYAtAjd1GHULMpRpLiJkftrbYTZtfEnAC/142wz4O0XsvHDg3TuDTJmjF586CTYL0xX4dHdobLxSAV8WNJT+N8o0Kttxc4cn+rpW8AACAASURBVAQYGxP/rNfycc8e8fcLF66/XrvXA4iEWmJdwZsNiQfI7jDbaDSX3F4xm43jNFs+yivUzLNv+eJzM/C4GLz51kHDrulxu7A7FbZ1MVCp88hVuEbjtDusn1Cj1p/tmqbUNsGsjMXvnl2Ax8Xgr956GH6vCy/fn9J1PapkOT1jzxy1Oi/g0YvLSEV8CPs8YBgGQ4kAplcNyFBrczgOsm4wjDWE2qoRlo9RfVZ3Nxqa7QyPG2BhxMlY+QBAwAKFGi8QLOWr6DfAHppmttq1eQpIgxbhDYRaVN/+oEihFhL/Db016kaMLZpLqAHAXaNduLiYN1xdt9nIlusgBOhqYXn0ygMpVOoCxpbU10k1noD1yB+5oyYSalRhtbM7ZNg1qX2gnWwfZzYo1BiGweHBKM7oUKh1ysgBzFWyn57J4usn5/Ce+3Y2zqt60R/3Yy5TtqTJazWenRQHBe4cXT9H0rVU6xBqJ0Kdvv95Ewk1eu2IAYTaTf1RRPwePDVuf0JtZq2M4a5gg2jQ42gBiEpBgbRfD2iWq1nk+kaUazxmM2Xs0WANPtwVhNfN2D4uohmlGof5bAWsx4WvnJjTvWd3io5oON1YYAE6s1bST6jprJ1vNKQLNXSHRUJtTIeK2YFieBiGOd70630qn99LCJmXvl4A0Cv3YIZh7gLAApC1p3AINZsiGWIR9nm2HaEmCARzmUpjujAZZrFS0HfgF0hny0cAmq2BlGI+W0F3mDVMldQb9elTojQTarEYEAgA73wnQDcTOYWaEkKtv1+8plpCrVgULR3DYnGYCYhTV10hX4NQK0J6bKWiK0OtHYKSbYLRh2OOF/ClE7N4xYFUgxAyCvt7w41GnB1Bi7tuSRUQYN2I+Dy6FWpyxGo8YB7ZTgjBQ2cX8aLdSfzsXTtw9k9ep7uBerA/ChezHlBtJxBC8LsPnsLTV1bxG/fvbXx/uCtoTIZam+lChmEQYj0omJSN0oxMqYaA163atqUZPWHR6m7VZo3ydpjLlDGSDIL1uHB8Ur/ipqNCjfWYZgVMsVKoghOIIfbQ/VKGjF2tnco1Hvkqd51CTW/GZieiHWhSqOmsUTdibCmPIOvGgAFuBu1w184uEKLTNnwLojGU0ELlSwdOtJArdU4Au4kKtW+cmsOunlBDUWAEDkiEmp3qhdlMGYmgt6EYA0Qr7LGlvOZBiMYZUmYtoLlJRquXBYHgz791DomgF+972S7Drnt0KI5SjbelxdXxyTXEg95rskf3UkJN49AhxxNZhSK1YTSXUKtf82/pgdvF4O6dXTg2YW9Crc4LmM+WMZwIYEhS9+qNUuk0pM16XPC6GZTq1ijUJtIFEALsTqnfG7xuF0aSoW1FqFF12i/duxPlOq87f7lTrIzZTjcU2XId+QrXuM+1Yr12tueZoRk1TkC2XEcy5MP+3jDWSnVdMSIOFIEjhNzR9OvjGx/AMMz3GYY50+LXm5ofR0T2sy0DyjBMP4BPAXg3IUTWmsIh1GwKhmGwoyu47Swf04UqarzQmC5MhlisFPUtbuvTha3/Ph4wV4VCsZAtNwKSjUBfzG8Moba4KKrTAODFL15XlsllqCmxfHS5gB07gKtXr72G3OsBRIWaz9cg1Fb84qE/GWIbZEqBkV5bpaLZ8tEj0xxxuRgEWbfhjdMnxlewnK/ip24fMvS6AHCgP4rZTNkQ27OtiEXpXu9rajJSr2+tkAuWBkTSzudxmTLFP75cwJV0Ea85KH729GSnUQRYN4a7grY8HI0tFfDlE7P41ZfvxjvvGWl8fzgRbOQiaHmflDTOQz63RQq1OhI6wqQBICWRMNtlunAuU8FoMoRbhuJ4xgByQFSotd8bAqz5lo8LLdY6raCE2nzWnnm89NC/UaHWF/PDxazbpmdKNVXZKZ2yFQGxJgH05/xuxOWlAvakwrJ2k3pxdDgO1u3CMwaQ0FsJdDCulW3uSFcQEZ9HU55WnRfg9ci/H7GAF4UqZ0hGTzOWchU8fWUVP3FkQFc2ykbEgyxuHoziay/M2WYqmzqcNOPQYAwCAc4v5JCr1HH/3z6C75xZUHxNmpGjxNXC6CG8f35sHMcmVvE7rz1giNUfxb17ugEAP7q8bNg1twqupIvY1xu5Zv2kGdyXtSrUBEH2/aeqsbyJGWq5hkJNP6EGiLaPkysl29YGgDhwJRBgqCuIAUnxr5tQU1AbBLxuyxRq41L+mdaBzN09ocY1tgMoofa6m/sA6K+NOyrU/NbEBsxIg6XDXXoVapJduo2soNuB1ovJMNvIJ720YL/+yY0GQsirCCE3t/j1VQCLElFGCbOlVtdgGCYK4JsAfp8QcqzTv+kQajbGaHdw2ynUZiT7psGGQs2nX6HWYXqEWmhkTZ7ov7paMiQ/jUK0fNSx4TUTainJao5hgF/4BfHrdgo1pZaPgHjdeUmZ20mhRkm6YlH8OiJubgs+sUhMhll0SRZLeUivp1wWrR9VKtQ4gcgGjAOiEsFoVcrjY8tgPS68bJ+sla8m3CnlBTxjw1wUYN2yrFm10a0zL4rj5dUogKhgNUOh9uilNADglTfJqtVVY3dP2JaHI6qwecWBa20xh7sCyFU4/I//8wJe83ePqW4MKjkch3weFCyw61gr1VoqK9SAZgtqVebcaJjLlDEQD+DgQNSQHAiRZG//90HWjbLJk8et1jqt6A774HExtrV8pKrsjdPZfq8bN/VH8dzVNRSrHF761z/Efz45qfi6nabQAbF2dDEwfIhlbLFgqt0jIP58bhmO2y5HTc421+VicHAgqilPq6YwQw1Yb3wbhW+engchwBuO9Bt6XQD4+XtGcHExb5u6kWZwN4Pmjn3v3CI+fewqxpeLqtTMDYWajEKpYRNvYJ3wwnQGf/vQJfzEkX68/a5hw64LiMNoB/oieHwsbeh1twLmc+XGIEkz9qTCmgk1jifwbhmFmjHEaiNHbcIen/1WoHbww4kgfB43eqO+BvGgFYI0LyHXQ6C5WVZgfKkAhgFGk9rUy8OJYCOjczvginQ+3t8bQdTvQVpnj5GXbohOOdx5kwm1KalfrFehRs+Qi9tAobbufOTDPkmxb+foFJvgawB+Ufr6FwF8deMDGIZhAXwZwAOEkAeVXNQh1GyMHV0hTK+VbOlx3g6zG/zvu8Os7sD3Tgo1egg2M0NtMVfBxHIRd4wkOj9YIfpifhSqnPaJSEqora0BXevhzXj3u4F9+4D9+9e/p8XyERAJtUVJTq/U8pEQUaEmEWpz7jCCrBtB1tOwWMoS6VqFwrWvTyGEDrZeABD2Ga9QOzaxiluH47os3drhyFAMAa/bthYe6wq19YNyT8SHtK4MNUG2SQKIjTkz7GCPTaxgJBm8rvmjF7t7QphYLtguQ4sWvhuVKDu6xMPDN07NYylfVb2O87yyfBQrFGorxZqu/DQADes7XfmaNwgqdR4rxRoG434kQywKVQ41Tp86hOPlJ9HDPo/p1i2t1jqtcLkY9Eb9trV8PDefA8MA+/ui1/3dnaNdODGVwaOXlpGrcDgxlVF8XSWEmtvFoCvEIm2gQi1fqWMhV8HeVMSwa7bDXTu7cGY2a8naZhXWiu0VaoBo/3d+PqdaRVbjlBNqRto+zqyV8MBTV3GgL4K9vcbfE288Ooio34MHjl01/NpWgxAiKtTi1zYU+2MBvOXWQXziRxP418cmAKjLlOQUqtgBGDqE9+HvX0I84MVfvvWwocpEivv2dOP45JrpmaBWghCCxWy15d55dCiGE9MZfPescnUiRacMNaoeNLNpTsm6qEEKtQN9EbhdjGaS8UYAtYPfkRTXhKFE0ECFWvvHWOFkQDG+XMBwIqi5rxAPelGu86hy9lkH5DCRLmIg5keAdeseygU6K9QiFlk+nl/Iw8Xoz94N+TyIB72Yy9ifZKX95e4wi+6wD8kQq9kW2IFl+CsAr2YYZgzAq6Q/g2GYOxiG+YT0mLcBeCmAdzEM84L06xa5izqEmo0xmgyizpNtsahRzG5UqIV8WC3WdDWHaWOk3TQR63EhxLpNtXykU4DUZsMI0Ol1zY0ySqhlMkCiiegbGgIuXgRuvXX9exsVakosHwGRUKPjXEotHwGAZbHKsCAMg1nG1yDSIj4PvG4GGYlQyy6vXf9cBeA6WP0BokLNyEZTtlzH2blsYyrQaHjdLtwxmsAxm04bzmcrCHjd1xwmeyN+zGcrmocOOAXEaizgNXxtEASCZ66s4p6dxt8Lu3vCqHJCYy21C6i158aspI3TeGoPy7yCfJSQwWtBy9chEIwt5nUfhlIRyfLRptavzaC10UA8gLjUQM+U9U6byu8N0YDXcAXKRsxnK/C6mYaloF70x/yYs6mt07m5HEaToUZORTPuGE2gXOfx0UcuA1A3eaqEUAPEGtVIhRptbpqtUANEQo0XCJ6fsk+OGs2ObDeYcHgohionYExlE7nOC2A98kdumsdsFKF2eSmPN/7jE0jnq/jDnzhoyDU3IsC68VO3D+O7ZxYMtyu0GmulOsp1/jrLRwD4/R+/CSGfB2sl0VZZzXqoZC0ISZltRtm8nZ3L4pGLy/il+3YapkjaiPv2dqPGC3jWRravq8UaarzQUt39m6/ah8ODMfz6Z0/g5LTy4QoAqPPyMQGUUDXT8jHfsHw05n7wuF3oi/pt3WOaXi3B62Ya98NQIoCZjD6FWqeeEiCuB2Zn7VKMLxd1ZWuaMQiylTGRLmKXlK/YE9YXGwF03h+iDeW6uT/fc3M57O4JGzKwPZQI6CaebwTQ2j0pDeru7Q07CrUtDkLICiHkfkLIXskaclX6/nFCyHulrz9NCPESQm5p+vWC3HUdQs3GGJHk29vJ9nF2rYyo39MoGLtCLHiB6NroqV2H3NR5PMiaqlB74nIayRCLg/3XT1FrRSoqybK1KhGaFWqJDso5rQq1niZrQ6UKNQDw+TBZc2HNH8FkpoqkZPXIMOJE+FhWfK/+xycev/b1KYRAOhNqoirFuImt45OrEAhMI9QA4EW7k7i4mLdljtpCroK+mP+aSd2jwzGU69qD1Ts1zwGxMWd0htr5hRyy5Tru2d3V+cEqsVtqxNotR205X0WQdTfsMyhGu0MIsm684egAAGBW5WGZFwgYBrJ5RWG/x1QrH0BspJdqPI4Ox3RdJ8C6EfF5toX//VxG3PsG4oFG9pzefZwn8iR71O81/WC8mK0gFfEblqHVHw/YTqFGm1Xn5nNt66o7RsT1lVr8TaaLiqewlRJqXSFWty05RZ0X8JGHL4NhgIMDxtWK7XDbSAJuF2OI3d8Hv3MBv/5fJwx4VfqwVqwh4HUjwLauNw8NiOvrGZU5anWegFWoUDOqXvi774+hxgn4yvvvNXQYbyNetDsJTiC4dIM3kuhk+UjX9ZZX3WEfPvwzt+BXX74b99/Ui/mM8vWQ76BAAMTMJIYxLifnY4+MI+zzXJMXazTu2tll2OdfLQSB6FaTtwLNH21l+Rj2efCf774TDAN89YU5VdflBEHW8tHjdiHIui2yfDRGoQYAA3G/7YbvmjG9JlqC0318KBHAfKaiK+dSUFAbBFk3ihYo1ASBYGK5gN092gdwGoTPNiDUCCG4slzAzm6xv9qt0+UG6JyxGbfABQsAzs/nDKsbh+L6lZw3AtIFavkoDmAdGojh3FwOWZPfKwdbDw6hZmOMSBL1q6v2y8Nph/lsBQNNFmhUmaTH9pHjO8vzYwEvsjon29uBEILHL6fx4j3dhobM04krXYRauQzk8+YRaqmmvCM1hBrLYiLUgyuJAZyYylwzqZ8M+XAyLW6C+4Lie1tj1E3kKFKo+dwoGjhhdmxiBazHhVt3xA275kY0PPFtkofRjMVs5bqpU/r/1WpzKSrUOk+dG10IUxXh3SYp1ADYLkdtOV+9Tp0GiE2Spz5wP/73mw4B0KBQE4isOg0Q9wezD5t0YvrIkP71oSeif+ryRsBck6KdKlLWdNrvdSLZI34PapyAiok5anR4wCj0x0Qlr9p8wa2K8eUCjv7JQ/jyiRlMrZbaNhH6Yv5GQPu9e0TSgAbSd4JihVqYbeR26cUHvnQaD19Ywp+9+WbDrYBbIezz4NBAVLdC5bmrq/jYI+P4+sm5TSduV4v1tnaPALCrOwTW41JtcyZavnXaJyRLcgP2iivpIr59eh7vvGdEV7NUCfb1ite/0a2OHr20DI+LwV27Wg8qvXx/Cr/7ugMYiPmxmK+grrCpTi295M5vLheDoNeYJvp3zy7gG6fm8YsvHmmQtGYgyHqwqzuECwvWv+//8tgEXvWhRw2/Ll1/etvkj8aDLG4ZjuP4VXVrnpK85YjfY7pCze1iEGwzLKAFA/GAbdXrALCQvTZPbygRBCcQLOqJCiCdCfYga3xkRCvMZsqockJjkFILtpNCbaVYQ67CNQg1QxVqbeqDqAU/30yphtlM2bChfVGhVrLNmaEdVgo1sB5Xw+HirbcNosoJ+MJz05v8yhxYDYdQszH6on6wHte2UqgtF65tmnZLMlw9iptGoLSsQs34pjnF81MZLOWruG+Psc1z2nBb0EOopaVA6niHJi4lw3heveUjhQrLx7rHi9+/9xfxC2/7UwDrxCr9uuoRH/vqEbEoytTUTZsJCgi1kMFZOU9NrJiWn0ZxeDCGiM+Db59RnxGw1TGfvb7J3Bv1Y1d3SDOhpkShFpPWBiMLS5qfNmBC07QrxCIR9NpSobYxP40iFvAiFvAi7PNosnzsrFI03vZzI07OZBDxebBTY7B4M3oiPixvA4XabKYMhhHXAWq3pjfvsJMNrBX2LQsthgf0oC/qR5UTTJ+QtQqPXlxGnSf4o6+eBQDZJsKdo2Jz/ZdfsgsAcFFh81hJ0wwQa9S0AeT1s5OrePC5GfzaK3bj5+42T5WyEXeMdOGF6YxmtUipxuH3vnSm8fn73vlF1ddYKVTx4HMzhuRFr5VqSITakxBipqBPdd2sJEONDn4ZQbB+/LFxeNwu/NK9o7qv1Qli/o4LFxdu7JrhhxeXcftIopFn1Q798QAIUT6MyAtCx3UAAIIGZK3OrJXwO184iSNDMfzG/Xt1XUsJ9vVFcHFRm8ODHjxxOY2p1ZLh+W3rCrX2tfWdo104O5dT9V7VeUHW8hEQrRjNVqiFfR5D8/QGJPW6EWvvVsRirnoNuTok2cHOrGrvq/EKCPagz2NJhhodDNnV7Vg+KgFVJtP7oCfiQ77C6RqQ65Sh5ve6EfC6DXe6aca5eXENN0yhlgigUhd0iRluBKQLNfSEfY019dBADLePJPCZp6dsl0PvQB4OoWZjuFwMdnQFMalwotYOSG9QIRiiUBM6K9QSQdaUhumHv38JP/MvTyHi9+AV+1Odn6ACQdaDiN+DRT0ZahXpuZ0Uai6X+MsihdoaB1Q9LBARQ9iTTY30rhCLqlu8L1KM+J6tVNU1gzhBUKZKMahpupCt4MxsDi/d19P5wTrgdbvw9rt34Jun5jBlIyJeEAiW8q1VG3fvSuKZK6uaDoRKMtQSQRY1XkDZQEXKqZkMbt/R4TOnA7t7whi3WdD4xmGLjWAYBoNx9b7vPN+ZUIsHWZRq5oZ2n5zJ4MhwzBAVcyrqx1LeXhZ/rTC1WkIq4gPrca0r1HSQRoJAQIj88A3NcDSrcUYIMUWhBsA2k+jHJlbAMOvvgVwT4Vdetht/8ZbDeNHuJNwuRrGtnZKcFEAkUXIVTpd9GSEEH/z2BaQiPrz/FeY30Ztx52gClbqAs3PqLBABMZ/mrR99EpeW8vjQ245iV3cID51VN8xDCMH/+/mT+O0vnMQffvWM7sGV1WKtbX4aRX9UvQVqje9MqMUCXrhdjG6C9cnLaXzu2Wm8/c5hpAwk1tvB5WKwrzdyQ1s+LmQrOD+fwysOdD5n0UGmeYX3AC/IN88pwj6PboXah753CXWe4B/ffht8HvOG7ygO9EYwvVq2ND+PEILTkuWqEcMIzVjIVuBi1i28WuGO0QR4geAFFTlqnEA6KlQjfo+pP8d8hTPU7hEQ1f11nhj+PmwFEEKwmKtsINRE5yc9dnYNRZJMbRD0ulEyMDKiHZ6ZXIXHxeDQoHar+HjQOGX1VkfD4k86S9J1Qs/9zwti7Sd3jhRdsMz7+dLYi5sMU6jp/5zcCEgXqtcM7APAz98zgivpIh4bW96kV+VgM+AQajbHaDKIKR2TNDcSCCHX2XrR7Cx9m13nxkjMBIXa9GoJf/+DMdx/Uwo/+K2XmXIw7o36sahQiXB8chUXFpomEZtJsU6EGiAqzCwi1Fbq4nv103cMA8A1lo8jyRB8YXGzTwoi0ZquqGtm8UJnKydaABmhTKJT26891Kf7Wp3wnvt2wuNy4V9/NGH6v2UVVoo11HnSUrVxz64u5Kucphw1XhA6kykBqnwxZn2o1Hks5qoY1TFR2Am7e8LbxvKxGUOJgOo8CCUKtcYEp0kKn0qdx4X5vCF2j4BoY7KUr9raroMQgmMTK7h9RNy71gk1/cM3HpnGGVU/mGUBmqtwKNV4QxVq/VIDebPt+IyAIBA8fWUVb75lEKmID8kQi5TMurC3N4J33L0DPo8bO7tDuLSobNBAueWj+G/rUSV9//wSjl9dw2++am/b7C+zcPuo+PlRa/tY4wT80n8+i7lMGf/xrjvxygO9ePWhXjw1vqKqcfTN0/N49NIyjg7H8dmnp/DvT0yqeh0bsVaqyVo+AkBvzK9aoVbnBfg88kdul4vRnam3nK/iNz73Anb3hPE/X39A83XUYm/qxibUHrm4BACKBhcH6ICBwlpBsUKNdetSqM2slfC1F+bw9rt2YEfy+hw4M7C/TxxatNLuc2at3FgjlnTmF23EQraCnohPVk1220gCDANV2XEcL3S0h4/4vciZqFDLVbhGvrxRoNbCdsxRy5U5VDnhmvpgIC5+9o0g1ORI9pDPY4nl4+Njady2I9GwrNMCs883WwkNQk3qLdIz5bKOdajOdyZYzXTBAkSFWm/U13D10oshySp9Zs3e/eeVYvWa/iIAvP5wHwbjAfz5N8+bkvPpYGvCIdRsjpFkCJMrRVs3xihyZQ41XrjG1qsrxMLtYrCkw75KaFj3yFg+BrzIlGqG/pw/8/QUGAB//IZDSEXMmTLtiyprDCzlKvj5f3sGP/nRJ9en8rQSahZYPi5XxffhPfftRF/Uj5ubpq9+7RW78a/vuw8AEKyJRfFyRd0kmBIiJRbwos4TQ5RJD51dwK6eEPbo8DlXit6oH2+9bRCfPz5tqp+/laDWPK1UGzRH7Y++dqaRQ6UUnEJ1EgDD7BpogTpiYsNkTyqMdKGqO09qq6DK8ciW67KNcwAYlHzf1UCJ7Se1MzPL9vHsXA6cQHDUIEJtZ3cQpRqveAL/RsREuoj5bAX37ukGAARYN/xel65Dq5Lhm2hA3MfMapzJrXVaQRVqdrgfzi/kkC3X8dJ93fjbtx3FH73hoGILrH29YZyYyuCPv9p5r+BUZKgB2oe+eIHgb757Abu6Q3ibNEBkJVIRP0aTQTw7uabqeR9/bBxjSwX8/c/eipdLJMZrDvaCEwieuJxWdI2nxlfwB185g8ODMXzxv78IR4di+NbpedX/h2YoUqjF/FhQmSlY50lHhRpALUC177v/+PAYsuUa/ukdtyHIGqtGkcP+vjCW8jduzfDY2DL6Y/5GHpwc+lUq1JRkLgNiE10PofaJH10BALz3JTs1X0MtKKGm1ArXCJyZXVfDGq5Qy1XQJ2P3CIhDMQf6oqpy1MTPfweFms/cDLVcpW64Qo2qNZWSyzcSFvPX5+n5PG70Rn26iIJGjIhM3RFg3aZbPq4Vazgzl23UwFpBXRfMtrXfCqBuV90RsUagBJSePZsXCFyMPMEaC5gbG3B6JmuYOg1YJ9rtrlBbKdSuIyF9Hjf+9E2HMLZUwMcfG9+kV+bAajiEms0xkgyiUhcMn+LailguiMVPswrB7WLQHWZ12VdxPJ0mav+YeNALTiCGBEoDouLg88en8eqDvabkJFGICrXOP5t/eHgMdV5APMjiXf/xjHiIsUKhlkisK9M6KdSaSLqlmjhFOtwVxLHfu79BmgDiZpdIioUDUxRVOMtllYQaUaZQA/TbIGTLdTw1voLXHDRfnUbx40f6UeUEnJhSRzBtVdDGRyvVRm/Uj///p49ierWMd/zrMVVe6LxAZNUoQBOZYtB0Gc3EHO4yj1CjTZLNCJs3A/Swo0Shlq9wqj6zvEA62r/GA5RUNf5ARAjB3/9gDCHWjbt2dhlyTWqBp0W1eaPg8TGxaf+SPes2uokgq6shzEnWLbIZaiYr1Ghjy0hCrTvsg8/jwukZ9bZ+Ww3HJsQm6N07k3jJ3h686ZZBxc89MhRHulDFJ5+6ik8fuyr7WEEpoRbSZ0v+pedncGmxgN9+7X5FhI0ZuHO0C8cnVxURTMcnV/GBL53CPzx8GT9+uP8ai71DAzEwzHquixy+c2YB7/y3p5EMsfjHd9wKj9uFe3YncWomoznPpM4LyFe4zgo1lZmCvEDAC0oJNVYzSZAuVPG5Z6fxllsHG3u4VdjXK/57W0ml9sJ0Bu/8xNOKSKrTs1lJeaTMmjHi92BeIYmgJHMZAEI6muhTKyX81zNTeNMtg6aeGTdiOBFEkHVrrhW1DKGebiLU9ChDWkHMH+2s0rhnVxeeubKqmPznBCUKNY/JGWpcg/wwClSxZUtCLXc9oQaI97whlo9yCjXWDU4gpipcnhxfASHAfXv1EWoetwthn2d7WD7mqwh43Y1hlXVCTfs6JEZHyK8N8aDXNAXg1EoJY0sF3KeTWG1GxO9FPOi1tUKNEIKVQu2aSBmK+2/qxY8d7sPf/2AMj15yrB+3AxxCzeYYSYq2YFdtlIfUDpQ03Ng0TUX8ughFZQo1Y1Uon3l6CqvFGn7hRaOGXK8d+mKitZdcA2JsMY/PPTONt9+1Ax95x63IlOp4cnzlWpWZWYSaywX0SA1PouVgPwAAIABJREFUFZaPC2Ueu3pkJk39UoGczzcerwZKFWqA/ib610/OgRMIXn2wV9d11ODWHQm4GLH5ZQesB423bjL/1O1D+LM334xijcdZFSSCOHksv40mgsaSKdTCd4eJhNqBfkqo2YNQWW6zN2zEYFz8mc6qOCyrUqiZECr9jVPzeOzSMn77tfs7NoKVYn9fFAyzHlRtRzx+OY0dXcFrrLHiQVaX5aOSRklU2hfMapydmMqAYYC9BqqZ3S4GP3n7EL58YhZLKq3utgqKVQ6/9fmT+PD3L2EkGdTUdH73vaN46P95Ke7e2YWxDqSPUoUaJT61WLMXqxw+9L1LODoUw+tvtm7gZiNevCeJNVoXtgEhBB9/bBxv+5en8I2T87j/QAr/3xsPXfMYv9eNvqgfkyvydsOZUg1/8JXTONgfxVd+7d7GOefOkS7UeaJaaU5BP/uJDusoHcxRavtY58WmqNfTmVRJhlisFLWdVz755CRqvID3vXS3pufrQYNQ2yLZq4QQ/PHXzuLxy+mOWVfZch3Tq2UcVDGhPxALYE6FQk2J5aNWhRohBH/w1TPwul347dfuU/18PXC5GOztkJ+3mKvggacm8ZffOn/NWfNXPv0c3vep51STaqdnsw0loZZGdrZcx4ceutiSrFjIVtDfQaEGAL95/17s6g7jlx84jvMK6iSO7zx8JxJq5pES+UrdcMvHiN+LiN+DucyNWRfIgTob9W4gWIcSAcxk9CvU5BRJlLAx0/bx8cvLiPg9ODqkPT+NwuyMr62ClWLtmsws+rUeYl9ZdASLTNkc9fdD58TcWqOHtocS6jPJbyTkKqIrWru8zb986xHsTUXw3z513BbDiA7k4RBqNseo1CzqdEC1A+iGttHWKxXxKc4Ja4X1xkj7x8QMVKGcnsnig9++gFceSOHFu5Odn6AD9+xKghdIIz9gI+YyZbzrP55FLODFr9+/B0cGY/B7XTgxtXYtKRZXYDXmdqu3fATWbR9VWD7OlQXslMuY2kCoLZa4xkS5EihpohuhUEsXqvib717EXaNduG2HMXZuShD2eXBwIKraxmmrYjFbgdvFtJwkorhlWPz5nppR3ozjFTRKKJmip1HfjKnVEoKs+zrfbiPRExazhS7Mb51pcz1oEGphedXOUEJ9HoSatcBoyw5BIPirb1/AzYNRQ4cvwj4PRpMh2yrUOF7AsfGV66xuEkGvrqxDSqjJNc6o5VLOpMbZ45fTODIYa1jNGoX3vWQXOEHQnVFlFPKVOn7Ypm5phS89P4MvPj+DVx5I4SNvv1XTv+nzuLGvN4L9fRGMLxVkG8FKbJ0A0RonFfHhOQ3DK3/3vUuYz1ZU2VaagR873I9UxId/frS9vc1ff/ci/uJbF/C6m/tw7Pfux8feeXvLAYeRZFB2AJAQgr/81gWsler4q588fE2DmOYhHr8q1i2Xlwp41388o1h1SlWre+SGsbBOgiol1GoSocYqtHzUkqF2JV3Evz9+Ba892GeJNfhG9Mf8iPg8uLRFVO3fObPQIFY77WMXJELk0IByQq0/7sd8VqFCTUHOKgCEWA+KGhronz8+LQ7VvGafIjLIaOzvDbe1fCxUOfzERx7HH331LP7lsQl88slJAOL+971zi/jeuUV87eSc4n+LEIKzczncMhxHIujVRKh99+wC/uHhy9cNDBaqHPJV7jpFUivEgyw+9d67UOUEfPNUZ5vZuiB0VKhG/F5U6kKDgDca+QpnuOUjIO5hdsxQo5aPGyM3hhJBzGcq4DS+T/RpcmfHoJSFapTrUSs8PbGKu3cmZfMClSIW8JrmurCVkC5Ur7H483nciAW0rUMUSgYuYkHzCMuHzi3iQF/E8NzNobg+JedWxwrN02vTV4oFvHjgPXfBzTD4wnPTVr40B5sAh1CzOQbiATCMuon7GxXtmqapqB/LOiwfBQW5KHGD7P0A4Le/cBLJMIu//emjpjdJXrQriWSIxddbHAguLuTxsx8/hly5jk/+0l1IRfzwuF04MhTH81OZdQLL5wMCCg5xWhRqwDqhpkKhlhNc2NUjQ6gFg+L1lkUpdoW4sKyiIFJi82YEofYX3zyPUo3Dn7/lZssbZneMdOHE9JpphzsrMZctIxXxyTY1+mJ+pCI+nFIxScSpUCoaVQxPrZSwoyto6v3AMAz290W2n0ItoT5IWY1CzWjLjqcmVjCbKeO/vXS3ooadGhzsj9pWoXZiOoN8lcNL9m4k1MxXqAW8bnhcjCnNh3yljhemM7otfFphtDuEHzvcj08fu6rZUs9I/OnXz+Hd//Eszs4pW6+/fmoee1JhfPhnbsERnVmDe1Nh5Kuc7KAWtQrvZOXDMAzuHO1SPbxydi6Lf3/iCt5x9w7cPmKM1atW+DxuvOe+nfjRWPqaSVxCCI5PruIPvnIaH3tkHO+4ewf+6R23IeRr39Qd6Qq1JdQqdR6/++Ap/J/j03jvS3bi0MC1k/WJEIu9qTCelRrlH3tkHI9cXMZnn5lS9P/41LGr2NUdwt0drHMbhJpChVJdUsKwns5H7mTYh1KNV6VMqNR5/NpnnofX48IfvuGg4ucZCYZhsK8vgosaLR+/f24R3zilnFjphL//wRj2psJIRXwd9zHqSnBQBaE2EA8oVuVwfOfzAkAVaurW1ofOLuD3vnwG9+5J4udNdjRph/19UawUay2byp/40QSW81V89r134+X7e/DRR8aRLdXxxFganEDQE/Hhf3/jnOIBk4VcBavFGg4NxNAT8WlShowviyrKifS1g8b089wX62z5CIhES2/EpyhLj+M7N80p2VUwQb1OCEGhag6hJn4W7NdjWspVEfV7EGCv7T0MJQLgBIJFjaokag0u11MKSntk2SSFWqXO48pKUdUQgRy2i0ItXahdp0jSug5R8AKBu4N6NRYQyXaja++VQhXHJ1fxmkPGOxwMSZnkaobVbyTQKIlkG4UaIJJthwZj19gUO7AnHELN5vC6XeiN+G1Z7GzEcqEK1u1CNHBtwZiK+LBSrGkmBhpT5zKNEb3B8hQrhSouLubx7ntHO9rOGAGP24XX3dyHh88vXXOAf35qDW/56BMo13k88J67cPPgeuPith0JnJvLou6Sikwldo/AOqFWq5lOqNXdHnnLR5cL6O4G5sQDPOdyq7JFVZKdpZdIOTWTwZdOzOKXX7ILe3utzcMAxFyUSl1QZYG4VTG+XJQnWCUcHY6rsotSolDze90IeN26spmaMbVaMtXukeJAXxQXF/ON9e9GBj3syBW+gGi35fe61Fk+Kpg+D/s88LgYwy07HnxuBhG/xxQ72IMDUUytlkxTUm0mHrm4BLeLuY54SoS8ulTmXKNWaH8/MAyDaMBrys/12MQqeIHgvqZcOCPx03cMo1Dl8NREe2s/KzC2mMcXn58BAHzxudmOj1/IVvDs5CrecGTAkEGEPSlxPx5bak8erNs6db7eHaMJzGb+L3vnHR5VnX7xz52eOum9J5AQSgDpHQuiay/Y+9rbupYtP1ddy7qWdd21su7aERUbCohY6B0CISGk996TSZ9yf39MISGTmTuTCaBynofngUzhZube+/2+73nPOT2S9+miKPLM2iMEeKv4w9lpkl4z2rh6Zhx+GgUvbMhHFEVEUeRv645w2Zs7+Wh3BVdOj+WpC50PBsWHeNPU2UenHeu7x1bnsGp/FfednjLs7z0tIYj9Za00dfbxjYWg+Wh3hdN1LKe6nQMVbVw7K96hFReYawpBcIFQs5CrUjLUrGuUKyq1j3ZXkFvbwT8uzyD6OOZnHYux4b4U1uucWvjVtPVww9t7eGZtLpvyG/g6q4bbPtjHE1/nOnxtU2cf+8udKzkbdX3k1em47LQYJkRrnSrUcms7CPFVD1GiOEJKqC8tXf1USKgbpDRMAXzUcrr6DZItEGvbe7jv4wNMjNay/LppHh+qkYo0S17fsSq1ps4+3tpSwtLxEcxJCeGRs9Po6NXz758K2ZjfgL9GwT+XTaaps5+dDuxiB8LqmjAu0p8QX7WtqQnmulXKPru4wUyklR5DqJVZ/h0bKH1/HaHVUNfh/L6tN4pOlUC+FhJlNOygu/uNGE2ixy0fwZyjVt3W41Ye3smM+o5eu2rFGMv5UeWGTTOAhU9zeL16Ky0KNRcJdqkobuxEFI9a9Y4UvxZCrbmzj2CfwYT7SHJPQZpCzTaU6eHP+Ke8BkwiLBmFGjIp1JdevYkaiUrunxucKdSsmBit5Uhth9uK1lP4eeAUofYrQFSA5hd7QxuIRl0foX7qIQV7mL8aUXSf7LI2yRw1RsIsm66RBiTnWAq/gQTWaOP8jCh69Ea+z60HzM2av359GK2XkjX3zmNK3GDCbEpcAHqjSF23ZaPnCqGm14PROOqWj31yJanONoqhoVBrVuYZZHJbhklnn8Hpwmc0iQ6ny+CoDai7SoTn1ucR6K3kzkXHPw8DzE0++PnnqJlMIoX1OsaEOS8cMmK0lDR1Sd60GiSGzQd6Kz1i9yeK4vEj1CL96NWb3Mr2OdnQ2NlLkI/KaUNTEASiA1zzfZeiUBMEgYAR2gkeC12vnm9zarkgIwqN0smwgRuw5sn8Umw/B2JjXiPT4gPxP6a5FOitoq273+2JyqMKNcfnmb9G4dGmmSiKlDV1sT6nDi+lnKnxo2MPPDMxCI1SxqY86VaLnobBaOKZdUfwUSmYlxLCVwer7WbhDMSaQzWIIpyXEemRY7Ba6hXWD58XZZAwiGXF9ASzIspqVegMWwub2FHczL2np9j2GScafholvz9rLFsKGvk8s5q/r8/jra2lXDMzjgOPLeHvl06StFYmWPLQjiUqdpU08+m+Km5fmMTvl6QOS3otHBuCrs/ABa9so99g4vdnjaW6rYcfj9TbfX5Pv5Gn1uRy2/v78FLKufS0GKfHqJTLCPFVU+9qhpoEQi3U0pxxpV7ZXtREUogPZ4w7fjm79jA23I/Wbr1Tt4e3t5WytbCR93aUc+M7e7lv5QG8lHKaOvscrr1Pr8nl8jd3sqO4yeH7W0m36YlBpEf6U9TYSa/eOKxCPLemwyV1GsCZls/amj/jCEZRlHQf8FErEEXokahCePn7QkwmePXqKTYy5kTA2pTPG0CoiaLIn7/Ips9g4qGzUwHzkM5VM+L437ZS1h6qZf7YUDJizbVuSaP9WIp9ZS28t6OMHov13RGLa0JqhN8gZUh7t54rlu/kiW8OOz3eEqtCrXHw/duqZExzIUsvUutFrQSlosFkQuk0Q81SM45w2EYURT7YWcYTXx/m9U1FiKJo22+MhkItLcKftm79EMXfzx3DE2pWJwv3+mpG0XmMiLfavKfvHiXLR+veZUy4Z+yBtV4jG0b7OcBkEmnp6ifEb3D/KsR3hAo1owSXEy/PZrFbsSm/kQh/jceUigNh3ScXnSS5qp5GU5dzhRrAhGh/evUmiodZ407hl4FThNqvAK5YU/yc0ajrI8SOpZd16rDBzRw1WxaGgwXPT63ASymXXGAPhxyLLPhYK5vRxPSEIOKCvPnXj4X0GYx8m1NHVlU7D5w11u5mcooly6tCZ1nYXSHUeiwb0FFWqCm91EOChIcgNBRazIW3SaGkpLETo0nkrJc28++fihy+VMpEka9KgUxwb6JoW2ET24uauef0MaMyUSgF4f4aYgK9yKwYnRy1vWUttHhIteUI1W09dPcbSY1wTqhZrcByJMrzpSjUALSWRv1I0ajro89gIt7DXuf2MC7CSqh4XqG4o7iJOz7Yz+7jpHSpa++1NSqdISbQ26XAcSn2r2CZ4PRgMbRidwW9ehOXSWgAuwNrg1GqpZ4j1LT1UH6S5LjWtfeSW9vB4rSwIY8FeKswie43tKQo1MDcOPOk5ePXWTUsenETn2dWMSspCLXC8wQrmNW2c5ND2JjfOOw0ekVzN99k1bD6YLXkjCGpaOvu58Z39rIpv5HfnTWWm+cl0NLVbzcD1mQSWX2wmgte3cYz644wIdqfZCfZWFIR4qsiwFtJoYNGgVHCIJYVaRF++KjkkoZXevqNPPttHjGBXlw9M07yMR8PXD87gUkxWh5alcXyzSVcMc2sSrOq9aXAOiwy8H5R39HLn7/IJibQi9+dMdbh688eH8ET56dTr+tjVlIQdy1KJsJfw2f7q+w+/7HVOby9vZTUCD9eu2aK5GON1GokWb3B0Qw1Zw11GOh2IW2/YDSJ7CltYWbS6OYtS4GVWCmoG/666Ok38um+Ss6ZGEnW40v44JYZ/PWC8bx1wzSAYfebvZahP5MI93980G4DM7uqnfZuPXvLWlErZEyI0pIe5Y/RJPLUmlwyntzAc+vzqGzpZu2hWlYfrGZHUROFDTrbAIlUxAV7kxbhx4Zc+0TtQBhMIlLEYz4q6aqUogYdq/ZXct3seJti5kQh1M+cuTswP++d7WVsyK3nj+ekDcr0e+y8dNIi/OjqN7I4NQw/jZJwf7XNhnEg2rv13PHhfh7/+jALX9hIQb2OvFod0QFeaL2UFoWa+TzYWtSI3iiyLrvWYXO732Ci3DIkdqxCLbemg4Rgb5fISet9wJk6y2z56HzQBkauUHv+u3z+svown+yt5Pn1+eTWdqCz7GlGo55cMMasiN9S0Ojx9z6RqO/oI8xOHyEyQIMgjIBQkxAj4qf2DLk6HArqdShkgm2AZaQYzYyvkwXtPXoMJnGIQi3cX0N9R5/bCk1zP8nxvcGWw+2hLHYwD/psKWxkUWroqERIjPmlE2q6PgQBgpzkVU+0CCRO2T7+siGJUBMEYakgCPmCIBQJgvBHO4/fKAhCoyAIBy1/fjvgsfWCILQJgrDGkwd+CtJhDYz9pcnxj0Wjrs9u09RKrDS4OUFinX52FCguCALh/mqHmRpSkFPdTnywt0sNiJFCLhP464XjKWns4vefZvHE14cZG+7LpVPtN2rD/MxES0GLpZkQcHQaXm904PGsUEC3pVHtCqEWYfF2VjtuiPcOuJ1FhGqdbxBCj9pixYb6kVnRSkG9jtr2XvaWOm5s9eqNTlUhMpnZ2sudiaJXNxYS4a/h2lkntmE2MVpLTrXnCZU1h2q4/M2dLHh+I+/vLPP4+w9EgSXTQ4q1RYaFUNte5HgC2gqDUXSqRgGLQs0DZIq1ERB7HBRqY8J9kQlwxEOEWlGDjoUvbCT9sfVc/dZuvsut4+Z397pksekucms6JBGqYM5Rc8nyUaJKMcBb5THLx8qWbv71QyFnjgtjcuzoqJHC/NSE+Ko9UgTcuSKTu1ZkeuCoRo7NBWbyZXHqUEIt0KL2cVdJaLRmYzg5H/y9FHR4UKH2eWY10QFevHr1FP5+6SSPva89LEoLo6Kle8g0uq5Xz7LlO1nwwkbuXXmA+z8+yMWv7fDY0ITRJHLPRwfYU9rC85dN4pZ5iSwYE0qIr5qvswZnLxmMJm54Zw/3f3yQPr2JB84cy3+um+aR4wDzfm9MmC9FjiwfXVCoKeQypsYHsq2oyaE6st9g4s4V+8mr6+Dx88ePGnHqLuQygRcvz+D8jChW3jqL5y6b5PRaOBbWYRHrWpdT3c55r2yjrqOXFy7LGJJncywEQeDGuYlseGABr149FYVcxpyUYDIr2gbVQKVNXbz4XT6r9ldx7+IU3rlpBqenSVd4mZtoEgk1CTWEFcGWGqZZokItt6YDXZ+BWUknNkcPBhBqDnLUvsmqoaPXwPWz4vFSyZk/JpQb5iQwIyEIL6WcAxX29wMb8xro6jfyl/PSaevuZ/nmYttjRpPIi9/lc/6r27hnZSZ7y1qYHBuASiGzEWUrdlcQ7KPijU3FzH9+I3d/lMn9Hx/k6v/uRm8UXVaoASwZH8G+shan35VRApkC2LIFu+zYnQ5Ea1c/d63IxEet4O7FKdIPeBSRGuFHnuV7P1jZxrPfHuHMceHcMi9x0PM0SjmvXzOViyZH2ayqk0N97RJqf1+fR2u3nr9fMhFdr4EPd5WTX6ezWUyG+pnzBrv6DGzKb8RLKUdvFPlk7+DMxI35DbZhhYqWLowmkZhALypbewapm3NrXVcqRmg19OiNdPQ4/s70RucKtQBvqwrF/TXzi8wq3thUzDUz49j40CLAPKDZMYoKtbhgbxKCvX9RhJooijTo7CvU1Ao54X4al7KWB0LKkHagj2UvOkpDp4UNnSSG+EjK9ZQCrZeSPoPnM75OJjR32Y8OiArwokdvdJtQNErIYh8Ny8fM8lZ0vQYW2amFPIFAHxUhviqHTg4/ZzR39RHorXJq5ZsY4ou3Si55UPsUfp5weicVBEEOvAacA6QDVwmCYC/1+BNRFCdb/vx3wM9fAK7zyNGegluICvCi32Ci+TioQU4kmjrNlo/HwqpQc1c9ZpXce6scb0TDXCiwh0NOTftxtXu0YnFqGOdNimTtoVqCfFS8tGyywwX+qhlx5Daam855fQpe+r6A1q5+Ln59Owue32g/52CgQs1i+djZZ+C7w3V8m13Lt9m1fLCzjPs/PsAbm4ptFh8sWwbvvw8JCXaPxWgSeW59HlP+vsn2s8gwCZ/hAEJtbEwgByvb2GHx8c+t7XBIQPfqTZJs1tzxFc+saGVXSQu/nZ94whtmE6K1VLR0e0xZI4oimRWt/PHzbDJiA0iP8ueJrw8Pyu/zNPJthJpzdYLWW8nS8RG8vb1UcjaGFIVagLeSFg9Mllknao+H5aNGKScp1HdEGXp6o4mdxc2UN3dx14pMOnsNXD0jjicvHM+mhxYR5Kvi9g/2j2pOW3NnHzXtvbYpMWeICfSitVvvtKllhWRCzYOWKH/9JhdBgL9KyCRyF4IgkBGj5VDVyIqA8uYusirbyKvTnRTF9obD9URpNXbvB4GWhlarm9eqVIWavwcVai1d/WwvauKCyVGcNynKbgPIk1g01rxufm5R/GRXtfNtdi2/fW8fmeWt/OmcNNbeN48PbplBS1c/9398gG+zazlQ0TqiDIFXfypiW1ETT180gWXTYgEzEXV6WihbChoHvfdL3xewtbCJx85L59v753PfGWOI8nC2VEqYH4UNncPuE2xW4RIvz0umRlPS2MXa7Nphn/Pc+jw25Tfyt4snjkpuoicwNtyPV66awuxk9xRTfholwT4qypu76NUbuW/lARQygS/vmuvSeyaH+tqyLTJiAmjq7LMpyvaXt3DmS5t5dWMRp6eFcf+ZjlVv9jCcQq24sZM/fn5o0L3OavkopXkZbMlOllqv7bKovGedBAq1EF8VQT6qYQk1URR5d0cZY8N9mZE4mABUyGVMitFyYBiF2ppDtYT4qrhhdjwLx4ayNrvWRj4/s/YIr24sIi3Cj62FTRyqarfZqMYFeeOjkqOSy1h1x2zevHYqj5+fzpp75/Hjgwt56/ppPHx2Kme5YZe5JD0ck4jNLn84SMlZhaM1ZpeD/bDBaOKmd/dS1tzN8utOI+g4ZG1LwdhwPwrrdbR193PPR5mE+Wl48fJJdvcnSaG+vHzlUTVoUqgPxQPupaIo8trGIlbuqeDmuQlcOSOOBWNDWJ9TR3Fjp204ynp9N+r62JTfyJnp4cxLCeGj3RWD1oMHPjnIsuU7eWtLiU0tcVZ6OEaTaLM07+jVU9HS7bI7TKTWvK7UOslRM0jI3bb2L5xZpg4HURRZvrmE9Eh/nrpwAhFaDWPCfNlW1GRTqPmPAqEGsHBsKLtKWugznPg9nifQ2q1HbxQJs9NTAnOdMFKFmiNnC6sKyhN1oz0U1us8ZvcIRxVUnnReONlgVY0fO7gfHWDec1dLzMA9FlIcj2wKNQ9+vhvzG1HKBeamjN7eISXM12HW8M8ZzZ39tv2aI8hlAumR/qcItV84pIwmzACKRFEsEUWxH/gYuFDqfyCK4o/AL/Nq+pnA2kiQGnjuKvRGEzuKm/jftlLJTUhPw2A0E4b2CLUQXxWC4L5Czepn7+WEQAn317j9f4B5Kq2ypYcJx9HucSCeu3QSH94yk7X3zXdK6t06P4mgQLNVwK5WE//+sZB5z/1Efp0OpVzGlf/ZNXTxOMbysaNXz1X/2cXtH+znzhWZ3Lkik7+sPsy2wiaeW5/H3Od+4oFPDpKnM8J1Qzn51q5+nv32CEtf3sIbm4rRC0dvZzHhEmwoQ0Jsfx0XG0Sv3sQHO8sA8xRQjQM7nx69ES+V89unO4Tam5uKCfBWctWME2/nZD0PPGH7VtSgY/7zG7nk9R0o5QKvXzOVW+cnYRI9p4Kyh8L6TqK0GslWJ49fkI5cEPjL6hznNi4mk6Sw+RBfNc0SLZwcIae6HR+VnHgP2XQ4w8RordsKpa2FjSz55xauemsXC1/YRGFDJ/+8YjKPnpfO9bMTiA/24eGz06jr6B22ieYq/u/LbG54ew97y1qoa++l32Cy5VKOj5Y2eRxtWS+lFkdSm2VaD6kUK5q7+eFIPbctSLId62ghIzaA4sZOWzNGCrr7DXywq9zWRF5zyEwQGE2iLaPkRKGqtZuN+Q1cMjXGbqMv0GdkE+IGo/PJY7AQah6y8lmfU4fRJHLeJM/kgzlDbJA3S8dH8PqmYpa+vIXzX93GnSsy2VPWwj+WZXD7wmTGR2mZPyaUxy9IZ2thE3euyOTi13cw/Zkf2C8xJ2wgdhQ18fKPBVwyJZrLpw1Wzi9KDaOj10BmRRv3f3yAqU99z+ubirlyeiw3z0t0WSElFanhvrR1D79PMFnuC1IJ7wsyokmL8OPFDfl2M+Gyq9p5Z7s5k+xk2BuMJuKDvSms7+TfPxZS0tTFc5dOkqwwtocMi4r3UJVZ/fS/baX4qhVsfngRb984XdL9+1jEBXnT3qMnr66DBl0vXx2otjS0i/l4byVbC4+q3F3JUNMo5fipFZIzWXaVNJMU4jPqRLoUWJWb+fU6DEbTkEGZzQWN5NZ28Nv5SXaviylxgRyu6RgyeFHW1MWPefWcMyEShVzGeZOiqG3vJbOilfU5dby9vZQbZsfz1d1zidKaPwdrBrBMJnCr5px7AAAgAElEQVTHwmSeumg8SaG+LJ0QyU1zE5kQrSU51Jez0sO5e3GKU+WjPYyP8ic13I/lW0ps37E9SB268VE7t3z8Ma/BrAC7eCJzkkOGfd7xRlqEH939Ru78MJO69l5evXqKTXHlDMmhvnT0GmxE0p+/zOGF7/K5cHIUDy4x568tSY+gQdeHwSTaMs6s9f6m/AaaOvtYnBrKtbPiqWnv5UdLzmd7t562bj3BvmqeWXeE5VtKAGwEqnVIzZoV66r1Z4TlfHOUoyaKomX4zvH1H+SjQia4n8W+p7SF/HodN8yJt61788aEsKe0xUYGjFaEwIKxofTojewrG52IAHdQ39HLp/sq3XJnqrOs68PdV2MCvdzOl7YOAjjam3ip5GiUMlo8UDcei169kfKWbkm54lJhJXx+ybaPVnvZ4GMItaM9VvcG6qWsDzaFmgdqSFEU+Smvni8yq5ieEDSqsSJjnAye/ZzR1NnnND/NignRWg7XdLidz30KJz+kEGrRQOWAf1dZfnYsLhUE4ZAgCJ8JghDrykEIgnCbIAj7BEHYZzCcGELml4woy/SEK4SaKIpDAnuHw0Orsrj6rd08tSaX9TnOA5pHAy1d/Ygidgk1hVxGsI+aRp17i12PZVrQWcEV7mcOKXd34bAqQaQqKTwNH7WCeWNCJBV+KoWMK2YnATBtchIvXp6Bn0bJy1dM4cu756A3ikNt8wZYPnaLAre8u5cjtR3868rJrP/dfNb/bj5bH1nMvkfPZNUds5mbEsIPR+q5a0WmbdrQYDSxvaiJtYdqOf/Vbfxvaykhvmr+eUUGF02Lx2gh1WIjXFOojYs1T7OWNXfbmtS5DpQ5Pf1GpwQruE6oFdbr2JBbzw2zE2z2LycS1nMxZ4SEWllTF9f8dzd9BhPPXzaJDQ8sJDrA66i3tBsqGJNJ5IgTJSFAfp2OsS404yK1Xjxw1lg2FzSyx4n1p1SFWoivmvYe/YinN7OqzApWdxqA7mBCtJYGXR8NEpW37+0o46UN+azLruXmd/ciE+DlKybz53PTePmKySwYGzro+YtSQ1HKhSE5JJ19Bj7ZW8FDq7J4b0cZpU1dPLY6hy8P2M/BATMpu2J3BduLmrj8zZ3MevZHrn97t8u5lNY8Eql2LtIVaiqPFJufZ1YhCNhUOqOJSTFaRNE17/f/bS3lL1/l8IPlO/0mq8amqDx8gif0Vuw2W0FdNUz2lNXysaXLve/JauXjPENNMeKcFDDfA7/IrCIpxMflRuBI8No1U7lzUTLNXf38YWka394/n51/PIMLJw8uDa6ZGc/WRxbz7f3zee3qqfhplNzzUSY/HqnnoVVZDi0TrWjQ9XLfxwdJCvHhqYuGKjKte5Yn1xxm9cEapicEcv8ZY3j8/PEe/Z2PxSyLWmo4e2CDxGxFK+QygUeWplLe3M23OYNVakaTyJ+/zCbYV80jS9PcP+ifCZJCfdlX3srrm4q5cHLUkHXDVYyL9EMpF8iqaqe+o5fvDtezbFrMiAZTLjstBn+Ngr+ty+PW9/bxu08O8tXBatZaBgg2HD5aC/UbzPcFKYQamC2lpCjUTCaRPWUtzDwJ7B6tSI3w43BNB1Oe/J5n1x0Z9Ngbm4qJ1Gq4aLK9FgJMjQvAYBIHDePVtvdwzX93461S2OwDz0wPR62Q8dz6PB789CCTYrT8+Tfj0CjlPHpeOvHB3pwWf3So7t4zxnDFdM+T0IIg8PDZqZQ2dfHpvsphnyedUHNu+fjBznKitBounBzl+gGPIqyE986SZm5bkMSUOInZ2mDLtixu6GLVvkpW7qng9oVJvHzFZJsTyOlpYbbPcJxNoWZuZr61tRSZYCZ1zhwXRpRWwwc7ywGotOzjnjh/POmR/hyoaCNSq2G8pfaw9jlyLTWOq5aP1v6KozxFvWXQxplCVS4TCPZVu02ovb+rHK2Xkgsyjl5f81JC6DOYeGZtLr5qBZHa0SHeZyUFo5QLbPaw7eNXB6rdigUQRZHffXyQRz475NZQYEWLmWiNHSafcEK0luq2HrcG1aU6GQT7qEdFoVbc2IkoSotBkIpfA6FmHYq1Z/kI7osWDBLWB1+1ArlM8EhswGsbi7j53X14q+Q8dHbqiN/PEcaE+6LrNbh9TzuZ0dzZb1NJO8OYcF969EbqRuhidgonLzzVsf0GWCmKYp8gCLcD7wGnS32xKIr/Af4D4OPjc4q+9TCOTtxLv5Bf21jEixsKeOv6aXatZUwmEUEwS6DXHKpl2bQYPttf5fbEzkhRaZHehw8jzw/zcz/frEdvRC4TnPqfh/tr6O430tlncHnio6K5m6fW5KKSy5ggUUlxopEUZS6YJkxIYMJpMVx22tHJ8Qh/jc1qzwaFAnrN5+DLW8rJGpPIy1dO5rxJQwvD6QlBTE8I4rvDddz+wX5W7a9iSXo4d3+Uya6SFtv/8dmdc2wZQoHeKgwyOXKjiYQoCcXcAEItOMCH+GBvypu7uXpmHC9uyCe3psPuuS+KolmhJpFQcyWP6c3NJXgp5dwwJ0Hya0YTQT4qogO8yHYzR01vNPGPDQW8s70UjVLOJ7fPIi3i6Pkd7m/Oacpxw1bw+e/yeXNzMfeenmKbYj0WRpNIUWMn88e4Nsl77ax43thUzBubi5npwEpJykYYjlrTNHf2u2091m8wcaSmg5vmJrj1encwwdJcyKlp53QnE/Df59bz+NeHbf9Oj/Rn5W2zHOZB+muUzE4O4bvDdfzpnDQEQaCooZPbPthHSWMXfmoFn+0/SqK9v7OcrMp2Hj8/fUhjffnmYnxUcjb8fiG7S5rZVdLMp/uqaNT1uZRLGRNoWS8lXrdGiY3zAG8lnX0GS5aGe7kFJpPI55lVzEsJ8biFnT1YMwWzKtuZkxxCo66PT/dVYjKJnDsp0tYIs6Kn38g7O8oA2JTfSEqYL3l1Oh4/P51Xfio6oaHMvXojn+yt5Mxx4cMq+6yTp+5aN1sbJU4Val5KuvuNIzoXRFHksa9z2FfeapdoGk3IZQJ/WJrGHySQO9a8x3GR/sQHe3PJ6zu45b19gFnF+tkdc4bNhDSaRB745CCdfXpW/Ham3SETf42SafGB7C5tITnUh9csuVmjjdRwP0J81WwrbLJLbpskrg0DsWhsGD4qOZnlrYPIydUHq8mubudfV04+rvm6JwoPLhnLtPhAlHIZ50yMGPH7qRVy0iL8yapsY8XuCkyiyLWz4kf0ngHeKu5YlMzz6/MB817pD59n028wkRTiww9H6jEYTSjksgGWj9LOB7Oi3Xm9UtLUha7XwFQXyIvRxtS4QN7fWY5aLuP7I/U8ep45IeJQVRu7S1v4y3npwxILVhLmQEUb0yyWjY98doj2Hj0f3zaLhBAzAeqrVrA4NYz1h+vIiNGy/LppNnv0cydGcu7E46PWBThjXBjT4gP51w+FXDIlxu7gpVRCLcpiH1jS1MXiYx7r1RspqNexraiJh5aMPS73OFdgbc7HBXlz3xljXHptcph5H7E+p5ZP9lUyOymYR85OG7SmBfqomJEQxP7yVhIt54F1gLa6rYeHz0617bPNNVwBxY2dtp5EYogPz14ykYte305yqC9aLyUhviqbQi23toNgH9WwFn/DIdRXjUyAuvbh94sGS7aqlOG7UDcJtb1lLazPqePmuQmDzsGZScEoZAJd/UbevWn6qKlRfNQKpsUHsaWgkT+fO84j77m/vIUHV2Wh9VJy3ax4l/Y4n2dWs9Nih/vZ/iomxbiWNWzNiE0MtT90Mc9SU24rsr/+O4JRdK5QA3OO2mhkqFkzrUbD8tFTtvYnI5o6+5AJR63hrQj2UaFSyNwm1IwS7GAFQUDrgdiAHcVNvPR9ARdOjuLFyzPcrj+kIsVSIxY2dBJ2EqjoPYnGzj7JhJp1qLSipfu41O6ncPwhhVCrBgauFjGWn9kgimLzgH/+F3h+5Id2Cp6C1kuJt0ou+Wbf3NnHm5vNtgiPr85hTnLwoEaGKIrc+v4+dL0GFqaGYjSJ3LYgie1FzSeMUMuqNFu5DLdpCvNX0+CmQq2734i3Uu50Mxfmb23G9bm0aRVFkave2oWuV89bN0yTbJNxwqG0/I6BQ4v5MeG+Q3MUFArEnh4EzAq1j2+f5bQRsCQ9nKlxATy1JpcnLM36Zy6ewIQoLUmhPoM+57kpIfTLFaiNegIDJUxeDSDUUCqZFh9EeXM3C8eG8vn+KnJr7Td/+yx2TBoJFjGuKNSq23pYfbCa62bHnzS5CGC2tcmuaiO3poMWiZt7q2f0o6tz+CarhkumRPPAWWOHNE4FQWBCtOve0hvzGnhzczFRWg2v/FREQ0cfp48Lw2dAzqFJFFlzqIZ+g4m0SNcm8TRKOTfPS+SF78zE6nBTq1IVatbCv6mzz+3NVF5dB/1Gk8uF4UgwPlqLIEBOdQenpw0ml615eN39RvLrdLzyUxHjo/x5+qIJfHe4nlvmJUpq/i5JD+fRr3LIrm6nvqOPBz45iFoh44NbZjAvJYTNBY0crGzj0qkxLN9SzLs7yrh4SrTNxqumrYc1h2r45lAtN89NIDrAi0umxnBGWjhfZ9VQ3NjFb1ywwwv1VaOSyyTnI0hWqHkfLTjtKamlYFdpM1Wt5ubR8UCgj4q4IG+bVdoL3+Xx6T4zwVnQ0MkrV00Z9PxP9lbQ0tVPUqgPG/Mb8FLJUcoFzs+I4qe8BnLcJOY9gY15DbR09XONg0a6r1pBYogPBy37CVdhtE0eOy5SrTkmul6D2/f6Vfur+HBXBXcsTOa6EZIDxwsTorW8ds1UKlq6OS0+kBve3sOFr23nrkXJgwYtrNiY38D2omaed2L5d3paGLtLW3hkadpxazQLgsC8lGC2FjZhMolDmmNShy0GQiYTSI/yH0Q89xmM/GNDAROi/TnfzvDRLxGRWi+u9LCtZUasllX7qthb1sJZ48I9Ypt805xEvsmq5Yy0MCZE+3PHh5nEBXnz+yVjueejA+wvb2VmUrDNwtMVhZq10e8I1rrHuhaeDLggI4rZycGsOVTLU2tyqWnrISrAi415jQgCXDY1ZtjXhvqpiQ3yItNiAb29qImthU08+ptxQ2zoHzo7lUmxWm6emygpz3i0IAgCfzwnjcve3Mnb20u5e3HKkOcYTCZJ94IIrYaYQC/2lbXY1Hhgtvo214gGlHJhVNR2I4WPWsFfLxjPafGBLn8fkf4avJRy3ttZToivmn9dZT/D+4/npFFQr7Pd44N91MQHe3PepEjuWpRse94V0+P414+FfLqvkgAv8/oaG+SFn0bJPy7PsOWepUb4sa+8FVEU2VXSwqQYrcuDKQq5jDA/jcOIAL1FoSplbQr1U7ucodbc2ce9Hx0gJtBrCJnpq1bw4uUZRGo1DocDPYEFY0N5bn0e9R29ki1oC+p1vLO9jMunxWAwiqw9VMO5EyNRKmTc+9EBjCaRlq5+Gjv7CPNz/J5Gk8hXB6pZuaeCA5VtnBYfSKRWw+qDNfzfb8a5lEle0thFmJ8a32GcYlLD/Qj1G36gxhGstm/OBvGCfNSSa25XUFCvQyETSPBgdMCvQaHW1NlPkI9qyL1JEASiA7xGlKEmd1IzgDmHeySfb3e/gQc+OUhiiA9/u3jiqJNpACkW0vZIbQdzU04ei+KRos9gRNdrsKmknSE+yHytVbR0nxR5t6fgeUgh1PYCYwRBSMRMpF0JXD3wCYIgRIqiaPUouQAY7PNwCicUgiAQFeAleeL+lZ+K6O438Pylk3jk80O89H0Bf7FMGYJ58tzqT76vvIXJsQGkhPkRF+R9wgi1zIpWorQam5/5sQj303Cgog1dr97lCa1evVESeWLdQDZ09JISJn3yp6q1h+q2Hp6+aAILR2htc1xhJdQChhbzqeF+fLi7fHCzWaGgr6MTDXDZrCQmS5iqFQSBJy4Yz5Pf5DIpJoBl02PsNt7A3KwwqVXQ3wNqCQ3rgYSaQsGyaTH0GoyMi/RnXJS/rYl8LHr6pWXqgXmT2dajRxRFp4XaG5uKAPjt/CTnx34cMTFay4bces7991a3Xv+HpWncOaDYtff+WwubzNeZhM+0pq2HBz49yLhIfz67YzbPrDvCZ/ur+MSO5Y5SLnDjnAR+M9H1RuS1s+L594+FfLa/isei0u0+R+pG2LrpGontQZbFFjMj9vhZwloJBnvKor9/m2fLowBzhsZrV08lIcTHJbufJenhPLUmlwte3Q6YbQbfvPY0G/G4KDWMRalhADxw5lhW7K5gU34jGbEB9PQbueT1HdR19JIe6c+tA64drbeSiyZH8/HeSpdsdGUygagADVVSM9RMolMrH8A2KNHeYz/rUwre3lZGgLeSJekjV21IxaQYLfvLW6lp6+HLA9VcNyue2vYe8o7JQ+vVG1m+pYTpCYEsmxbLw58dYsXucs6dGEmIr5qJ0Vr+s6VE8nXuaXxzqIYQXxVzkx0XM1PiAthS0Cjpnn0sJGeoDQhwd4dQE0WRt7eVMi7Snz8sPT7kqqcwUPX9ye2z+OvXuTy9dviSwV5u2rG4bnY8SaG+nDkuzGPHKQVzU0L46mANeXW6IUMXRpOIO868E6K1rNxTgdEk0tzZx7Pf5lHd1sPfL504anlwvwZMigngw10VpEf688LlGR55Ty+VnHX3zUMQBERR5PLTYpiTEsyi1DBUchkbcuuZmRQ8QKEmrYGVEOzDxrxGp/fKQ1Vt+KjkQ5TCJxIymUC4v4ZZFhvK3aXNXDwlhl0lzaRH+qP1dlx/TYkNZE9pC6Io8tz6PKK0GrtqwpQwX1LChpJXJwLTEoI4c1wYb24q5uoZcbYsTitMJpwqEKyYnhDE1sImWrv6uWtFJrOSgvnyQBXeKjkPnjWWMZZG/skId501ZDKBpFAfci0RAMMRJxmxAYPIY7lMYNNDi4as06F+ajJiAthb2kJqhD9BPipb3X/JAEJ36YRI/vJVDqv2md117jndvfMpQquxZW7Zg95kJdSlDd8NGUZ1gpd/KKSlq58v7ppjt79x0RT7FquexkILobaloJHLJZBM32bX8uCqLLr7jazcY7bjFgR4z2LXGeKr4tHfjOPptUfIq9U5JNRKm7q4a0UmR2o7GBvuy20LkrhpTgJ5dTrWHKrlxyMNLilXS5u6SBpGnWY+ToF5KSFsKWi0O1DjCEaJTgZB3kpKm6RFr7iCwoZOEkN8JK9HUmAbGPwZEWqPr85hfJSWZdOlEaIVLV3DnoNRAZoRKNRMkgZztd4jI9Te3lZKfUcfr90x9bhFioT6qkmP9OeNTcWcnxF1UmS9egJWovvYPL3hEBmgQS4TqDxBPfJTGH04vaJEUTQIgnAP8B0gB94WRfGwIAhPAvtEUfwauE8QhAsAA9AC3Gh9vSAIW4E0wFcQhCrgFlEUv/P8r3IKjhAV4EWNA0sCMNuzPb0ml/d2lnPNzDiWTY8lq6qNd7aXctHkaA5WtVHb1sMPR+qJD/Zm4dhQ3t9ZzqUWq7+4IG9+ym84Hr/OEByoaHPYxL1wShSfZ1Zxy3v7eP/mGS419KTmZVkXinoXlXDW7LRjJzBPegRZchtihja7xkb40as3UdnSTUKID7pePU1tfUR0m8/BycnSG1+TYgL47M45kp6r9lKDDlBJaFIeo1CbGR1sm+BLj/Rn7aFaWrv6hxTHPXrXCDWjSaSr3zjspBuYN+8f76nkqhlxw9qRnShccloMzV39TIrRDmvNdSy6+43sK2shNsjb6fTe+CgtRksemjMiRm80ce/KA+gNJl67ego+agV/u3gij52XzpHaDpvlmhWxgd7DkuzOoPVSEhvkTXXb8BsgdxRq7uJQZRvBFgvO44kJUVr2lR3NkhNFkW9z6li+pYTLT4th2fRYogO83FbehflrWHPvPDbk1tvUzsPdn4N9zY2SjfkN3H/mGN7eXkpdRy8f/XYmc+xMv900N5G12bXMc3EyLibQW7pCTZSaoTYyS5SCeh0/HKnnd2eOcZrn6UksGBvKmkO1XPDqdkwi3LYgiU/2VrIxv5E+g9E29fv+zjJq23t5adlkksPMjQi9UeT62eZm6IRoLQaTyPLNJUQGaDhc3c6di1Lcuj4bdL34qZWSP4euPgM/5TVw+WmxTqfEp8QF8kVmNVWtPZLvd1ZIbZRYm17u5qjtK28lr07Hs5dMPK5Wj55GWoQ/H906k7w6HZ12coMUMoGMmACnv6O3SmHXnnm0MX+MeQ+xtbDRLqHmjlpuYrSWd/Qm9pW1cPuH++nsNXD7wiTb/3UK7uHs9AgK5+u4fWGyR20zreemIAiDiLqZSWb7M4B+o2sKtZlJQSzfUkJmRStzkodfuw4e50xVVzAuwh+tl5JdxS2cMyGSzIpWSTabU+MC+DqrhlX7qjhU1c7zl046oQo0qXj47DSW/msLS/+1hXMmRPJ/vxln+74NJhNqpbQG5rSEQL48UM3z3+Wxs6SZnSXNyAT4+LbZzEg8ebLyPI37zxhDZ5/BZRXDcGvD1PhA3t1ehkIms9ltHYtzJkTw+OocnlyTi1IucLabg0pRARry64YnwayDNs6U62CuFZo6+ySTNLpePV9kVnHB5KgT3kMYF2kmezc7IdSMJpF/bMjn9U3FTIkL4B+XZ/DjkQZkMoFLpkTz5YFqDCYT18yMp99g4um1R8iv0w2bpflTXj33f3wQhUzglaum8JuJkbbPLthXTYivih9y610i1EoaO1k6wfHz56aE8OWBarsDNY5gzdqVOdnXBPqoaOkcDctH145XCrReSrReSkm5uO6gqEFHa7ee+GBvp0pFKWjr7uf9XeXMSwmRRKh19OrZU9rCzXMT7T4epfVia6H9PF1nMBil15CuqletaO3qZ/nmEs5KD7fZKR8PCILAv6+awgWvbuPelQdYeeusYX9XURTJr9eRFOJLdnUb3x2u5/xJUZhEka8OVnP7gmS3+zmeRpPOQqhJHIhUymVEBWgobz5FqP1SIWmHJ4riOmDdMT97bMDf/wT8aZjXzh/JAZ6CZxAdoCGrso0+g5GfjjTw1cFqnrt0km1q3mgyB7iuza7lt/MS+eM55myMR5ammQO8l++kR29EJoBJhFeumsLZ4yOYlxLC6WlmciQu2JtGXR/d/Qa8VYNPrfU5tbz8QyEA18yK59qZcR5rBDV09FLd1uMwW2hOcgj/WJbB7z45yDNrj/DURRMA2JTfwIrdFbx29dRhp3W6+414S2jcWb3XnWW1/ZBbz7qcWl5aNhkwe7fLBLOq62eF6dMhMxOmTBnykNVPP79eR0KID3/8IpvL2vtINFg+G+Uo5YBY31eKQi14gFJBMfh8nW1RMWwrauL8jMHqJhuhJtHyEcw2CI4ItRc35KNSyLj3jJNj4nYgogO8eOKC8S6/TqracmKMuQh0Roq3dfdz70qzjdK/rpxM0oCpbI1S7pIqSioitRrqHFzPBqM0Kx+rz/bIFGptblnSjBQZseYGV15dB529Bu5deYDadrMi7KmLJnik2TUm3I8xEu9/i1PDePnHAooadLy5uZgzx4XZJdPAbOlz6PElLn9m0QFeNhW2M7hq+djqJqH25uZic77i7AS3Xu8uLj8ths5eA8+sO8KFk6OIDfImLdLPnE/Y0Mn4KC3tPXpe21jMotRQ271zSlwABqNos/WdmRhEUogP//yhwPbefhqly6HY9R29nPXSZoJ8VPzn+mmSgtV/OFJPr97EeRKsP6fGmSfgMytaiQn0cuncsWalOFWoWSwfO3rdOxfe31mOn0bBhZN//haAgiAwLvLnkRt7LCK0GiZGa/lkXyW3zk8a1AA1iqLThpk9WJuiT3yTS1u3nq/unmvLiT0F96H1VvJ/v7GvNB8NzEsJ4dlv86hr70VvaairJBJq0xKCkAmwq6RlWELNmql643HMVHUFMpnAjMQgdpU2W2pPkySrI+s+7pl1Rwj2UXHhlJ/HPS41wo+3rpvGqv2VvLujjEithtsXmp0ZpO4RwKxQA1i5p5KZiUH86dxxdPUZftFkGsCS8Z5V3U+JDeA/RhP7ylvs5nSDeV8+NyWErYVNnDkuzKl6cjhE+HuxKX94VbtVoSpFpRjqq0ZvFGnv0Q8Z5rSHLzKr6eo3nhS2z4IgMH9MCD/lNQyrrhVFkf/7MpuP91Zy5fRY/nrheNQK+aB67uYBdqc+anPW9pG6oXbhoijy+qZiXtyQT3qkP8uvO42YwMHkqdwylONKfm9rVz+t3XqSHSjUAOaPCUEQ4NN9lS7VyJbTwek9IdhHRVe/0aOuDr16I+Ut3YMyWj0BQRCYFKMlq9LzOcmf7a/ioVVZAIwJ8+X73y8c8XvuLG5GFJGsGNqY14DeKLJkvP3BrehAL+p1vXyTVcPG/AZbf08KpLqcBPmoyXNA3DvCf7aW0NlvOG5xAQOREubLXy8Yz8OfHeKj3eVcN0wN+88fCvn3j4VolDJ69eaL5D8DXHC2FDTy6e2zJavCRhNNXeZeTogLavH4IJ8T5uJ2CqOPkyvV9hRGDWePj6C9R8/9Kw/ywKcH+e5wPTe9u5cuy1TwY6tzWJtdy/+dO45Hz0u3TdZqvZQ8deF4REQeOy+dQ0+czZp753F+RhQqhYwl4yNsz7VOgVW2DJ7s1/Xq+fOXOfTqjaiVcv7yVQ6PfHaIXgsxMVJkVpit+Zw11C+cHM2NcxL4cHc5mRWt9BtMPLb6MN/n1rP6YDWf7q1k9rM/ojumydUjcTPjo1bgq1ZQ3+FYofbG5mK+yKy2Zbrl1nSQHOp7XFUHHoEg2CXTwLzpASio01HS2Mm67FpiQwc0zUabUJOiUFMojqrsjiHUMmICCPRWstGO4tJVy0eAdgdN9NKmLtYequXmuYkembz6uSFKq2F8lD9vby+lz2D/ntBnMHLF8l3sLmnh75dM9HgxMBzC/TUOw8alKtQ0Sjl+GgVNbk4bNur6KKjvPK6TZVZcOjUaf42Cv63L4+HPDiETBJ69ZCIrb5t1QibHFwEka8YAACAASURBVKeFIopw4avb6dUbefjsNIfPd4eATA7zoamzT1KxZTSJTrMQAJu1X0uX66RqS1c/32TVcMX0WElNFk9CEARunpfIpocW8beLJwLYbHfzas3F3ef7q2jv0fPQkqPF2n+vn8Z7N8+wff7Bvmp+emgRWx5ezHe/W8DMxCA25Na5fDxPfpNLr8FEV7+RS9/YIckC5asD1YT7q23NSkdIDffDWyXnywPVzHtuI8+tz0MURaevg4EZatIsH92xb9lR1MSaQzVcOT12yODSKRx/3LYgiZLGLjbk1g/6udEobW04Fsmhvngp5Ryp7WBmYtApMu1ninljzETY9qImW0NdqkLNX6NkQrSWXSXNwz4nv05Hv9FExnHMVHUVs5KCKW/u5p8/FCAIMEPC/XdcpD9qhYz2Hj1XTI91KffoROPM9HCWXzeNs9LD+ecPBbb9g1GUfi9ICfW11Q3Xz05gcmzALyp75nhhary5H2ASGVahBtiGbIYj3aQgLsiL7n7jsOoRq3OGVMtHQJISpbvfwHs7y8iI0Z40OYrLpsXS1q3n1Z+KyK5q5/n1ZsviXr2RrYWNPPDJQT7eW8k9i1P4+6WTJF3faRH+tr3mQKzaX8UL3+VzQUYUn985ZwiZZsX4aC3FjZ1090tzBCix5Fcmhjgm1ML9NVw9I473d5a5lANuFK1OBo6fZ93rt3Z7TqVW3NiJKCJpEM1VTIrRkl+v80hvr71Hz7PrjvD2tlIe/SqbmYlB3Dw3kcKGTqpaR05KbC0yq8mqWnts+/Zj0Wcw8v7OMlbuqWDD4XpCfNVMjrXfZ4wK8EIU4c9fZvNFZrVL1n5S83ZD/FQ0d/ZLrkes6OjV8+FOs/3+aHzvUnDZaTHMSwnh+fX5dnuk2wqbeOWnQs5KD+fK6XH86Zw09vz5DB4+O5VHlqbyzo3Tzfnhnx0a9v+obe/hYGUbr/5UyLSnf2DtodphnztSNFt6OSE+0gm12CDvU5aPv2CcItR+JViUGsZv5yWy/nAdvmoFz1w8gUNV7Ty99gi5NR2s2F3BLfMSuXXB0PymcyZGkvPE2dw8LxFftWJYWwHrpvVYBv6traW0dPXz76um8OWdc7jv9BRW7a/iiuU7nZJPjmA0iXybXctn+ytRyWVMiHY+5fzgklTC/TQ89GkWf1t3hIqWboJ8VLzyUxFPrsmltr2XncWDi9geiQo1gDB/NQ0OFC3VbT3sLzcHbh+xbBCP1HZ4XH5/ouGjVhAb5EVBQyf/2VKCSi4jNmzA7yiF8HIHSiXI5eY/UmC1fTyG4JPLBBaODWVzfqMtQNiKXlcUat7OG6crdpWjkAk2a7RfGwRB4JGlaVS19vDR7gq7z3lzUwn59TreuHYqV844foHskVoNjbo+DNaRwmOgd8HWK9TX9bBxK3YUmzf/88cc/8ZKgLeKOxYls6WgkdKmLp67dBJXzYjzqG2WK5gQpSXCX4OXSsFHt84iNcLzBcJvJkUhCPB5ZpXT50qdPh+JSnH1wWr0RpErZ7gWfu5JxAZ52wjUhGBv1AoZeZap4TWHakiP9B+0Nwj2VdvNB4sL9iY1wo+zx0dQUN9JqaV54Qw9/Ub+/WMha7Nrue/0FJ6/dBK6XsOQLLdjkV+nY2N+I1fNiJNkoaSQy5gUo2VTfiONuj7e2FTMqz8VSTpGg0TLR+u54KoFbIOul/s+PkhyqC8PnDXWpdeewujgnAkRxAd788amokGNDqlWsMdCLhNs+8Hrj7Ma9RQ8h3ER/gT7qNhW1ES/QXqGkhWzkoI5WNE2bHNyd6m5TpkUc/JaxV8+LYYZCUHsKmmRlJ8G5py5STFaZILZzeTniL9a1CpvbTVP1xuM0tWqMpnA7KRgIvw1w6ohTsE5wv01RFnsweKChyfULp4SwwuXTZKkXh8OyZYB0uIG+3sZa/0g1fIRht8ntnfrueXdvfzx80Nc8voOSpu6uHvxyeNsMispmEumRvPm5mIufXMHr28qZvELm5j01w1c9789rM2u5faFSTy4RPr+JS3Sj6KGzkF1WHZVO4+tzmFuSjAvLZvscLhvYrQWk2jutUiBdU+aJCGb8pGlaQT7qnn0qxxJ7w3mzCxwbvkYbBvC8xyhVlhvzmQbE+753M2MmACMJpHDNSNXqf392yMs31LCk2ty8VUreOWqKVxlqX+2uWmtOBDbCpuQywQMJtFu9lllSzdn/GMzj60+zJ++yGZtdi1npYcNu6ezRjFYbdx3OhiGORaSoyN81fQbTXS4aBW/YlcFuj4Ddy4cPst+tCEIAk9fNIE+o2lIPfV9bj13fLiflFBf/nXlZJ64YDy3L0wmzF/D3YtTuGtRCovTwrhuVjzbiprsDl4fqe1g4fObuOi17by4oYC27n7W5YweoWat3YJ9pfcy44K8ae7qt2tvfwo/f5wi1H5F+MM5ady2IIn/XD+Na2bGc92seD7dV8njX+fgq1Zw3xljhn2tlKaxlVArbzZvRvaVtXDTO3t4Y1MRv5kYyaSYAGQygd8vSWX5dadR1NDJbe/vsxWbruK/W0u4c0UmPxxpYHpioKRJJ1+1gpeuyEDXZ+DdHWXMSgriiQvGU9HSjd5oQqOUsb1o8GLdo5eWoQYQ7qdxSBKuPVRj+3tuTQetXf1Ut/WQ/jO1PHKE1HA/vsmq4eO9lSybFotaM2DhGU2FmitkXYiFoFAMnfRfnBZGc1c/K/ZU8N+tJbZmmasZamC2Ft1wuI4Xv8tnb1kLjbo+3txczMa8Blbtr2LphAjCfiFhre5gwZgQZicF89z6PG59f5+tUQ9Q1NDJaxuLOD8jijPGHd8GQ7i/BpM4/LSo1I0wmK0B3LV83FbYhNZLyfioE9M8u2lOIokhPlw1I9Y2eX+iIJMJfHHXHH78/UJJiiN3EB3gxZzkYD7PrBpCqB8LqYSaRinHX6Nw6xz4bH8VE6O1NmXYiYZCLmNsuB95dTqqWrvJrGjjvAzXGlLWzKvvJajUqtt6OPvlLbz0fQFL0sO5bUGyrSFQ3OiYkFu+uRhvlWtWmfPHhBLoreSru+dyfkYUL/1QIOl7s54rzqydgn1UyGWCywNF724vo627n9evmXpKnXaSQCGXccfCZLKq2lmXffRcdsXm7VjMTQ4mPtj7VEP9ZwyZTGBOSsggQk2KrZMVs5KC6DeaeGtLCYdr2smuaue9HWW8samYg5VtvPxDIdPiA4kJPLkydwfCX6Pkw9/O5KElY3ngTOkN9DsWJvPnc8eddHnCUhEV4MXYcD/KLHkp5jxF6feCZy+ZyOd3zZGsaDwF+5hiUak5UqipFDIun+Y8W9URkkOte5FOu49bLV9dUqjZ2W+IosiDq7LYXNDI2uxa6jp6efemGR63yxwp/u/ccQT5qJieEMiae+dx9cw4rpsVzzs3TSfr8SX86ZxxLjlHpEX40W80UdrUhcFo4tGvsrnwtW34a5S8fMUUp+usddg6p9oxoVbf0ctLG/LZUtCIQiZIurdqvZTcNj+Jg5Vt1LVL28/pDebzQe2khxBoiWRp7XLPGtweCup1KGQCCcGO1XfuwKqSHKnt496yFlbuqTSLAH43n9X3zCPMX0NKmC/h/mq2FY2MUKto7qaipZszx5njauyphl74Lp+mzj7ev3kGD5+dikou4yIHzjjWDPGx4b4E+6gcqsuPhVmh5vz+484gXq/eyP+2lbJgbOgJz1hMCPHhrHHhrMuuxWA0YTKJ/PP7Am59fx9JoT68d/MMh3XN9MQg+g0mu2rQ59fnoVHKeOv6aay7bz7nTYpkT2mLy2o+qWju7MNLKcfHQZTLsbCJTk7lqP0icaoi/xVBKZfx53PH2f59z+kprNpXyd6yVm5fkDRixUGAtxI/jYLKlm6q23q45b19aJQyrpweN4SsO3t8BP9YlsEdH2by7LdHePx81zKaKlvMNiJnjgvj6Ysm2p2EHw5zkkPY/PAivjpQw/wxIURqNaxOC+OMceFsyK2zScGt6Ok3SrZjDPVTk1XVNuzj32TVMilGS0tXP4dr2jlSa17gfmkKNYDfn5XKuEh/FDIZ186Kg08H3G5Gi1BTqVwj1KwKNTuE2oIxoQgC/MUyeTY3JYRxkf42y0cpdnexQd5EB3ixfIAP9Ksbi1DJZbageuCk8L8/kRAEgReXZfDKj4WsP1zHXSsy+fb++Ygi3LvyAN5qOX85b5zzN/IwIi0TrnXtvdS19/J1Vg0Nuj5eWpaBSi5zqWka6ms/B8AZRFFkW1ETc1OC3W7QjhReKjkbHljgloXZaCDqODTaLjsthgc+yWJPWYvD7JeuPoPkTXWon+sqxdyaDg7XdNim3k8WpEb4mRs7FluN8ya6ZpkUG+RNeqQ/qw/WcNPcxGGbh426Pq77725au/r56LczbXl5UVovNErZsE0sk0lkTXYtq7NquHFOgktWmXctSuaWeYlolHJuX5DEN1k1bC5o5LLTYhy+ziDR8lEmEwjzUzvNWz0WmwsamRofeMJsW07BPpZNi+Wj3RU88c1h5o8NwV+jHBGh9sBZY7nn9DGnGuo/c8xNDuabrBoK6s1uFK58nzMTg0kN9+Mf3xfwj+8Lhjwe4K3kX1dNOe6Zqq5CpZBxz+nDD2vaw/EenBoNRAd4UdhgXptczVMM9FHh+UTgXx9mJATxbXYtSU6s+0aKCH8N3ir5sHsRa7bqSBVq7+4o44cj9fzlvHRusDiajIQIHC0E+6rZ+ofFqOQyBEEYcSM/PdL8+p/yGgjwVvLhrgqunRXHA2eOlZSnFOGvIcRX5TBHLbOilds/2G/73JNCfSTfr2cmmQf7HOX1DYTUoVyr+qXZDZv44VDY0EliiI9Lwx1SEe6vIdxfzcHKNnYUNTE+SutyLqHRJPKXr3KIDvDi90vGDiJYBEFgbkoImyzOQVIcJ+xhbba5Zrl6ZjzfHa6noqWbOQMez6lu5+usGu5enMyCsaEsGBvKbQuSHJ4P0QFenBYfyN2Lk/lsfxW7S1qGzVQc+jubJNXWNkJN12cj8Z3h88wqmjr7Tqg6bSDOz4hkbXYtO4qb+XhvBeuy67h0agzPXOw8j32aZUBib1krp8WbrzmD0cR3h+vZmN/IH89Jsw1qzkgM5quDNZQ1dzu1bnUHNW29LqnTAOKDj7q4/RJ7vr92nCLUfsUI8VVz1+IUXt9YNCgE1l0IgkBckDf7yls58OF+jCaRT26bTcIwN7OlEyLNU0vby7hlXuKw/tfHYntRE09+k4tMEHjywglEaF1X9nirFFw986h13P9unA6YPcmfXnuEmrYeW9PWFYVakI+KlmFykgrqdWRXt/Pob8axp7SF3NoODlSaybdxv0CFWnqU/+BFYyBpNZqWj2oXAksdEGqBPioePGss1W09rNxTSXlzl5lQc8Hy0V+jZNsfFpNXp0PXayA13I+Veyuoau3m2lnxbC9qpq695xcfOC4F0QFe/P3SSZwzMZIb3t7Dk9/k0trdz5HaDt6+cdoJyZcLt6gGa9t7+b8vs2m1ZOHde3oKKZYNrWSFmq/KLXVSSVMXte293HOCczR+bc3dpeMjeUx9mA92lTsk1HS9Bvw0LhBqLp4DXx2sRikXuCDD/YyP0UBahB+f7a/i+e/yyYjROrRVGg63zEvkwVVZPLQqi/vtKOTr2nt5aFUWLd39fHDLzEGKRJlMICnEd9gm1r0rD7A2u5a0CD9uXzjUytoRBEGwFXfjo/wJ81OzMb/BKaFmtFk+Or9Wwvwdq9mPRaOuj8M1HSckVPwUHEMuE/jbxRO58LVtvL6xmD+ekzYiQk0QBFSKk5soOQXnsDZyyi0Tya6soT5qBet/N5+C+k5KGjsRBHNjuVtv4K0tpVw6Nfpnq+D6NSAqwIvNBY2IokiTro/A5OObfXoKcPXMOE6LDxx19w+ZTCAp1GdYtbxVoSZFpeinVqBWyIYMXlW1dvP8+nwWp4Zy89yEk55I92T24dhwXxalhvLvHwvxUSuYEhfAUxdOkPwZCILA+CgtOdXttHb1D8oki9BqyKvTce1/dxPqp+aT22axuaBx2L6VPaRH+uOtkrOvrNWjhNpRhdrILR9FUWRtdi17SluYmzJ8PTNSZMQE8HVWDV9n1TAtPpAVt87ky8xqRGBKXAAKmcDhmg7q2nu5ZV7iEEJ49cFq8up0vHLVFLtqpXkpIXyRWU1ubYdTonZXSTOHazq4blY8H+0uZ8XuCp67bBJvbi5mwdhQ5qWEoJAJlA9QqPXqjTy2OocAbyW3DyChnK3dKoWMz+8003JVrT2sy66jqrWHWAfqWCsMJhG5hHtDiJ/5fJCaxW4wmli+uYTJsQHMSjo5ekyLUsPwUcl5cFUWjbo+Hlmayp0LkyVdy8G+apJCfdhX1gILk6lo7ubSN3fQqOsjNsiLG+ck2J5r7antKW227cM6+wx8mVlFfLAP0xIC+fJANRH+GuamhPDVgWoCvFUsTgvl64M1eKsUnJUeztrsGmSCwDkTIll/uA69wUSwr4p1ObVc5WL8iPVcGK5mPYWfN04Rar9y3LUometnx+On8YxiKDnUl6+zalArZP/f3n3Ht1md/R//HEmWh7xnHDuJs0PIwCEJoUAIm7IDLdBBgZZCB9205el42h+dT/celDLaUkYpLVDKCIEyCyEDkpC9iJPYsR078Z46vz/uW7ITPCTHsS3r+3698kLjljhO5KNz39e5roufX31Cv4uSj542iT+/+jaPry0/7MurN797fjvff2ITRZnJ/Or9pYOeqRAqZ/bStmqunO/Ua26KoodaTsBPfWsHrR2d71hQ/vm/b+P3ebh8XjENrR0s27ifv7z6NgtKssI7T0Y13xBkqEVb8nHiRMjMhF4ugN585lTqWtrdgJqz6GqJouQjOIv57gHTj3X7nI+UEm4jyenT8rhk7ljufW03xsBnz57KmTOGZ8dyKENtxc4aapvauWTuWB59cx81jW105LgXzyMs5ZOXlkh9Swct7Z397sRqaO3g76v28NK2al7dfgBj4LQpeUf3w0hUkv1ePrBoAre/sJ1d1Y09fpd1Bi31rR2kR/j9mZeWxLo+MpiPFAxaHl9b7pQgjCLDaigsLS2itqmN9k7Lu2cNrOTQFScWU1HXwg+f2swjb+zr8ZiizGT+dtO7mN1Dr6DJ+am8UVb7jsdf2V7N4+vK+fiSydxy7vSjyuw0xrBkeh5PrK+gozPY547wSDPUAArSEsPfKZF4aVsV4GROy8gzuziDueMyw5/HzqDFO8IvesqxFdrst7umCa/HRD0PGWOYPibtHX1Cf3zl3EEboxwbYzOTaWrrZGd1I3UtHVFdoJfBkeD1DFmZs8l5qeH+6EcK9f6KJKBujHnHxitrLf/7yFsYA99eOnvEB9MGmzGGb106i3N++jyV9a38YgCZubOLMnh+SxWl31p22OMJXmdeLkhP4m83nUx+ehIn9bGBric+r4fS8Zm8vqsmouNDVW4S+8kSy0zxY8zR91Crb2nn8w++ybIN+5lekMbNZ0SXMRyNC+cUsrumiUWTcrj7lV2c8cP/sK+XUphej+GG07o2u7V2dPLjp7cwqyidC2f3XEJ+8bQ8EryGv60s6/V3+0BDK196aC3LN1UCcP+K3WytbMBj4D2/fYWghS+f75wXFGcls9sNqLV3BvnkvatZU3aQX1xdGvF53ZFCGzBf2V7NVdn9B10ibR0RbcnHf60tZ3dNE1+9MLoSq8dSUoKXc48fwz/W7OXiuWMjDqaFLJiQzVMbKggGLV97ZD3NbZ386v2lLJ6Wd9h1lcl5AXICfl7bWcNVC8bzZtlBPnz36xxwf5dS/F6a3N/DSG7/j39d+DbAlPxUvnZhdFWTnLYd6fzsmS1kB/xRB+RkZFNALc4ZYwYtmAbwtQuP4+qF4ygdlxVRBs/4nBTmjsvksbX7+g2o3bdiN99/YhMXzSnkR++dG1HJvWhNL0gjNzWR/24/EA6oNbd3khRhQC07tavm9ZiMrtfUt7Tz8Oo9XDSnkOyAn5mF6VjrZL58Z+msQf85RiRvt7/DYxlQiyZD7bOfhauv7vOQ9KQEsgP+cD+E0GI40oCaRO97l89maWkRpeMzyUwZvkBCdsCP3+th2Yb9AM7upTf3UdvYHs5GiTxDrWsx3F827h0v7uBnz2ylOCuZi+YWctGcsQPKAJKj8+FTSrjz5Z38/oXtfO/yOe94vsFtDp0eYbnkvNToMtTWlNWy92Azt5wXef+ZoZKTmsgXz5tx1O/ziSWTKR2X2WMpTGMMi6fm9joHTM4L8K+1+w4LUltr+b8nNzM2I4nPnDV1UMqknjE9nwdX7mH17oN9ZhOHm81HElBLT2JFhBdgAF7YUk1OwM/xKhUyYk3MCfDKdqd3RsdRZKjJ6BDKcK+oayEpIb4yvONdUabzbx/qyT0xV+u30Sy0mbinFhHRbLSBd1YyeHJ9Bc9uquRrF8ZuX8GjNS47hR+9dy7bKhv6rBjRm0tOGMuW/fXMKc4IZ4oErWVzRQP7DjbzxfOmH1Um4/wJ2fzy2a3Ut7T3e03NWa96+l0nej2GzOQEapoGHlDbXtXAjX9aya4DTXz9oplc966SY7ouufSEIi51e421dwZ5cGUZ3106m4UTs9lQXoe1lpKcAD9fvpUfP72F82eNCZ8PP/ZmOXsPNvPdy2f3+neTm5rI0tIi7n+9jJtOn8zyTZXkBvzMKsqgM2hZvbuWHz+9heqGVm599wzyUhP56j/Xcfq0PL5w7jSu+eMKzplZEO5HPj4nEO6h9vjacpZvquS2S4/n4qOoCDI1P5WizGQeX1fBVQv6D5p0dEa2VsxK8eMxkQXU6lva+d4TG5lZmM45I6yE8kdOnYi1lm9dFnmWacj8kiweWFnGp+5fwwtbqvjmxTN7zAo1xrBwYjYrdjrnWA+sLKO1I8jfP34y6/fWsXp3Le9bOJ6d1Y28sv0AV80fR0VdS7gSSV1zO09v2M9lJxTRGQzy2NpyLphVSFKCh7+t3MMt500bUB/re284iU/f/wb/8/A6Wts7ue6Uo68OJyODAmoyqPLTk6JelFw8p5BvP76x1ywAcOpbf/2f6zl9Wh4/veqEY1Z+zJmEs8I7jTqDlraOYMTBk5xAV83r7qUo/7FmL41tnXzo5BKgq2fa9II0zpieP4g/wQg2VCUfo3nv5GQnS60fE3JSePuAU86jud25aBppXz2JXiDRxxkzhv/3whhDQUYiZTXNJPo8nDTROZGraWoLnyRHUt4NunojVDe09RtQW/V2LccVpvPEZ047itHL0cpPT+I9Jxbz19d2s+rtWj539jTe3W3nZF2LUwI0PYqSj41tnRH3XXvszXL8Pg9nj7ATosFkjAn3RYvW5LxUrIWd1U453jte3MEdL+6koq6FH7xnzqBtujllqlMa5rnNlX0G1KK5cJaflsjBpvaIMlaDQcuLW6s4dWrugPtGyLFXkhvg4TV7aW7rJGgVUIt3SQleslISqG1qxx9nJZPjXah6ysvbnAB7SY4y1Eaz7muRI/vjtLsZapH2O5uUm8qyDRU0t3XSEQzyzcfeYmZh+mElzeJRJOUUezOtII3bPzR/EEdzuAUl2QQtrNl9kMXT+q4iEHUbkQFmqD2zYT+fe+AN/D4P995w0oACkUfj25fN4kvnzQj3UZuS39X367ZLj+ecn7zAz57Zyo/e62RcP7SqjJKcFBZP7ft84MbFk/nbqj2c99MXqG/teMfz47KTeehjXVUtzp5ZQGqiD6/H8MqtZx623h6fncybbuuVp96qID8tkQ+edHQ97Y0xXD6viF8/t42KQy39tqWJNEPN6zFkB/wRBdR+/PQWKutb+f0180fcOcOsogx+dnXpgF572tQ8sgN+nn6rgiXT87jGvabak4UTs3lifQV7DzbzZtlBThiXyYkTsjlxQjbXunPpokk5h2WKdS/rHwoMg9OiKORoerxmpvi589r5fPze1XzzsQ1kBfyH/X8kdimgJsPugtlOQO0Xy7fy3ctn8+T6CoyB+SXZJHgNG8vr+crD6xiTkcQvri495r185k/I5t/rKig/1BzeaRRpycfsgHPRvPsCqKMzyB0v7mTuuExOGJcJOGWs3ntiMZeVFo2YVOxjbihKPiYmRpehFqEJ2Sm8vssp5xGqf95fuQYZHcakJ1FW08ysooxwUKy2sW3gGWr9ZCgFg5Y3dh/kkhNGVs+sePXVC45jfHYKj7yxj5vvW8PvvJ5w4+NDzW5ALdIMtbSuLMX+AmpV9a38a+0+zpieN6hZ5KNJqDH39qoGAn4f3/33Rk6ckMUXz5vO0tLBO0lJT0qgdHxmONugN1091CLLUAPc+v99B9g3lNdR3dCmco8jXGhD2K4DjcpQEwDGZCQ7ATWtF+NKKKD23x0H8HpMRL10JHZNznfm/v99ZD1ej+Hu6xeGN112uD3UEiIsD3/VgnH8ffUeHnljL2v3HqKqvpXbr5kfcUBOht4J4zPx+zzc9fJOTp3S98an5rZjG1Brae/kN89t4xfPbmN2UQa/u+bEYclsNMaEg2lHKs5K4fxZY3h2UyWdQcu+g828uqOGW86d1u81sSn5qVw4u5DnNlXymw/MIz8tkR1VjWCcfnYzC9MP+/vP6HZ+duR51/jsFA41t1NZ18LzW6pYWlo0KAGoK+YV88tnt/Hz5VvZXtXAVfPHcUUvPZidtWJkv9u5qYlU1ff9edhZ3cif/ruLD540IXzNcbQYk5HE6q+fE9Gxoc2PL26pYnNFPTcujq6X9rHi83r45ftK+dCdK7j17+uYWZjO1IK0/l8og8IYkw08AJQAu4ArrbU91ms2xqQDG4B/Wmtv7ut9FVCTYTc2M5mPL5nMb/+znSffqjisTm1IaqKPv9xwUq9fzoNpQYkzCa/cVctJbiPPaBY/cHhA7Yn1FeyuaeIrF3TV2zXG8MP3xlkfhKEIqH3pS1BXN+hvOyEnwCNv7qO1o5MWd3dZ3ARC49yYGS3lfAAAH9RJREFUjGSgljnFGSR4PaQl+Zweam55t0gvmob6se2p7btv0raqBupbOygdn3VU45bBEUj08bHTJ/PBRRP4wB9e5ZP3rubbS2dx5fxx1LslH9OiyFADJ4gyoY8d64ea2/nQnStobO3kE0umHP0PMUpNzA1gDGyrbOC1HTX4PB5+9f554WDVYDp1Sh4/W76F2sa2XvvZhS6cRZShlu58FvbXtfR7sfWFrU7/tNOmDSyTT4bGRPd3eld1I0EF1AQYk57IxvLI+ifJ6JET8OP3eTjU3M6EnBT9+49yJTkBEryGNWUH6QxaHlxZFs6CCJ0r+CK8aL6gJIsZY9L4wVObqWls46bFk5g7yi6MjzapiT6+duFx/O8jb/GHF3f02cIkmjYieWmJbCyvj3gcq3fX8om/rKairoUr5hXznaWzjkl7lMGwZHoe/1izl7V7DvL8liqMgaXzeg46HenHV86lpT0YDpbNL+m9ckRf5hQ7v1efuHc1TW2dnHv8wPpBH6kkN8DCkmzuW7EbgC376znn+IIe+7J1BoNRbcztL0Pt9he24/N6+NRZ8X3uOGNMOmlJPu5+ZRcdQTui5tCkBC+/el8pF/ziRT5x72oeufmUAZWQlAG5FVhurf2+MeZW9/6Xezn2W8ALkbypVngyInz5/Bn89Kq5lI7P5I4PzefRm0/hO0tn8a1Lj+fu6xew4qtnDdlOi+MK00jxe1m5q4aWtlB5v8gmunDJxwYnoGat5bf/2c6kvADnzhy9ZbsiMhQlHxcvhosuGvS3nZCTgrVQVtPcY418Gb3GuBe+57oL7+yAn9qm6DPU8tISyUpJYPP+vk+OVruNzeeNHzmLP3FOmO/58EIWTszmSw+t5c//3dWt5GPkPdSAfvuoffUf69hWWc/vrzlxRJ0EjDTJfi/T8tP4/fM7eOD1Mi6fV3RMgmkAp07NwVon46A3QRt9htr+uv7Lt7ywpYrjCtPJTzs2P5sMjhK3T9LOA410KqAmEC73pIBKfDHGhLNCVO5x9EtK8HLfRxex/POnM39CFre/sCNc6rE9ygw1YwzXnDyBmsY25o3P5Jbzph+zccvguWbRBC6YPYb/e3ITT64vZ1tlA/ev2M3minqsuzYEwptyIzEx1+nxFfos9eeny7bQaS3337iIH185d8QG0wAWT83DY+DRN/fxl1d3c8rk3Igz6RJ93sMyzwYqVPJv5du1pCX6OHkQy2J+5uypnHd8Ab+/5kQONrVz+/M7ejwummoGual+DjT2fs6wv66Fv6/ay3tPLI778wWvx7CgJJtNFc41l9A1nJEiPz2Jn11VStDaqHqry1G7FLjHvX0PcFlPBxljTgQKgKcjeVOFQ2XEWFpazNLSrt0pc4Zp8vN5Pcwbn8Xru2p5/0lOtlyki5+M5AQ8BmrdJrKb99ezobyOb182a8TVMR5yQ5GhdoyEskl21zRGVf9cYl9ogR8K6GelOCU4QtkokS6EjTHMGJPe727D1btryUxJYGIv/SRl+GSm+Ln7+gWc/ZPneWlbdbi3WaQnduEMtT52GD63uZJ/rS3nC+dM67cXg8Ad187nB09t5sWtVX3uCj5ac4szSUv08eLWai7o1kevu64eav1fPO8KqLX0eVxDawcrd9XykdPUvHqkS0tKIDfVz65qBdTEMSbdWT9EejFdRo+xmUnsrG7UWi5OhLJkPr5kMh+5ZyX/WruPpaXF4Qy1aILqV8wrpraxjfecOE7B+BhhjOGH75lLxaEWbv7rGoLW4i4JOX1aHj+/+gQyU/xRXUOYmJtKR9BSVtPEpLzUPo/dd7CZl7ZV86kzpw55v7SByAr4KR2fxV0v78Jj4MvnLxiWcXzj4plsKK9jTlHGoJZmPmVKLqe4/aEvnjuWP760k48unvSO88VIe6iBm6FW38YLW6ooq23iA0f0e/vNc9voCAa5afGxOxeKJQsnZvPspkry0xL77WU3HE6dmstTn12scr7R8RljVna7f7u19vYoXl9grS13b1fgBM0OY4zxAD8GPgicHdGgohiASNyYX5LFz5dvpbLeudgVaQ81j8eQleLngFvy8dXtzm7203VhNMYDas7O813VTU65hgR9+cWLK04sZkJOINwfJzvgZ39dS1eGWhQXymYUpvHA62UEg7bHAHtZTROv7ayhdFymSoqOUD6vh7GZyVQ3tFHnlnyMNEMtO+DHY3rPUKtvaedr/1jPlPxUbjx9ZNR7H+nGZafwy/cNrMF1NHxeD4sm5/DStqpej4mmh1pWSgIJXsP++r4Dav/dfoCOoOV09U+LCSU5AXZVN9FpLYk6SY57YzKcTRR+nzZhxZuxGaEMNfVPiydnTM+nMCOJ5zZVsbS0OJyhFs25QlKCl5vPnHqshijHSCDRx13XLeTzD77BhJwAVy4o5vnNVfzo6c1c8dtXeOIzi2lu6+y3h3LIpDznvHNndWO/AbV/rNmLtXDFvMHrH3ysnTE9j1Vv13LduyYyuzhjWMaQlODln5941zE95/7wKSU89uY+lm3Yz/mzxvDf7QfCvbg7ghZvhHNDbloize2dfOmhtVQ1tHLmjHwK3e+ZN8sO8qdX3+aDJ01gvL5zgK4+aiO50ouCaVHrsNbO7+sAY8wzQE/1W7/a/Y611hpjbA/HfQL4t7V2T6TzggJqIj2YVpCGtbBlfwNAVGnz2QE/NW7Jx1d31FCclayG1BDTAbWcgJ/URB+7a5poUcnHuJKWlMAZM/LD97NS/Gwqrwtno0TaTBhgxpg0mto6KattOqyHVnNbJ7c+vJZH3tgHwHVu7wUZmfLSElmz+yD1bsnH1Ah7qHk9hpzUxB4DatZabn14HRV1LTx40yISdQF2xHnX5ByWbdhP+aHm8Elsd9H0UDPGkJ+WRGU/JR+Xb9xPwO/lxBL1VIwFJbkBnt9SxdjMZDzaFBH3xrjzhF8ZanFnbKjkozLU4orHY5hVlMGGcqefd0e45KMunMaDjJQE/nhdV7bVjDHpJPo8fPOxDeyva6G5PUhOamTr+0nu3LGjqpGzjuv9OGstD63aw8KJ2X32Zx5prpw/jtqmdj53zrRhHcex3sB6wrhMirOSeezNfax6u4b7VpTx/BeXMCEnEHWGGkCFW9nivtd28/lzp9PRGeQr/1hHXmoiXzxfJWJDZhdlUJSZzJLp2pAYT6y1vWaVGWP2G2MKrbXlxphCoLKHw04GTjPGfAJIBfzGmAZr7a29va++3UV6kO+W5tp9oBGIPEMN3IBaYxvBoOXVnQdiIvV+SIQCaj4fxNiFJmMMxVnJ7KltUsnHOJcdSKBmAD3UwDmxAg4r+1hW08Tlv32FR9/cxyfPmMwzn1+sgNoIF2oMXdfcQWqiL6rSbnmpieypbebptypoae8MP37fijIeX1vOLedO58QJA2uwLcdWqAz1+r11PT7f6ZZ2irS8c0F6Yp8lH9s6gjyxvoJzZhYowBojJuYGqKpv5VBTm0o+CmPS1UMtXk3OT8VjnA2aEl9mFqazo6qB5rbOcMnHaM4VZHQJlfhuaO2IqodaZoqfrJQEdlQ39nnc5v317KxuZGlp7GSngdNH6usXzSQ1woy9WGWM4cI5hby0rZoHV+4BYJPbW88pDx7Z+iA31Q84mzpPm5rLX1eU0dYR5O5XdvHWvjq+ecnxEVdMiQcJXg8v33rmO0pjSlx7FLjWvX0t8MiRB1hrP2CtHW+tLQFuAf7UVzANFFAT6VFo8bPrQBNAVBlJOW7T0M376znY1D6oTU5jWiigFmPZaSH56UlU1re6JR91cTNeZQX8tLQHaWh1spOiuWg6rSANY2BThXNB/rUdB7j4Vy+xt7aJu65bwBfPm8GU/DSVexzh8tISaWrrpKKumfQIs9O6v/albdXc+OdV3PnyTsDpo/W9f2/klCk53LRYpR5HquMK0/AYWLf3UPixupZ2WjucwGhHFDtNAcZkJLFlfwO1bonoI728rZpDze1cPHfs0Q1chsy88U4m4a4DTQqoSbhvhwJq8efC2YU8/bnF4Uw1iR8zx6YTtM5av6vko+aAeBWqYtHQ2kFzW3SbciflpbKjqqHPY/6z2SlFfsb0/D6Pk+Fz8ZyxdAYtiW6fti0V9VFvzM1Pc9YT71s4ng+fMpHqhlY+fd8afrJsC2fOyOfds3qqcici3XwfOMcYsxWnP9r3AYwx840xdwz0TfXtLtKDPDdD7W03Qy2axU8oQ+3VHU7/tJMmKdsA6Aqo+f3DO44Byk9LpLKuNerFsIwu2SnO5zdUti+aC+jJfi8TcwJsrqhnze5arr/7dXJTE3nsU6eyRCdCMSNUdmNHVSPpydFtEDj7uHxOnpTD5LwAj73p9MW97bENtHUG+e7S2RFnN8nQS/H7mJyXyltuQM1ay2W/epnvPL4RwN1pGvm/3/WnTKSupZ1r71pBXUs71lpe2FIVnlseW7uP9CQfp6l/Wsw4eXIO99+4iFOn5PKuydpMFe/Sk3wkJ3hJ8Ol0O954PYYp+cpOi0czC51qFBvK62jvdDLUElT2NW6FMrAaWjqcKjdRbNKemBtgZz8Zas9tquS4wvTwBg4ZeY4fm845Mwu49d0zGJedzJbKhm6tIyKbG44rTOMHV8zhpsWTOH1aHp86cwrPba7EWrjt0uO1GVekH9baA9bas6y1U621Z1tra9zHV1prb+jh+LuttTf3976jO8dWZICSErykJ/nYU9sMRJehlp3i52BzO89uqmR8dgrFWeqfBsR+hlqaU+bN7/Ooh1ocywocHlCLNgthRmEa/15XwZNvVTA+O4W/3nAS+ek6CYoloQ0XO6sbmVscXbPja04u4ZqTS7jzpZ3c9q8N/OGFHTy+rpwvnjc9pnofxKvZRRm8tK0acMrs7KhuDDeYjzZDbUFJNr95/zw+9pdVXPbrlzluTDqPrysnxe9l0aQcXtpazaUnjMWvi/ExZdGkHJX6FsAp9VSYmUSSfodF4kZxVjJpST427Kuj0A1y+KLotyyjS5qboVbf2hF1lZtJeQEeWrWHhtaOHksj1rW0s/LtWlW3GOGMMfzhQ/MBeH5z1YAy1IwxXLlgXPj+F86dzjUnT6ChpUPXGkWGkb7dRXpRkJ4U3j0SbYaatfDi1mrePVvp12ExHlALfR4qDrUoQy2OZQeOzFCL7mv0U2dO5eNLJvOpM6Zw30cXKZgWg0J17Fs7guET5WhdOKcQY+A7/97I1PxUPnqaToZjwfFFGVTWt1JZ18Jzm5wyO1sr6wkGbdQZagBnzyzgzx85iYNN7fx7fTk3nzGFM2fks7O6kctKx3LLeWowLhLLvnPZbD591tThHoaIDBFjDDML090MNec6gjLU4ldqonPd41BzO20dwehKPuY6G+22V76z7GMwaHnszX10Bi1nzFCVk1gxbUwaO6obwn20j6Y8eH5aEpPyUgdraCIyAMpQE+lFfnoiW90FTFQBNbccGDg1k8U1Cko+ArR1BtVDLY5lhUo+NgwsQ+24wnSOc8vBSGzK6zbHR1vyMaQgPYmFJdm8trOG714+W1lIMWJ2UQYA6/cd4rnNlQC0tAcpq22iM2gH1Cfl5Mk5PPnZ06isa2WW+/4iMjqcrNKfInFn5th07l9RxqJJOXg9RuXY4lioh1q1uxEz2R/5OvH4sRn4PIaP3PM688ZnsXr3QVrdQEx7MEhLe5CizGRKx0VXLUOGz/SCNNo7Ldvca4zRVLYQkZFHATWRXoSafyb6PFH1tclxM1hKclI4fqwunIfFeIZafnrXRXSVfIxf78hQ067TuJMd8GMMWOv0yBmor180k22VDSwoUZ/NWDFzbDrGwN9X7WXV27WcMiWHl7cdYHNFPR0DyFALyU9LCq85REREJHZNzU+jub2TPbXNumAe51ISvBjTtREzmk3a47JT+NvHTuZHT29mQ3kdi6flkpnsnId6jLMmXTI9f0CbuWR4TCtwemtuKK8DwKt/O5GYpoCaSC9CGUkpUQZPctxyYBfNGasdad3FekCt28VOlXyMXxnJCc6J0QB7qEns83k9ZKf4OdDYNuAMNYBZRRnKSIoxqYk+rl4wjvtWlAHw0dMm8fK2A2zZX09nMKgLZyIiInEudC1gf10LCbpgHtc8HkOq3xc+b4y2yk3p+CzuvWHRsRiaDINJeQE8BjbscwJqOm8QiW0KqIn0ItTbKNrgybT8NL58/gyu6tY4VIj5ko95ad0y1BRQi1tejyEzOYGKuhZAC+F4lZeWyIHGtgH3UJPY9b3L53D5vGLW7K5l8dQ8ijKT2bK/AZ/X4NEmGhERkbgW6rVbWdeiShZCalJXQE1VbuJbUoKXcdkpbKtySj5qY65IbNOWGZFehDLUol34eDyGjy+ZHC4NJ64Yz1BLSvCS4WajJGkxHNfGZiazv04ZavEs1+2jlp4Um/OZHJ0FJdncuHgyHo9h+pg0N0PN6sKZiIhInMsOOGvEiroWfB5dbot3qYndAmralBv3CtKT2HewGdDGXJFYp63VIr0YaEBNehHjATVwPhOHmtu1GI5zd12/gOUbK9lT28R0txa6xJdQxurRlHyU0WFaQRovbq1iQk6KAuwiIiJxLrSptqU9SFaK1gXxLpDo4+2aJkABNXECaq/vqgG0MVck1imgJtKLggGWfJRexHjJR3A+E1srG/SZiHP5aUm8b+H44R6GDKNQOR9lqMm0glTaOy3bqxq101RERCTOpSf5SPAa2juVuS6QluSjrSMIqMqNQEFaItY6t5XBKhLb9Bss0ov89FCGmuLOg8LrLiBjPEMNINmvqVMknnVlqOn7Id5NzksFYFd1I16dGIuIiMQ1Y0w4Sy1B64K4l5rYda6gTbkS2rQPylATiXX6hhfpRYrfR2qij+QE/ZoMilFQ8jHPDbImaTEsEtcm5ATwGCdbUeJbSW4AgI6gVYaaiIiIhPuoKUNNFFCT7kKb9kE91ERinSIFIn2YU5wR3n0uR2k0lHxMUxlQEYFzjivgmc+fzpgMBdTiXUZyQrgEqHaaioiISGhdoJJukprULaCmko9x77AMNQXcRWKaahWJ9OGvH1003EMYPUZBhlpJbgrQ1WxaROKTx2OYpM0W4pqUm0p1Q412moqIiEhXyUefAmrxLq1bhpqq3Ej3gJrOG0Rim77hRWRojIKA2hnT83nys6cxIScw3EMREZERYqJb9tGjE2MREZG4l+OWfEzQuiDuHZahpoBa3MtP6yr5qMoWIrFNATURGRqjoOSjMYYZY9KHexgiIjKCTMpzAmraaSoiIiI5oZKPKukW91ITnc3EXo8hQZ+HuBdI9IWzFlUSViS26TdYRIbGKMhQExEROVIoQ007TUVERCRc8tGry23xLpShlpzgxRitEwXy050sNZ03iMQ2fcOLyNBQQE1EREahUD89ZaiJiIhIjhtQ07pAQtlI6p8mIaE+apofRGKbAmoiMjRGQclHERGRI43PTsHrMXhVukVERCTudZV81Log3oUz1Pz6LIgjFFBThppIbNOsLiJDQxlqIiIyCvl9HibmBggkavexiIhIvMsOOCXd1DNLUhO7Sj6KQFfJR/VYFIltvuEegIjECWWoiYjIKPW7D84jxa9ltYiISLwLZ6gpcz3uKaAmRypIU8lHkdEgom94Y8z5xpjNxphtxphbe3j+OmNMlTHmDffPDd2eu9YYs9X9c+1gDl5EYogy1EREZJSakp/G2Mzk4R6GiIiIDLO0RB8JXqMMFAkH1NRDTULmTciiKDOZPDewJiKxqd+ttMYYL/Br4BxgD/C6MeZRa+2GIw59wFp78xGvzQa+AcwHLLDKfW3toIxeRGKHAmoiIiIiIiIyihljKMkJkJeaONxDkWEWCGWo+RVQE8cJ4zJ5+dYzh3sYInKUIqlNsxDYZq3dAWCMuR+4FDgyoNaT84Bl1toa97XLgPOB+wY2XBGJWSr5KCIiIiIiIqPcAzedrDJ/gt/nIdHn0WdBRGSUiaTkYxFQ1u3+HvexI11hjFlrjHnIGDMumtcaY240xqw0xqzs6OiIcOgiElOUoSYiIiIiIiKjXHbAr6wkASAtyaeSjyIio8xgdUl9DCix1s4BlgH3RPNia+3t1tr51tr5Pp8auouMSjk5cNttcNllwz0SEREREREREZFj6pZzp/P+k8YP9zBERGQQRRK92guM63a/2H0szFp7oNvdO4AfdHvtkiNe+59oBykio4Ax8PWvD/coRERERERERESOuasXKpgmIjLaRJKh9jow1Rgz0RjjB64GHu1+gDGmsNvdS4CN7u2ngHONMVnGmCzgXPcxERERERERERERERERkZjQb4aatbbDGHMzTiDMC9xprX3LGHMbsNJa+yjwaWPMJUAHUANc5762xhjzLZygHMBt1tqaY/BziIiIiIiIiIiIiIiIiBwTxlo73GM4TCAQsI2NjcM9DBERERERERERERERERlixpgma21guMdxpEhKPoqIiIiIiIiIiIiIiIjELQXUREREREREREREREREZFQwxmQbY5YZY7a6/83q5bjxxpinjTEbjTEbjDElfb2vAmoiIiIiIiIiIiIiIiIyWtwKLLfWTgWWu/d78ifgh9ba44CFQGVfb6qAmoiIiIiIiIiIiIiIiIwWlwL3uLfvAS478gBjzEzAZ61dBmCtbbDWNvX1pgqoiYiIiIiIiIiIiIiIyEjhM8as7PbnxihfX2CtLXdvVwAFPRwzDThojHnYGLPGGPNDY4y3z0FFOYhjrqmpyRpjmod7HDHGB3QM9yBERAZA85eIxDLNYSISyzSHiUis0vwlIrFMc1hkkq218/s6wBjzDDCmh6e+2v2OtdYaY2wPx/mA04BSYDfwAHAd8Mfe/p8jLqBmrVXWXJSMMSv7+3CJiIxEmr9EJJZpDhORWKY5TERileYvEYllmsMGj7X27N6eM8bsN8YUWmvLjTGF9NwbbQ/whrV2h/uafwKL6COgpuCViIiIiIiIiIiIiIiIjBaPAte6t68FHunhmNeBTGNMnnv/TGBDX2+qgJqIiIiIiIiIiIiIiIiMFt8HzjHGbAXOdu9jjJlvjLkDwFrbCdwCLDfGrAMM8Ie+3nTElXyUAbl9uAcgIjJAmr9EJJZpDhORWKY5TERileYvEYllmsOGgLX2AHBWD4+vBG7odn8ZMCfS9zXW9tSLTURERERERERERERERERAJR9FRERERERERERERERE+qSAmoiIiIiIiIiIiIiIiEgfFFCLYcaY840xm40x24wxtw73eEREjmSMGWeMec4Ys8EY85Yx5jPu49nGmGXGmK3uf7Pcx40x5hfuvLbWGDNveH8CEYl3xhivMWaNMeZf7v2JxpjX3HnqAWOM33080b2/zX2+ZDjHLSJijMk0xjxkjNlkjNlojDlZazARiQXGmM+554/rjTH3GWOStAYTkZHKGHOnMabSGLO+22NRr7mMMde6x281xlw7HD+L9E8BtRhljPECvwbeDcwE3meMmTm8oxIReYcO4AvW2pnAIuCT7lx1K7DcWjsVWO7eB2dOm+r+uRH47dAPWUTkMJ8BNna7/3/AT621U4Ba4CPu4x8Bat3Hf+oeJyIynH4OPGmtnQHMxZnLtAYTkRHNGFMEfBqYb62dBXiBq9EaTERGrruB8494LKo1lzEmG/gGcBKwEPhGKAgnI4sCarFrIbDNWrvDWtsG3A9cOsxjEhE5jLW23Fq72r1dj3MhpwhnvrrHPewe4DL39qXAn6zjVSDTGFM4xMMWEQHAGFMMXAjc4d43wJnAQ+4hR85foXntIeAs93gRkSFnjMkAFgN/BLDWtllrD6I1mIjEBh+QbIzxASlAOVqDicgIZa19Aag54uFo11znAcustTXW2lpgGe8M0skIoIBa7CoCyrrd3+M+JiIyIrmlN0qB14ACa225+1QFUODe1twmIiPJz4AvAUH3fg5w0Frb4d7vPkeF5y/3+UPu8SIiw2EiUAXc5ZatvcMYE0BrMBEZ4ay1e4EfAbtxAmmHgFVoDSYisSXaNZfWYjFCATURETnmjDGpwN+Bz1pr67o/Z621gB2WgYmI9MIYcxFQaa1dNdxjEREZAB8wD/ittbYUaKSr1BCgNZiIjExuibNLcTYGjAUCKEtDRGKY1lyjiwJqsWsvMK7b/WL3MRGREcUYk4ATTLvXWvuw+/D+UBkh97+V7uOa20RkpDgFuMQYswuntPaZOP2IMt3yQ3D4HBWev9znM4ADQzlgEZFu9gB7rLWvufcfwgmwaQ0mIiPd2cBOa22VtbYdeBhnXaY1mIjEkmjXXFqLxQgF1GLX68BUY8xEY4wfp0Hro8M8JhGRw7i16/8IbLTW/qTbU48C17q3rwUe6fb4h4xjEXCoW4q8iMiQsdb+j7W22FpbgrPOetZa+wHgOeA97mFHzl+hee097vHahSgiw8JaWwGUGWOmuw+dBWxAazARGfl2A4uMMSnu+WRo/tIaTERiSbRrrqeAc40xWW6m7rnuYzLCGH3HxC5jzAU4vT28wJ3W2u8M85BERA5jjDkVeBFYR1cPoq/g9FF7EBgPvA1caa2tcU+YfoVT0qMJuN5au3LIBy4i0o0xZglwi7X2ImPMJJyMtWxgDfBBa22rMSYJ+DNOr8ga4Gpr7Y7hGrOIiDHmBOAOwA/sAK7H2VSrNZiIjGjGmP8HXAV04Ky3bsDpJaQ1mIiMOMaY+4AlQC6wH/gG8E+iXHMZYz6Mc80M4DvW2ruG8ueQyCigJiIiIiIiIiIiIiIiItIHlXwUERERERERERERERER6YMCaiIiIiIiIiIiIiIiIiJ9UEBNREREREREREREREREpA8KqImIiIiIiIiIiIiIiIj0QQE1ERERERERERERERERkT4ooCYiIiIiIiIiIiIiIiLSBwXURERERERERERERERERPrw/wGhurHCtZCaVQAAAABJRU5ErkJggg==\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } + ], + "source": [ + "fig,ax = plt.subplots(figsize=(30,4))\n", + "ax.plot(X_test[0,:,0])\n", + "ax2=ax.twinx()\n", + "ax2.plot(np.arange(40),model.get_layer(\"conv2\").weights[0][:,:,2], \"r\")" ] }, { "cell_type": "code", - "source": [ - "model.get_layer(\"conv2\").weights[0][:,:,0].shape" - ], + "execution_count": null, + "id": "a2lKpEYu1LjZ", "metadata": { - "id": "a2lKpEYu1LjZ", - "outputId": "228b1416-b9f3-4eea-a557-70bc72714bf1", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "a2lKpEYu1LjZ", + "outputId": "228b1416-b9f3-4eea-a557-70bc72714bf1" }, - "id": "a2lKpEYu1LjZ", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "TensorShape([40, 1])" ] }, + "execution_count": 126, "metadata": {}, - "execution_count": 126 + "output_type": "execute_result" } + ], + "source": [ + "model.get_layer(\"conv2\").weights[0][:,:,0].shape" ] }, { "cell_type": "code", - "source": [], + "execution_count": null, + "id": "gl5foXzj5_EU", "metadata": { "id": "gl5foXzj5_EU" }, - "id": "gl5foXzj5_EU", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [] }, { "cell_type": "code", - "source": [ - "model.get_layer(\"conv2\").weights[0]" - ], + "execution_count": null, + "id": "qMRXBlrt5xPT", "metadata": { - "id": "qMRXBlrt5xPT", - "outputId": "243bf6e3-1385-469f-cbcc-1f9288b65410", "colab": { "base_uri": "https://localhost:8080/" - } + }, + "id": "qMRXBlrt5xPT", + "outputId": "243bf6e3-1385-469f-cbcc-1f9288b65410" }, - "id": "qMRXBlrt5xPT", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "TensorShape([40, 1, 3])" ] }, + "execution_count": 130, "metadata": {}, - "execution_count": 130 + "output_type": "execute_result" } + ], + "source": [ + "model.get_layer(\"conv2\").weights[0]" ] }, { "cell_type": "code", - "source": [ - "plt.plot(model.get_layer(\"conv2\").weights[0][:,:,2])" - ], + "execution_count": null, + "id": "XgROt0J-3SgG", "metadata": { - "id": "XgROt0J-3SgG", - "outputId": "fb48329b-e791-4039-bc71-a8e0e8ccabde", "colab": { "base_uri": "https://localhost:8080/", "height": 283 - } + }, + "id": "XgROt0J-3SgG", + "outputId": "fb48329b-e791-4039-bc71-a8e0e8ccabde" }, - "id": "XgROt0J-3SgG", - "execution_count": null, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "[]" ] }, + "execution_count": 132, "metadata": {}, - "execution_count": 132 + "output_type": "execute_result" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO29eZhbZ5Xn/z3aS1tVSVVSeS+Xq+zEcZzYOI6dDegEEpL8EiYNTUIPBGigN2hmaHoGmqYfGn6/6QYGeugfTE+n2aETCBAghKRDCAlLE9txnMRLHO9blWtRbVKptEvv/HHvq1KVpdJ2V+n9PI8fl6Rr3dcq6atzz3vO9xBjDAKBQCBofSx6L0AgEAgE2iAEXyAQCNoEIfgCgUDQJgjBFwgEgjZBCL5AIBC0CTa9F1CJnp4e1t/fr/cyBAKBwFS88MILk4yx3nKPGVbw+/v7sX//fr2XIRAIBKaCiM5VekykdAQCgaBNEIIvEAgEbYIQfIFAIGgThOALBAJBmyAEXyAQCNoEIfgCgUDQJgjBFwgEgjZBCL5AYGKOjsZwciKu9zIECvLDF4bx0L7zqjy3EHyBwMT8+YMH8Hc/PaL3MgQK8vD+C/jRgRFVnlsIvkBgUsZjKZyOzGM0mtJ7KQIFGYul0NfpUuW5heALBCZlz+kpAJLwC1oDxhjGokLwBQLBEvaemQYAzKVySGXzOq9GoASziSzSuQL6/ELwBQJBCXtPT8FC0s8TsbS+ixEowph8tSYifIFAUGRiLoVTkXnsGggWbwvMDxf8sIjwBQIBZ5+czrnrqpUAgIk5EeG3AmPyBvwKI0f4RHQbER0jopNE9NFljvt9ImJEtEOJ8woE7cqe01PwOKx4/WUhAMCE2LhtCcaiKRABvT6nKs/ftOATkRXAlwG8CcBmAPcR0eYyx/kAfAjA3mbPKRC0O3tPT2NHfwC9XidsFhIRfoswHkuhx+uE3apO8kWJZ90J4CRj7DRjLAPguwDuLnPcpwF8BoAIRQSCJpiMp3FiIo5rBwKwWAi9PqcQ/BZhNJpSLZ0DKCP4qwBcKLk9LN9XhIi2A1jDGPuZAucTCNoanr/nG7YhIfgtw3gspdqGLaDBpi0RWQB8AcBf1nDs+4loPxHtj0Qiai9NIDAle09Pwe2w4spVnQCAXp9L5PBbBDNE+CMA1pTcXi3fx/EB2ALgWSI6C2AXgEfLbdwyxh5gjO1gjO3o7S07dF0gaHv2nJ7Ga9Z1F/O8Ib8TERHhm55UNo9oMmv4CP95AENEtJ6IHADuBfAof5AxFmWM9TDG+hlj/QD2ALiLMbZfgXMLBG3F9HwGx8bniukcQErpTM1nkM0XdFyZoFl4SaZaXbaAAoLPGMsB+ACAJwEcBfAwY+wIEX2KiO5q9vkFAsECPH9/7fpA8b6QTxIIEeWbm1GVa/ABwKbEkzDGHgfw+JL7/rbCsa9T4pwCQTuy5/QUXHYLtq7uKt4Xkmu2J+bSWNnVodfSBE3CTfDCBs/hCwQCjdh7RsrfO2wLH92QXxZ8sXFrakbNkNIRCNSmUGB419f34ZlXJ/Reiq7MJjJ4dSyGa9cHF93PUzqiNNPcjMdS8Lls8DgVSbyURQi+wPDEUlk8eyyCn7ykzhQgs7DvzDQYw6INWwDo8TpAJATf7IxFU6pG94AQfIFMvsDwZ//2Aj77769iLpXVezmLmElI6zlwflbnlejL3jPTcNosuGpN56L7bVYLgh4HIsIx09SMqjjpiiMEXwAAmElk8PihMfzvZ0/h9f/zWTy49zxyBinzm01kAADnpxOYjLdvFLvn9BS2r+2G02a95LGQzyU88U3OuIjwBVoxK0fR779pAOt7PPjrHx3CHf/0W/z6uP4dz3xtAPBSm0b50WQWr4zGcO1AoOzjIb+wVzAzuXwBkXhaRPgCbYgmJVG9bkMQD//xbvzzH25HMpvHO7+2D+/6+j6cGJ/TbW0zcoQPAC9emNFtHXryvJy/X7phy5H8dERKx6xMxjPIF5gQfIE2RJOSqHa5HSAivOnKFXjqwzfh47dfjhfOzeC2L/4Gn/jxYV3SPDzCX93dgQPntI/wv/bbM7pvGO89MwWHzYJta7vKPh7yuYqiITAfxdGGIqUj0AIuql0d9uJ9TpsV77tpAL/6q9fjLdtX49t7zuG3Jyd1WFsGRMDrNvXi5eFZTUUtly/gC08dx3f3Xah+sIrsPTONq9d0wWW/NH8PSCmdfIFhej5T9nGBsRmLJgGoN9qQIwRfAGAhpdNZIvicgMeBv7hlCMBCc4iWzCSy6OywY8e6ABKZPI5rmF46cjGGeDq3KK2kNbFUFodHopeUY5bCu23HRfOVKVF7tCFHCL4AwEKE7y8j+IAkKEQLb0wtmU1m0e12FNMZL2q4cbvn9BQAYErHyPmFszMoMGDX+vIbtoBkkQwIPx2zMhZLw2G1IOBxqHoeIfgCAFKE73fZYLVQ2cftVguCHqcuEeRsIoPODjvWBtwIeBw4cF67jVsu+DPzGTCmT358z+kp2K2EbWu7Kx6z4KcjInwzMhZNIuR3gqj8508phOALAEiC3+kuH91zwn59BH8mkUG32w4iwrY1XXhRI8HP5Qt4/uwMHFYLcgWGWDKnyXmXskfO33c4yufvgYWh16IW35yMxdQdfMIRgi8AIEXRXR3LX072+V0Y00FQZhNSSgcAtq/rxqnIPKIJ9buBD8v5+xuHegAA0zrk8ePpHA6PRCuWY3Jcdis6O+yiFt+kjMfSqm/YAkLwBTLRZLbshm0p4U6XTimdhauPbWukPP5Lw+rn8Xk6501XrgAATM9rL6b7z04jX2DLbthyRC2+OWGMYTSaFBG+QDtma0np+FyYns8gnctrtCogkysgns4VI/yta7pgIeDAudrTOpPxNB7ce77uHPye01MYDHmxMewFAEzFtY/wnz87DZuFsH1d+fr7UsJ+V10RfiyVxTu+uhdHLkabWaIh+clLI3jbvzxXtOUwMrFkDqlsQUT4Au2IJrKLavDL0depfZ6Yl4t2y19GXqcNG8M+vHih9gj/S788ib/+0aG6Nntz+QKePzONXQOBYuWEHjXuo7OSoZbbUd0yN+Rz1vW7OXBuBr85MYmPPXKo5Rq2fndyCnvPTON939qPVFa7AKURRmNSDb7aXbaAEHwBpEvKmlI6cgSiZVqHR2id7oX9hW1ru/HS+RkUahCpbL6AR1++CAD46cujNZ/38MUY5jN57BoIIuiRvuj0yOHX8nvh9MrDzGu9kjk5EQcAHByO4qF95xteoxGZjKfhddrw/NkZ/OXDL9f0XtELrWrwASH4AgDzmTxyBYauqlU6XPC1i/C5NXJ3ydq2re1CLJXD6cn5qv/+2WMRTM9n0Otz4meHRmuOZJ87JeXvdw0E0eGwosNuxbQOKZ16BD/kcyGTLxSviqpxciKOgMeBXQMBfO7JY5hqISfSSDyN16zrxl/ffhl+dmgU/+Pxo3ovqSLF0YYipSPQAh5F11KlAyz4fmgBX1t3SYS/XW7AqiVF88iBYQQ9Dnz89ssRmUsXh4BXY8/pKQyFvOjxStF9wOPQJaUzW5fgL8y2rYUTE3EMhrz41N1bMJ/O4bP/fqzhdRqNybk0en1OvO/GAbzrun585bdn8NXfntF7WWXh3et8cpmaCMEXFCPCSl22nC63HQ6bReOUzqWWDwM9Xvhdtqodt7OJDJ4+OoG7r16FN14RRofdiscOXqx6zmy+gP1npxdVxgQ8Dl26beuL8GvfY2GM4eREHEMhLzaGfXjPDevxvf0XNG1qUwvGGCLxNHq8UiPTJ+7cjFuvCOP//dkreOJQ7Wk9rRiPpdDjdS6aU6wWQvAFxZr2aikdItK8+Yp72HSXtJxbLISr13ZXbcD66cFRZPIF3LN9FdwOG26+PIQnDo9Vdfw8PBIt5u85AY9DFz+dugS/jj2WSDyNaDKLoZBUgfQXNw+hz+/CJ3582PQbuNFkFtk8KzajWS2EL967DdvWdOFD33sJ+8/WdpWnFaPRVLEgQm2E4AuWNU5bSp/fpamfzmwyC7uV4FnSZbptTReOj88hnq7c/frDF4ZxWZ8PV6z0AwDu3LoS0/MZ/E7Oz1diz2lJEEqHjQQ9Ds3LMlPZPDK5QtUrL049KR2+YTsY8gGQqp/+5s7LceRiDA/uPdfgio0Bn4rGBR+QGtO+cv81WN3Vgfd+a3/x/28EpFm2HZqcSwi+ALPJ2iJ8QNpY0rpKp7PDcYnHyLa1XSgw4GCF8sxTkTheujCLe7avKv7b123qhddpq5rWee70FDaGF/L3gD45/Hq+iAHA47TB47DW1HzFBW9I7jEAgDuuXIHrB4P43JPHTD1Kkn/h9XgX70kFPA584907YbMQ3vX1fYZpUhuPiQhfoCELXvjVnfokwa+99K9ZZuaziyp0ONvWSEZilerxHzkwDAsBb756VfE+l92KN24O498PjyGTK5/WKZe/B6SUUjKbRzKjXU13vYIPSGmdWiL8E+Nx+Jy24lUBIKXs/u6uLUhm8/jME6/Wv2CDMClfiZX+3zhrg2589f5rMBXP4BM/Pqz10i4hlc1jJpFVffAJRwi+ANFkFg6rBS579bdDn9+FZDaPWEobI7HZZGZRhQ6n023Hhl5P2Tx+ocDwowMjuHGot5jX5tx51QrEUjn85kT5Wb2HRqJILMnfA1JKBwCmNLRXaETwe31ORGrYtD05Ecdg2HvJldNgyIs/umEA339hGC+cM1auu1YixQi/fNR81ZouvGlLHw4N699hzK+W+zpFSkegEdFkBp2yG2U1wp3aNl+V+ugsZdvabrx4fvaSq409p6dwMZrC779m9SX/5obBXnR22PHYwfLVGtw/Z+cS73nebTszr75pGydapkKpGrX66ZyQK3TK8Rc3D2Jlpwt/8+Mjuoy0bJbJeBp2Ky37uvX3eHAxmtK9C5fvh4kIX6AZszXYKnDCGk9W4tbI5di+thtT8xmcn04suv+HB0bgc9rwxs3hS/6Nw2bBbVf04edHxsp+2Pecnr4kfw8AQa9+EX4teyucWvx0ZhMZTMbTGKwg+G6HDZ+4czOOjsbwnT3m28CNzC2UZFZiXdANADg3lah4jBYUZ9mKHL5AK+op/eN+H1pV6pRaIy+l3ASs+XQOTxwexR1bV1Sc/3rnVSswn8nj2WMTi+7n+fvdZZwp+Rq03LhtKIfvcyKRyS9bvVTcsJUrdMpx25Y+3DjUg8///DhiKe2uapRgMp5eVKFTjvU9HgDAmRq6tdWkGOGLlI5AK2YT2ZqjSC39dJKZPNK5QsWUzsawD26HdVEe/8kjY0hk8rhn+6XpHM7ugSCCHgd+uiStc3C4fP4ewIKfjg6C73PVs2nLm68q/34WSjLLR/iAtIH73hsHMJfO4chIrObzGwEe4S/HuqAk+Oem9BX80WgKXqcNXmd1czwlEIJfJ798dRw/fGFY72UoSjSZrbnWmw/a0MJPZ6aMrUIpVgvhqtVdiyp1fnhgGGsDblzTX3kcoM1qwZuu7MMvj04gkVmIhCvl7wHA32GDzUKaC75vmbGT5eDt+culdU5MxOGyW7Cqa/mo8vI+6Qrg2Ji5BH8ynkZvFcHv7LAj4HHgrM6CL5VkapO/BxQSfCK6jYiOEdFJIvpomcc/TESvENFBInqaiNYpcV6tOTY2hz/9zgF88lFzbmZVIprM1lSSyZEmX6kf4c+WMU5byvZ1XXjlYgypbB4XZ5P43ampRbX3lbhz60oks3n84uhCWmfP6SlsCvsQLCMWRIRujWvx60m1cWppvjoxEceGXi8sVb5Ien1OdLvtODY+V9ca9KRQYJiMZ9Djq/5+7g+69U/pxFKabdgCCgg+EVkBfBnAmwBsBnAfEW1ectiLAHYwxrYC+AGAzzZ7Xq1JZHL48wcPIJsvSJe5F80V9VQim5cGjNS1MajR5KuiNfIyX0bb1nQjV2A4NBLFj14cAWPAPdsqp3M41/QHEPI58ZhsnSzl72ewa+DS6J4TcGvrp9OY4MsR/jK/n1PLVOiUQkTYGPbh1THzCP5sMot8gVWN8AGpUufspM6bttGUJi6ZHCUi/J0ATjLGTjPGMgC+C+Du0gMYY88wxvgruwdA9U9kg6RzeTx/dhqj0aSiz/u3PzmCU5E4/vFtVwOQujFbgVgDG4NhnzZ+OkVrZE/ltV3NnTPPzeCRA8PY2R/AWrkCYzmsFsIdW1fg2eMRxFJZHByeRTKbx+4NlUcJat1t24jg+ztscNgsFSP8+XQOI7NJDIUrb9iWclmfD8fH5gztJ19KsQa/yqYtAKwPejAWS2naTFdKvsAwMZfWxAefo4TgrwJwoeT2sHxfJf4IwBPlHiCi9xPRfiLaH4mUb4ypRjSRxVv/z3N48vBYQ/++HD98YRg/eGEYH/y9Idx99SoMhrxV/VjMQj22Cpy+Thcic2nV01qzyeVz+IDUXLM24MZD+87jVGQe92xf7q23mDu3rkQmV8BTR8aL/jk7lxkWHvA6MGNwwSciefJV+S/kUxFpw3ZDb/UIHwA29fkxn8ljZFbZAEotij46NUT46+RKnXPT+qR1puJp5Aus2NuiBZpu2hLRfwawA8Dnyj3OGHuAMbaDMbajt7e3oXP0+pzo7LDjhELmSCcn4vjETw7j2vUBfOjmIQDAdRuC2H92GtkWyOOXsx+uRtjvQoEttLCrRa1r2762C2enEnDaLLh964qan3/72i6s6urAYwcvYs/pKVzW5ys2WJUjqLFFciOCD/Dmq/IR/onxSz10lmNTcePWHGmdeiN8ADirUx5/VOOmK0AZwR8BsKbk9mr5vkUQ0S0APg7gLsaYaiUeRIShkLf4xm6GVDaPDzx4AC67FV+8d1uxWmL3QBCJTB4Hh2ufq2pUGkrpaFSaOTOfQYfdWrGenrNtrVSR88Yr+uCvo4SRiHDn1hX4zYlJPF/GP2cp3W6HbL2rzRd944JfufnqxEQcdithXaB62gtAcYC7WTZuyzllVqK/R3oNzurUfMULH8yW0nkewBARrSciB4B7ATxaegARbQPwL5DEfqLMcyjKUNiL4xNzTRt8ffqxV/Dq2By+8AdXLSqdulYWht+dNH9ah6dNupZJmyxFq8lXM4nyxmlLuX4wCIfVgrfvXFv3Oe7cuhK5AkMqW6gq+LzbVgtf/HqtkUsJ+SundE5OxLG+xwObtbaPvs9lx6quDtNs3Ebm0nDYLPDVUNfuc9nR43XoFuHzpitTbdoyxnIAPgDgSQBHATzMGDtCRJ8iorvkwz4HwAvg+0T0EhE9WuHpFGEo5MNsItvU5fdjBy/i3/aex5+8dgNetym06LGAx4HLV/hbYuO2OPykngi/Uxt7Bcnjp/oX0WDIh4OffOOyG66V2LLKX2yzv7ZM/X0pWvrpNNJlywn7XYilcmWtI05OzC3bYVsOvnFrBiJyDX4tvlCA1IClV2nmWCwFu5WKxnxaoEh7F2PscQCPL7nvb0t+vkWJ89QKz08eH5+r2nFXjnNT8/jYDw9h+9ou/OUbN5Y9ZvdAEN/Zew6pbL5qysHI8E3beiLJoMcJq4XUT+nUGOEDaPh3QET489cP4sXzs4umapUjsMgxsz7RrJdGfHQ4PJ0RmUtjTUnqJpXN4/x0AnddXfvGNiDl8X91PIJMrqDJGL5miMyla8rfc/qDHvz2ZGMFIs0yHk0h5HNV7YdQEmP/9hqERzCNTLVJ5/L4wIMvwmIh/NN922CvcOl73YYgMrlC1bmqRmc2UX83p9UiVYKMRdXttpWM09SPfv5gxxr8/T1XVj2OC74WpZnNRPgLzVeLv5DPTM6jwFBTDX4pm/p8yBUYTk8aZ0pUJSJz1btsS1nf48Z4LL2o41orpNGG2qVzgBYV/LDfCZ/L1tDG7YN7z+PQSBSffctWrO6uvLG1cyAAC5m/Hj/W4MagFpOvostYI+uBpoLfQPUUZ6H5avEXci0eOuUwU6XOZDyD3hq6bDn9vDRTh41brW0VgBYVfF6pc7yByoL952awursDt17Rt+xxfpcdW1Z14rlTk40u0xDMJms3Tisl7HequmnLGMNssvaUjhZo6Zg520yE7y9vr3BiIg4LLThF1spAjxc2Cxl+4zZfYJiery/C79epNJMxJkX4Gm7YAi0q+ICU1mkkpXNkJIotKztrOnb3hiBeujCrW6eeEswmMnX56HD6VI7wY6kc8gWmSUqnVuxWCzo77IZP6QTcDtgsdElK5+TEHNYFPXXvdzhsFmzo9Rp+43Z6PoMCq60Gn8Mj/DMam6jFUjkks3kh+EoxFPZiaj6DqTqGMcdSWZydSmDLKn9Nx+8eCCKbZ9hv0lFwQOO13uFOF+ZSOdVyn82kNNQkoFHzVSPWyByLhdDjdV7iaHpSNk1rhI19xvfU4U1X9UT4XqcNPV4nzmnsqbMw2lAIviJwr5B6Om5fkQ3RrlhVW4R/TX8ANguZ2mYhmmwsTx72qTsIpZo1sl4EPA5Mq9xhDEh7K/VuppcS8i/uts3lCzgzOV9zh+1SLuvzYWQ2iTkDD0PhTVf1RPiAtHGrdYRf7LIVgq8MvBKhHsHnDpi1pnQ8ThuuWtOF50wq+Iwx2Rq5fsHvK862VadSpyj4yxin6UHA49Ck8arRKy/OUj+dc9MJZPMMgw1G+JvkAKqRfTGtaCTCB6RafK1z+OM62CoALSz4Kzpd8DptOFnHG/TISBRhv7OmtmzO7oEgDo1EDR35VCKRySObZw1X6QDqNV8t5LCNFeFr5afTrOD3+lxFAQTq99BZykKljnFLMxuP8D2YmNO2NJMXPGjZZQu0sOATEQZDXhyvozTz8MUorqgxuudctyGIfIHh+bPmy+M34pTJCcuVIGpV6nBXSiNV6QBAt0dyzGzWtqMaSkT4U/OZou/PyQkp8Gk0h7+6uwMeh9XQ068ic2l02K3wOOrblF6o1NEujz8aTSHocWjeyNaygg9IaZ1aUzrJTB4nJ+LYsrK2DVvO9nXdcFgtpkzrNLMx6nPZ4XFYVYvwZwy6aRv0OJArMMSS6kaDTQu+/IXMo96TE3Gs6uqAp8HZqURk+I3byXgaPT5HzbYKnAUTNe3SOnrU4AMtLvgbwz5MxtM1eZgfHYuhwGrfsOW47FZsW9tlyo1bbpzWaNpEzclXfJ5rrSZfWlFsvlI5jx9tsD+CE17SfHViIl53w9VSLuvz4dh486aEahGpYZZtOfhAcy09dfSowQdaXPAHw7Vv3B4ZiQIAttQp+ABw3YYevDIaK47kMwtF47QGhSXsc6lapWO0Ch2gtNtWXVuJegbLl6O0+apQYDgVaV7wN4UlU8LIMvNy9WRyLtOQd5bXaUOvz4lzGkf4Wg4+4bS04C9U6lS/DD08EkO3246VDfwSdm8IgjFg7xlz5fGbae4BpEod9ap0jNVlyykaqKlYmsmtkZvL4csR/lwKI7NJpLKFuj10lrKpT0p3GjWtE4mn6yq4KGV9ULv5tqlsHtPzGawQEb6yrOzsgNthrclT58hoFFtWddad/wOAq9Z0wmU3Xx6/mU1bQKowmJhLqTLvNJqozRpZa7Tw02lkCtlSerwOEEkpnUY9dJZiZE+dbL6AmURjET4g5fG1qsXnaTYR4SuMxSJ56lSzWMjkCjg2Nld3hQ7HabPimv6A6QQ/mszCYbWgo0Fr4bDfiWyeqZLPNmqEH/RIgqJmaWazV14AYLNaEPQ4MDGXLl7hNiv4AY8DvT6nISP86fkMGKtt0lU51gU9iMylEU+rX5qpx6QrTksLPiANx6jWLHJ8fA7ZPMMVdVbolLJrIIhj43PFqggzMJuQ8sSNXNUAC00jamzcGjWH3+GwosNuVXWYuRKCD0i1+BOxFE6Mx9Hrc9Y11awS0sat8Uozi01XjaZ0iq6Z6kf5XPDFpq0KDIW9mJhLFzcoy3HkYuMbtpzr5GlLe0xklxxNZpqrBOlUR/Bz+QLmUjnDlWRyAh6HqikdpQSfDzM/GYk33GG7lE1hH06Mx5FXIY3XDBHedNVoSkfDWvyxaBKASOmoAh/CfDJSOco/PBKD12mrebBzOa5c1Qmv02aqtE6ztd68S1DpQShc8IyY0gHUN1BTVvBTODkeb7jDdikb+3xI5wqaVrTUwqQc4YcaTuloV4s/EZMaxGqZu6s0LS/4fPrVch23hy9GsXmlv6lRYzarBdf0d5tK8GcTjfnocEI+J4iUj/B501W1kYN6YZoI3y85Zs6lc03n7zmXGXTjttkI3+O0IeRzauKp02iDmBK0vOCv6upAh71ypU6+wHB0NFazYdpyXLehB6cn51WfBKUUjTplcuxWC4Iep+L/32ixIcyYEX5QI8FvxBq5FF6aCTS/YcsZCvlAZLzSzMm5DLxOGzrqtFUopb/Ho0mEPzWfKW7+a03LC77FInnqVKrFPx2JI5Ut1OyBvxy75Ty+WaL8aKK5lA6gzuSrmXme0mnPCL9Za2ROaXpDKcHvcFjRH/QYzjUzEk+jx9vc+2V90IMzGuTwJ+ONl482S8sLPiB76lSI8A8rsGHLuXyFH36XzRQNWLl8AXPpXEPTrkqRJl8pm8M3qhc+p9vjQDKbV23SWbO2CpyQvMfS2WFvyHKgEhvDXuOldOZSDVfocNb1uDEZT6vufDupwJdTo7SF4A+GvRiLpRAr84s8PBKD02bBQJ1zPsthtRDW93gwPKP9QOR6iaWkeuNmhUUNP51iDtugm7ZB3m2rkr1Cs5vpHB7hD4W8iuaLN/X5cXZqHqmscUZ7KhE1rw+qP9C8UGCYnhcRvqpslDduyzVgHR6J4vIVfsVMukJ+l2G9Rkrhvj9Np3R8LkzPZ5DOKffhn0lkYLUQ/C7tqxhqgXfb8tST0igl+DziVSqdw7msz4cCQ00d7FoRmWvcVoHD59uqmcefTWaRLzAERYSvHrwk7cSSvGOhwPDKxZgi+XtOyKf8JqYazCoURfd1yiZdCqZ1ZuTqIT2qGGqBf1jVivBnExlFBN9lt+K/3rIR9+5cq8CqFihaLBgkj5/O5RFNZpuOmoulmSpW6vAZ20GdInxjhlAKs7rbDafNcklEcn46gbl0TpEKHU7Y78JMIot0Lg+nrfGKAbVRqvSvdPLVmib6GEqJJpqrHlIbvreg1sZtNKlc09mHbghY2IoAACAASURBVBlS5HlKWRdww2GzGGYYCjeyazbCdztsCPudqm7cTsprFTl8FbEWK3UWC35xhq0CG7Ycnjc1elqnaI2skOArWaljVFsFDi+pU0PwGWOINWmNrDY2qwVDIa9hSjMnm6zBL6U/6FG1qUzJtTZCWwg+wCt1Fr9BD1+Mwm4lxboQgdKI1+CCX3TKbL5KB1D2/2tU4zSOv8MGm4VUEfxUtoBMvjlrZC3Y1OczTKVOsz46paxXuRa/mNLRqamwfQQ/7MPFaGpRydXhkSg2hn2Kpl744InInLHz+NyCt9mN0S63HQ6bRdF9i2giY7jh5aUQEbpVqsVXKtWmNpf1+TAxV9s0ObVZiJqbf8/093gwGc+oVpo5NZ+BhfQrOW4fwZcrFU5FpG9vxhiOXIw15ZBZDt7daPQIfzaZgc/Z/AhBIpKarxScfGX0CB8AAm51/HTMIvh8GIoRNm55hK9MSodv3KqTx5+MpxHwOJuycWkGRQSfiG4jomNEdJKIPlrmcScRfU9+fC8R9Stx3noYCkuVBTytMxpNYXo+o2j+HpAu1awWMnylTrO2CqVIzVfK/H9T2TyS2bxhfXQ4anXbmkbww8bx1JmMZ+Bz2eBqcK5DKWqXZkr9Avq9t5sWfCKyAvgygDcB2AzgPiLavOSwPwIwwxgbBPCPAD7T7HnrZU13Bxw2S3Hj9rA8w7bRoSeVsFioaEtrZJSwVeCEFRR8swhewOtQJZ1hlv9/2O9EZ4fdEBu3StTgc9YFuE2yWoKf1m3DFlAmwt8J4CRj7DRjLAPguwDuXnLM3QC+Kf/8AwA3k8ZF1jar1E3LI/wjF2OwEHD5Cp/i5zJDLf6sQu37gCT4Y7EUGGveI93otgqcoEoWycXNdAPvYQBSKk/auNW/NDOioIh2OKxY0elSbdzhVDyjW9MVoIzgrwJwoeT2sHxf2WMYYzkAUQDBpU9ERO8nov1EtD8SiSiwtMVsDPuKEf6Ri1Fs6PXC7VC+FSHkdynaiKQG0WRWMVHp87uQyhaKdg3NsGCcZuwIt9vtQDSZRTZfUPR5zRLhA5KnTrXxoVowqWCED0gNWGrZK0y1QISvGIyxBxhjOxhjO3p7exV//qGQF8MzScynczg8ElM8f88J+6XBE0aGjzdUAiUnXxWtkQ0u+DxKm1F4nm80mQUR4DOorUQpK7s6EEvlkMioPwd2OSLxtKLmcOt7PKqkdJKZPOYzedNH+CMA1pTcXi3fV/YYIrIB6ASguYcwr7ffe2YKY7GU4hU6nJBvodvWiPDmHsVSOnJ0pUSlTnH4icFTOmr56UQTUvWUXlUc9RA2QEVaKpvHXCqnaITfH/Rgaj5T1myxGYrlozp54QPKCP7zAIaIaD0ROQDcC+DRJcc8CuB++ee3APglUyLhWye8UufHL14EoPyGLSfsV95fRkmS2byizT19Ckb4ZsnhB1RyzFSyekptwioOsa8VJWvwOcVKHYWjfL7n0+MzcYQv5+Q/AOBJAEcBPMwYO0JEnyKiu+TDvgogSEQnAXwYwCWlm1qwLuCG3Ur4+StjAIDNakX48gfBqJU6swrZKnCU/OBHE1k4bBa47IbKNl4CF3ylSzOVcsrUAh7Y6Cn4SnbZcooDzRXO4/O5u3pNuwIUMk9jjD0O4PEl9/1tyc8pAG9V4lzNIFXqeHFsfA7rgm7VPljcT2fCoJU6C7YKyvz/XXYrOjvsivjpSD46xnXK5AjBX9i70fNKdsGMTNlNW0CNCJ87ZZo4wjcbPI+vpEPmUoxwqbscRVsFBYVFqclXUpetsdM5gHqOmWYSfJ/Thg67teUifJfdilVdHTgdUbYCSY0vp3ppP8GXh6FcoaAH/lICbgdsFjJsSodXwihZ663U5CslG8LUxG61oLPDroLgK2eNrDbcVmNcx/f5ZFydNMmGkBcnFRf8NLxOZTqCG6XtBH9TnxThX6lSSSYgddv2+pyG9dNROqUDSJU6ylTpGNsauZSAws1XZrBGXkrI78K4gj5K9RKZSxcN/JRksNeLUxPzKBSUqy3Ru+kKaEPBv+XyMP7pvm24fkOPqucJ+V2GrcXnKR0lI8m+Thcm42nkmmxEmklk0e0xh+AFPA5Mx5UTfLNYI5cS9rswruP7PDKnTiPTYMiLZDaPi9GkYs+pt60C0IaCb7NacNdVK1Wvcw75nIYty4wms7BbCW6HgrbQPicKrLmcNmMM0aSxrZFLCXgcijZemanLlhOWbUR0qLIGIImokk1XHD4HWMlO4ql4RjcffE7bCb5WSLlNg0b48sagkpUwAT4FqgkBnM/kkc0zw9sqcJT20zGLj04pfZ3K2Wo0QiSeRo+CG7YcVQR/Xp211oMQfJUI+1yYTWSRyhqv21aNjVGehmkmwufuk2bJ4Xd7JMdMpaJbM0b4xZ4TnSp1JufUifADHgcCHgdOKbRxmy8wTM9n0CMi/NZkYfKV8dI60WS26dGGS1HCaqAoeCaK8HMFhlhSmeh2Vr46MpPgc1sNPQoUEpkc5jN5RUsySxnsVc4cbiaRQYEBQZHDb00Wum2Nl9aZTWYUF5UAr0tvIqVjFlsFjtL2CmaM8NUYYl8rk3O8rl2d98uGkHKCP2WAGnxACL5qcGMpI27cziayitkqcPgVQzNDQRaM08wheMWrGoU2bs0o+KEm7BXi6VxTVV2RuHRO1SL8kBcziWxx8HgzFPsFRFlma9LMB0Ft1DDoctgs8LlsTeXwiykNkwn+lEKlmTETWSNz3A4bfC5b3Tl8xhje8IVf4UvPnGz43JE5daNmJTdu1TB5awQh+CrBu2317EIsR77AMJdSp5uz2TmvC6Zu5krpKNVtG01mTWONXEq4AVuN6fkMRqMpPH10ouHzRmQRDakY4QNQpOPWCLYKgBB81SjOtjVYSieWVNYps5Rud3N16TOJDLxOm+Jdk2rB2/mVKs00kzVyKX0NNF9dmJEamo5cjBZTWfUyOZcG0cIXr9Ks7HTB7bAqEuFPxdOwWQh+l76/X3N8skxKrwG7bWdVrIRRIsI3U/66w2FFh92q2DBzMxmnlRLy1x/YnJ+WrIcLDHj+zHRD543E09KVtFUdGSMibFCoUmcqnkHA49D96k0IvoqEDTjMnOfJ1UibNC/4GdPYKnCa/T+XYlbBl1I6qbp8Zy7Igu+wWvDc6caG302qZKtQymDIi1MK5fD1TucAQvBVJex3Gc4xU81ady5+jTYimcUauRQlDdRMK/g+J3IFVldJ7vBMAkGPA69Z143nTjUm+JG4ssPLyzEY8uJiNIX5dHO9FpPz+hunAULwVSXkcxqu21bN0r9utwPpXAHJBv+/swnl+wPURtkIP2caH6FSGpn/cGE6idUBN3ZvCOLoWKx45VkPUtSs7uu1oVfauG2243ZKJc+fehGCryL8g2CkblulxxuWEmjSXmE2ab4IP6iQ4HNrZLN94QGl9gq1v88vzCSwVhZ8xoC9debxGWOIzGkT4QPNlWYyxjAZT4sIv9XhtfhG2rhVM8IvGqg1IID5AkM0mTVN0xVHqQjfjNbInHqH2OcLDCMzSazp7sDW1Z1w2S11p3XmM3mksgXV8+Lrgm7YLNSU4CfkteptqwAIwVeVkI9/EIwV4XudNlUqG5qJ8GPJLBgDOk0W4Xd7HEhm80hmmkvbzSbN56PD4amKWt/no9EkcgWGNQE3nDYrdqwLYE+dG7dqjDYsh91qwbqguynBX2i6EoLf0oQV7rb91fEI3vHVvU1tIKm5McjTMY3U4vNyUbNF+EGF/HTMaKvAcdgsCHocNdfiX5iWavDXdEvDwndvCOLVsbm6LAy0FNHBJscd8qYrkdJpcboVnG3LGMPfP34Uvzkx2VQ7elQF4zTOQudp/Y00ZjNO4yjhEgpIltWAOQUfqG/U4YUZqSRzTaADALBrIAigvjz+xVnpS0MrwT83lUAm15jvD/8i61F47m4jCMFXEd5tq0SE/8yxCbw6Noe1ATe+8pvTODM539DzzCayis6yLcXvssNqoYYakczmo8PhUVs7R/hAfQN/hqcTsBCwsksS/K2rO+F2WOtK6zx2cBQ9XieGwt6G1lsPgyEv8gWGc1ONfeaKtgo+/YMZIfgqE/K7mrZXYIzhy8+cwqquDnz3/bvgtFnxqZ8eaei5JC98dUTFYiF0u+0N1aXPFp0y9f9Q1ANfb7Mbt6YXfF/tfjoXZpJY0dkBu7yPZLdasKM/UPPG7Vg0hV++OoG37lhdfA41Gez1AWi8UodH+GpZQNSDEHyVCfmcTVfp7DszjRfOzeCPXzuAlV0d+NDNQ3jmWARPHx2v+7lmVS7963Y7GorwzWaNzAk2UZlUiukFv44h9hemE1jd3bHovt0DQZyYiNdUwvz9/ReQLzDce82ahtdbDxtCHgBNCP58Bj6XDU6bcjOkG0UIvso04iS4lP/97Cn0eB34gx3SG/z+6/qxodeDTz32Sl1NXdKQ8KyqzT3dHkdDQ1BmExnZGthcgufvsCHkc+IHLww31WBnRmvkUsJ+JxhbSF8sB6/BL2X3BimPXy2tUygwfPf5C7h+MIh1QU/jC64Dt8OGVV0dDW/cRgzSdAUIwVedsN+JaLLxbtvDI1H86ngE775+PVx2KUJw2Cz45F1X4NxUAl/97ZmanyuVLSCTK6iW0gGkqpXGcvjSlYfVZNbARITPvGUrXh2bw/94/GjDz2NWa2RO2FdbLX4qm8d4LI01SwR/y0o/vE5bVV+d35ycxMhsEvftXNvcguukmelXUwZpugKE4KsOr8VvtNv2n589BZ/ThnfsXrfo/huHenHrFWF86ZcnixUL1dCi1ru7wUakmUTGdPl7zus3hfDeG9bjW8+dw5NHxhp6DjXmDGtJraMOh2VbZF6hw7FZLbimv7tqhP/Q3vMIeBx4w+ZwE6utn8FeL05F4nUZxHGm4hlD1OADQvBVp5nJV6cjcTx+eBTv2L2urI/239yxGQXG8PdPvFrT80VV9MLnBGRP/Ho/GGazRl7KX922CVtW+fHffnCw5i/gUsxqnMbhPSfVJl8VSzK73Zc8tntDEKcj8xU/KxNzKfzi6Dje8prVmufDB0NepLIFjDTwuzWKrQIgBF91Foyl6o/w/+VXp+GwWvCeG9aXfXxNwI0/ee0G/PTlizWVtPFKGDVLH7s9DhQYEEvVV5cuRfjmFTynzYr//77tyOYL+C/fewn5Or/wzC74Qa8TVgtVfZ8PT/Ma/DKCP9ADoHIe/wcvDCOn4WZtKY1Ov8rlC5hJZIub+3ojBF9l+Pi1eit1RqNJPPLiMN52zZplLwf/9HUbsKqrA5989EjVColZDZp7gg2O/dPCCEtt1vd48Om7t2DfmWl86Zf1NcepXT2lNlYLoddbvefkwkwSDpul7Cbm5pV++Fy2suWZhQLDd/ddwLXrAxjoVb/2filc8Ov1xuefgx6DvLebEnwiChDRU0R0Qv67u8wxVxPRc0R0hIgOEtHbmjmn2eh2O2C3Vo98lvKvvz4DxoD33zSw7HEuuxWfuPNyvDo2h3/be37ZY4vjDVXMFXc3IPjZfAGReBp98tWQmbln+yq8+eqV+OLTx/H82do7R2PJLPwmFnyAN18t/z7nJZnlNqetFsK168v76jx3egrnpxN4+7XabtZyAh4HAh5H3Ru3xaYrA9TgA81H+B8F8DRjbAjA0/LtpSQAvJMxdgWA2wD8LyLqavK8pkHqtq1v1OH0fAYP7TuPu65eidVlcp1LufWKPlw/GMTnf35sWT8SLTZtAw00IkXm0mBMquU2O0SET795C9YE3PjQQy8WLROWY6Fc1tyCLzUZVs/hLy3JLGXXQBBnpxIYjS7OlT+47zy63HbcekWfImtthMEGxh3yDmwjOGUCzQv+3QC+Kf/8TQBvXnoAY+w4Y+yE/PNFABMAeps8r6norXOY+Tf+4wyS2Tz+9LUbajqeiPDJ/+cKJDJ5fOInhyvmz6PJLGwWgseh3oYXH1FYj4Ear+xY0QKCD0i9BP907zZMzKXx0UcOVp0Alszmkc0z0wt+2O+sWqVzfipRdsOWw+vxS9M6U/E0fn5kDPdsW10sTdaDDbKJWj0T3RZM3lojwg8zxkbln8cALFsrRUQ7ATgAnKrw+PuJaD8R7Y9EIk0uzTiE/bX76cTTOXzjd2fxxs1hDIV9NZ9jKOzDh24ewuOHxnDTZ5/Bv/zq1CWWvdxHh0i9Wu9GDNS46Va4BVI6nKvWdOGvbt2EJw6P4cF9y6fazN5lywn7XMtOeIsms4ilcpeUZJZyeZ8fXW77IsH/4YFhZPMM9+3UfrO2lMGQF7OJbF3WIVNFp0yTRPhE9AsiOlzmz92lxzHpa6/iVx8RrQDwbQDvZoyV3V1kjD3AGNvBGNvR29s6FwH1zLZ9cO85xFI5/NnrB+s+zwdvHsJjH7wBV6/pwt8/8Spe+7ln8O0954ouf7Ma5IndDhtcdgum6zATG43yCL+yEJiR9904gBuHevCpn76yrNldywh+lQlvfHD5chG+Rc7j8wYsxhge2ncB1/R31xUAqUEj068m4xk4rBb4DdJBXVXwGWO3MMa2lPnzEwDjspBzQZ8o9xxE5AfwMwAfZ4ztUfI/YAZCvtq6bVPZPP71N2dw/WAQV69pbJtjy6pOfOPdO/HwH+/GuqAbn/jxYdzyhV/hRy8OY2Y+o2oNPifgdtQX4cdScNgspi7LLIfFQvj8W68CADzw69MVjzO7NTInXGXy1fBM5ZLMUnYNBDE8k8SF6QT2nJ7Gmcl53HuNPpu1pTQm+FINvppX1fXQbErnUQD3yz/fD+AnSw8gIgeAHwH4FmPsB02ez5TUOvPz56+MIzKXxp/UmLtfjp3rA3j4j3fj6+++Bl6nDf/1ey/jd6emNOnm7PY46s7hh/1Ow3wolCTkd+Ge7avwyIHhihvZrRPhLz/5aungk0qU+up89/nz8LtsuGPrCgVX2hgrO11wO6x1Cb6RbBWA5gX/HwC8gYhOALhFvg0i2kFEX5GP+QMANwF4FxG9JP+5usnzmopaa/Efe/kiQj4nrt/Qo8h5iQiv3xTCYx+8AV96+zZcvsKPa/oDijz3ctQ753U0msIKf2ulc0p5z/Xrkc4V8FCFXH6xA9rkVzjV/HQuzCTgc9mqNv5tDPkQ8DjwxOExPHFoDPds13ezlkNE2CBbLNTKpIFsFQCgqcQSY2wKwM1l7t8P4L3yz98B8J1mzmN2aum2nUtl8ezxCN6+c63iBloWC+HOrStx59aVij5vJQIeB87L+dpaGI+lsHV161bqDoV9uHGoB9967ized+MAHLbFcRYXfLPX4Xe57XBYLZUFf3r5kkyOxULYNRDA44ckX6J7dd6sLWUw5K1rUMtUPI2NOu89lCI6bTVgQfArR/hPH51AJlfAnQa4dG2WbrcD0zXY5ALSptxoNIU+v3GiIDV4zw3rMR5L4/FDo5c8VrRGdhpjY69RiAihZSrSzk8vX5JZCh97uG1tFy7r8yu2xmYZDHkxGk0hXsNcacYYJuczhinJBITga0K32w67dfnZto8dHEWf34Xtay9pVjYdAY8Dc+lcTTNAZxNZZHIF9LVYhc5SXjvUiw29HnztP85cUsc9m8zC77Kb1hq5lErzHxhjGJ5JLluSWcpNQ72wWgj37+5XeIXNsaG3dosF/hkwUkpHCL4GEMndthUin1gqi18fj+D2K1e0xIee2yvM1rBxyxt1WsFWYTksFsK7r1+Pg8NR7D83s+ixVuiy5VSabRuZSyOdK1St0OH093iw52M3483bVim9xKaop1JnoQZfRPhtR2iZIc+/eGUcmXwBd15l/nQOUGKgVovgyzX4fZ3GiYLU4ve3r0Znhx1fWzK0prUEv/wM5+VskSthRDO9dUE3bBaqyTWT25wYpekKEIKvGaFl7BV+dnAUq7o6sK3B2nujURzsXUMevxjht3hKBwA6HFa8/dq1ePLIWLEJCWg9wY+nc5fkuIslmTWmdIyK3WpBf4+npgjfaLYKgBB8zZBym5dG+NFkFr8+EcHtV/a1TB16oM4In2ihdLXVeefudbAQ4Zu/O1u8r7UEv/zAH/4FV4sZoNEZ7PXWlMMvOmWKCL/9CPtdiKVyl3TbPvXKOLJ5hjs0KpnUgqKBWg21+GPRFHq8Ttit7fFWXNHZgduvXIHvPX+hGAW3gjUyp1It/oWZBEI+pyHq6ZtlMOTFuelE1aIEHuEHDGKNDAjB1wyej1ya1vnZwYtY1dWBq1Z36rEsVSimdGqwVxiLpVp+w3Yp77lhPebSOXx//4WWsUbmVOoqPz+dqHnD1ugMhrzIFxjOTlX2RwKkTdsut91QwYxxVtLiFGvxSzZuo4ksfnNiEnduXdEy6RxAynP6XbaaDNTGY6mWcsmshavXdOE167rx9f84i/lMa1gjcyqndJJY023u/D2HV+ocHY0te9zUfLpYwGAUhOBrRLkPwpNHxpArMEP4hChNwOPAdA3DP0ajqZbxwa+H91y/HuenE3jkwDAA8/vocHwuOzwO66Ja/Gy+gNFosmUi/E19PoR8TjxyYGTZ4ybnjGWrAAjB14yQ79JL3ccOjWJtwI0rV7VOOofT7XFUzeGnsnlEk1n0taHg33pFGKu6OvDlZ6TZt2b30Skl7HctupIdnU2hwOoryTQydqsF9+1ci18dj+DcMmmdyfm0EPx2hXfb8g/CzHwG/3FyEne0WDqHE6zBQG2sBQef1IrNasH9160rRsKtEuEDcs9JdEHweQ3+apOXZJby9mvXwmohfGfPuYrHTMUzhmq6AoTga8ZCt630AX/yyBjyBYY7rmy9dA4gbdxWs0heGHzSfoIPAG+7Zi3c8rjJVhL8pRF+LYNPzEbY78KtV4Tx8P7hSybLAUAmV0A0mRURfjsT8juLFsk/OzSK/qAbV6w0jjGUkgQ8DkzNZ5ad/8n3M9oxwgckkX/ra1YDaMGUTixd/N1fmEnAZqGW+2J/x65+RJNZ/PTli5c8xq9uRYTfxoR90gdhKp7G705NtWw6B5By+JlcAYky0Q9nocu2tYSgHj78hk34n2+9qiUakjghn7MY4QLA+ekkVnZ1wGag8kQl2DUQwMawF9/ac/aSwIbX4Ac9IsJvW0J+JyZiKTx5ZFxO57ROs9VSAsVa/MppnbFoCj6nDV6T2wI3Q6fbjrfIUX6r0Ne5eP7DhemE6S0VykFEeMeudTg8EsNLF2YXPcYFv9cnIvy2hXfb/uCFCxjo9eDyFcYZjKA0vLtwuTz+WDRVnIMqaB2Wzn8YnqndB99s/Kftq+FxWPHt5xZv3hadMkWE375wv5gD52dx55Wtm84BFiySp5aL8Nuwy7Yd4PYKY7EUEpkcJuOZlqnBX4rXacM921fjsYOjRXdMoCSlI3L47UuoRNxayTunHMUIv0pKp53z961KyM9tRFIYnpFcMle3SJdtOd6xex0y+QIe3j9cvG9qPgOnzWK4dKUQfA3h3baDIS82hr06r0ZdquXw8wWGSDwtIvwWxGW3orPDjvFYeqEks0UjfADYGPZh10AA39lzDvmCtHk7GZearox2FS8EX0NWdHbAZiHcddVKw70RlMbfYYPVQhVz+JPxNPIFJiL8FiUsz7blw+xrGV5uZt65ux8js0k88+oEAMka2Ug++Bwh+BrS2WHHTz94A/7ktRv0XorqEJE0zLxChM+brkSE35pIzVdpXJhOosNuNZyJmNK8YXMYYb8T35I7b6fiaUNNuuIIwdeYy1f44bC1x8se8NgrCv7CaEMh+K2INOowhQszUklmq1/Rcn+dXx+P4OzkvGSrYMAvufZQHoEudLsdmKngiT8WlTbzhOC3JmG/ExNzaZyfat2SzKW8feda2CyEb+85h6n5NHoMOMVNCL5ANYJeR8Uxh2OxNOxWKm7uClqLsN+FfIHhxMRcS2/YlhLyu3Drlj48tO88snkmInxBe7FcDn88lkLI54LF0tqX+u0KtwMvsNYuyVzKO3etK9qJGM04DRCCL1CRgMeB2USmWKpWymg02XJmWoIFeAky0NolmUvZuT6ATWGpg14IvqCt6HY7UGDSkO6ljMfSwlahhSl1QG31ksxSiAj3X9cPAFhlwCsbY7WBCVoK3lY+ncgUrRYAgDGGsWgKv3dZSK+lCVSm1+cEEcBYe0X4AHDfzjV4zbpurO/x6L2USxCCL1CNbneJvULvwv2xZA7JbF6kdFoYu9WCoMeJfKFgOHsBtSEibOozpjFiUykdIgoQ0VNEdEL+u3uZY/1ENExEX2rmnALzEKhgoDbW5oNP2oWw39l20b3RaTaH/1EATzPGhgA8Ld+uxKcB/LrJ8wlMRHcFAzUx+KQ9+Mitm/CRN27SexmCEpoV/LsBfFP++ZsA3lzuICJ6DYAwgJ83eT6BiSgaqC2pxS82XYkIv6V5/aYQbtrYW/1AgWY0K/hhxtio/PMYJFFfBBFZAHwewEeqPRkRvZ+I9hPR/kgk0uTSBHrT4bCiw269NMKPSl7hIqUjEGhL1d0UIvoFgL4yD3289AZjjBFRuYnVfwbgccbYcDU/DcbYAwAeAIAdO3ZUnn4tMA18mHkpY7EUeryOtvEUEgiMQlXBZ4zdUukxIhonohWMsVEiWgFgosxhuwHcSER/BsALwEFEccbYcvl+QYvQ7bGXifCTIroXCHSg2XqpRwHcD+Af5L9/svQAxtgf8p+J6F0Adgixbx8CHiemE4sbr8ZiaawUG7YCgeY0e039DwDeQEQnANwi3wYR7SCirzS7OIH5CbgvjfDHY2K0oUCgB01F+IyxKQA3l7l/P4D3lrn/GwC+0cw5Beai27PYQC2VzWN6PiMqdAQCHRC7ZgJVCbgdiKdzSOckB8GJmFyhIyJ8gUBzhOALVIU3X83KeXzedCVsFQQC7RGCL1AVPgSCp3VGRdOVQKAbQvAFqrLUXmGc++iICF8g0Bwh+AJVWWqgNhZNw+OwwtdmDooCgREQgi9QlaJFqE53wgAABz5JREFUsuynMxZLItzpQrWua4FAoDxC8AWq0u22A1jI4Y9FU2LDViDQCSH4AlWxWS3o7FhovhqLpoStgkCgE0LwBarDDdQKBYaJubSo0BEIdEIIvkB1ut12zCQymJxPI1dgIqUjEOiEEHyB6gQ8TkzPZzEWFaMNBQI9EYIvUJ2AbJHMBV8YpwkE+iAEX6A63EBNzLIVCPRFCL5AdQJuBzL5Ak5NxGGzEHo8Tr2XJBC0JULwBarDu22Pjs4h5HPCYhFNVwKBHgjBF6jOguDHRDpHINARIfgC1eEGanPpnBB8gUBHhOALVCcg++kAoiRTINATIfgC1Ql4FwRfNF0JBPohBF+gOj6nDTZ5o1ZE+AKBfgjBF6gOERXz+Cs6O3RejUDQvgjBF2gCz+ML4zSBQD+E4As0odsj+eKH/KLpSiDQCyH4Ak0Iepzodtvhslv1XopA0LaIwaICTXjH7nW4aWOP3ssQCNoaIfgCTdg1EMSugaDeyxAI2hqR0hEIBII2QQi+QCAQtAlC8AUCgaBNEIIvEAgEbUJTgk9EASJ6iohOyH93VzhuLRH9nIiOEtErRNTfzHkFAoFAUD/NRvgfBfA0Y2wIwNPy7XJ8C8DnGGOXA9gJYKLJ8woEAoGgTpoV/LsBfFP++ZsA3rz0ACLaDMDGGHsKABhjccZYosnzCgQCgaBOmhX8MGNsVP55DEC4zDEbAcwS0SNE9CIRfY6IyrZbEtH7iWg/Ee2PRCJNLk0gEAgEpVRtvCKiXwDoK/PQx0tvMMYYEbEK57gRwDYA5wF8D8C7AHx16YGMsQcAPCCfN0JE56qtbxl6AEw28e/VRKytMcTaGkOsrTHMurZ1lf5RVcFnjN1S6TEiGieiFYyxUSJagfK5+WEALzHGTsv/5scAdqGM4C85b2+1tS0HEe1njO1o5jnUQqytMcTaGkOsrTFacW3NpnQeBXC//PP9AH5S5pjnAXQRERfw3wPwSpPnFQgEAkGdNCv4/wDgDUR0AsAt8m0Q0Q4i+goAMMbyAD4C4GkiOgSAAPxrk+cVCAQCQZ00ZZ7GGJsCcHOZ+/cDeG/J7acAbG3mXA3wgMbnqwextsYQa2sMsbbGaLm1EWPl9lkFAoFA0GoIawWBQCBoE4TgCwQCQZvQcoJPRLcR0TEiOklElawedIGIzhLRISJ6iYj2G2A9XyOiCSI6XHJfTf5IOqzrk0Q0Ir92LxHR7VqvS17HGiJ6RvaEOkJEH5LvN8LrVmltur92ROQion1E9LK8tr+T719PRHvlz+v3iMhhoLV9g4jOlLxuV2u9tpI1WuXG1cfk2429boyxlvkDwArgFIABAA4ALwPYrPe6StZ3FkCP3usoWc9NALYDOFxy32cBfFT++aMAPmOQdX0SwEcM8JqtALBd/tkH4DiAzQZ53SqtTffXDlJ1nlf+2Q5gL6R+nIcB3Cvf/38A/KmB1vYNAG/R+z0nr+vDAB4E8Jh8u6HXrdUi/J0ATjLGTjPGMgC+C8nvR1AGxtivAUwvubuqP5LaVFiXIWCMjTLGDsg/zwE4CmAVjPG6VVqb7jCJuHzTLv9hkPpyfiDfr9frVmlthoCIVgO4A8BX5NuEBl+3VhP8VQAulNwehkHe8DIMwM+J6AUier/ei6lALf5IevEBIjoop3w0T5ksRbb53gYpIjTU67ZkbYABXjs5LfESpI78pyBdjc8yxnLyIbp9XpeujTHGX7f/T37d/pGInHqsDcD/AvDfABTk20E0+Lq1muAbnRsYY9sBvAnAnxPRTXovaDmYdL1olEjnnwFsAHA1gFEAn9dzMUTkBfBDAP+FMRYrfUzv163M2gzx2jHG8oyxqwGshnQ1fpke6yjH0rUR0RYAH4O0xmsABAD8d63XRUR3AphgjL2gxPO1muCPAFhTcnu1fJ8hYIyNyH9PAPgRpDe90RiXfZGwjD+S5jDGxuUPZQFSp7Zurx0R2SEJ6r8xxh6R7zbE61ZubUZ67eT1zAJ4BsBuSLYrvAFU989rydpuk1NkjDGWBvB16PO6XQ/gLiI6CylF/XsAvogGX7dWE/znAQzJO9gOAPdC8vvRHSLyEJGP/wzgjQAOL/+vdKEWfyTN4WIq85+g02sn50+/CuAoY+wLJQ/p/rpVWpsRXjsi6iWiLvnnDgBvgLTH8AyAt8iH6fW6lVvbqyVf4AQpR67568YY+xhjbDVjrB+Snv2SMfaHaPR103v3WYXd7NshVSecAvBxvddTsq4BSFVDLwM4YoS1AXgI0iV+FlIe8I8g5QefBnACwC8ABAyyrm8DOATgICRxXaHTa3YDpHTNQQAvyX9uN8jrVmltur92kKxVXpTXcBjA38r3DwDYB+AkgO8DcBpobb+UX7fDAL4DuZJHrz8AXoeFKp2GXjdhrSAQCARtQquldAQCgUBQASH4AoFA0CYIwRcIBII2QQi+QCAQtAlC8AUCgaBNEIIvEAgEbYIQfIFAIGgT/i8Z+//YdJBptQAAAABJRU5ErkJggg==\n" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } + ], + "source": [ + "plt.plot(model.get_layer(\"conv2\").weights[0][:,:,2])" ] }, { @@ -6743,4 +6743,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/code/reproduce_results.py b/code/reproduce_results.py index 6738840..c56a762 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -3,11 +3,9 @@ # model configs from configs.fastai_configs import * from configs.wavelet_configs import * +import sys - -def main(datafolder = '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/', - datafolder_icbeb = '../data/ICBEB/', - outputfolder = '../../content/drive/MyDrive/PTB-xl-output/'): +def main(datafolder, datafolder_icbeb, outputfolder): models = [ @@ -52,7 +50,10 @@ def main(datafolder = '../../content/data/ptb-xl-a-large-publicly-available-elec e.evaluate() # generate greate summary table - utils.ICBEBE_table(folder='../../content/drive/MyDrive/PTB-xl-output/') + utils.ICBEBE_table(folder=outputfolder) if __name__ == "__main__": - main() + if not (len(sys.argv) == 4: + raise Exception('Include the data and model folders as arguments, e.g., python reproduce_results.py ./path/to/data/ ./path/to/icbeb/ ./path/to/output/') + else: + main(datafolder = sys.argv[1], datafolder_icbeb = sys.argv[2], outputfolder = sys.argv[3]) \ No newline at end of file From ee3e3a15dc9df2f3fc82d058b0891d29509e1ef5 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Tue, 1 Nov 2022 15:22:59 +0100 Subject: [PATCH 11/51] Update reproduce_results.py --- code/reproduce_results.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index c56a762..06b70bb 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -53,7 +53,7 @@ def main(datafolder, datafolder_icbeb, outputfolder): utils.ICBEBE_table(folder=outputfolder) if __name__ == "__main__": - if not (len(sys.argv) == 4: + if not (len(sys.argv) == 4): raise Exception('Include the data and model folders as arguments, e.g., python reproduce_results.py ./path/to/data/ ./path/to/icbeb/ ./path/to/output/') else: main(datafolder = sys.argv[1], datafolder_icbeb = sys.argv[2], outputfolder = sys.argv[3]) \ No newline at end of file From aaf865a62fe91c510aa0020444718385966fac1c Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Thu, 17 Nov 2022 11:53:07 +0100 Subject: [PATCH 12/51] Update scp_experiment.py add noise to test data to assess robustness --- code/experiments/scp_experiment.py | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 8fc3292..827e762 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -5,6 +5,7 @@ import numpy as np import multiprocessing from itertools import repeat +import matplotlib.pyplot as plt class SCP_Experiment(): ''' @@ -59,6 +60,10 @@ def prepare(self): self.X_train, self.X_val, self.X_test = utils.preprocess_signals(self.X_train, self.X_val, self.X_test, self.outputfolder+self.experiment_name+'/data/') self.n_classes = self.y_train.shape[1] + # Add noise to test data + noise = np.random.normal(self.X_test.mean(),self.X_test.std(),size=self.X_test.shape) + self.X_test = self.X_test + noise + # save train and test labels self.y_train.dump(self.outputfolder + self.experiment_name+ '/data/y_train.npy') self.y_val.dump(self.outputfolder + self.experiment_name+ '/data/y_val.npy') @@ -113,6 +118,8 @@ def perform(self): # predict and dump model.predict(self.X_train).dump(mpath+'y_train_pred.npy') model.predict(self.X_val).dump(mpath+'y_val_pred.npy') + plt.plot(self.X_test[0,:,0]) + plt.show() model.predict(self.X_test).dump(mpath+'y_test_pred.npy') modelname = 'ensemble' From 8ec778c9cc3ae6c80b9bb1e15870def5768c3ecf Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Tue, 6 Dec 2022 15:54:20 +0100 Subject: [PATCH 13/51] Add my model --- code/configs/your_configs.py | 2 +- code/models/your_model.py | 105 +++++++++++++++++++++++++++++++++-- code/reproduce_results.py | 2 + 3 files changed, 103 insertions(+), 6 deletions(-) diff --git a/code/configs/your_configs.py b/code/configs/your_configs.py index 708e59d..1027669 100644 --- a/code/configs/your_configs.py +++ b/code/configs/your_configs.py @@ -1,2 +1,2 @@ -your_custom_config = {'modelname':'YOUR_MODEL', 'modeltype':'YOUR_MODEL_TYPE', +my_custom_config = {'modelname':'tf_inception', 'modeltype':'MyModel', 'parameters':dict()} \ No newline at end of file diff --git a/code/models/your_model.py b/code/models/your_model.py index b94158e..bb20516 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -1,15 +1,110 @@ from models.base_model import ClassificationModel +import tensorflow as tf -class YourModel(ClassificationModel): + +class MyModel(ClassificationModel): def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape): self.name = name self.n_classes = n_classes self.sampling_frequency = sampling_frequency self.outputfolder = outputfolder - self.input_shape = input_shape + self.input_shape = input_shape + self.model = build_model((self.sampling_frequency*10,12),self.n_classes) + self.epoch = 30 + self.batch_size =32 def fit(self, X_train, y_train, X_val, y_val): - pass - + self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, + validation_data=(X_val, y_val), callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)]) + #self.model.save(self.outputfolder +'last_model.h5') def predict(self, X): - pass \ No newline at end of file + return self.model.predict(X) + + +def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=64, nb_filters=64): + + if use_bottleneck and int(input_tensor.shape[-1]) > 1: + input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1, + padding='same', activation=activation, use_bias=False)(input_tensor) + else: + input_inception = input_tensor + + # kernel_size_s = [3, 5, 8, 11, 17] + kernel_size_s = [kernel_size // (2 ** i) for i in range(3)] + + conv_list = [] + + for i in range(len(kernel_size_s)): + conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i], + strides=stride, padding='same', activation=activation, use_bias=False)( + input_inception)) + + max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor) + + conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1, + padding='same', activation=activation, use_bias=False)(max_pool_1) + + conv_list.append(conv_6) + + x = tf.keras.layers.Concatenate(axis=2)(conv_list) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation(activation='relu')(x) + return x + +def _shortcut_layer(input_tensor, out_tensor): + shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1, + padding='same', use_bias=False)(input_tensor) + shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y) + + x = tf.keras.layers.Add()([shortcut_y, out_tensor]) + x = tf.keras.layers.Activation('relu')(x) + return x + +def build_model(input_shape, nb_classes, depth=10, use_residual=True): + input_layer = tf.keras.layers.Input(input_shape) + + x = input_layer + input_res = input_layer + + for d in range(depth): + + x = _inception_module(x) + + if use_residual and d % 3 == 2: + x = _shortcut_layer(input_res, x) + input_res = x + + gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x) + + output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) + + model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer) + model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), + metrics=[tf.keras.metrics.BinaryAccuracy(), + tf.keras.metrics.AUC( + num_thresholds=200, + curve='ROC', + summation_method='interpolation', + name="ROC", + multi_label=True, + ), + tf.keras.metrics.AUC( + num_thresholds=200, + curve='PR', + summation_method='interpolation', + name="PRC", + multi_label=True, + ) + ]) + + return model + +def scheduler(epoch, lr): + if epoch == 15: + return lr*0.1 + elif epoch == 30: + return lr*0.1 + elif epoch == 30: + return lr*0.1 + else: + return lr \ No newline at end of file diff --git a/code/reproduce_results.py b/code/reproduce_results.py index 06b70bb..31f15ec 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -3,6 +3,7 @@ # model configs from configs.fastai_configs import * from configs.wavelet_configs import * +from configs.your_configs import * import sys def main(datafolder, datafolder_icbeb, outputfolder): @@ -16,6 +17,7 @@ def main(datafolder, datafolder_icbeb, outputfolder): conf_fastai_fcn_wang, conf_fastai_inception1d, conf_wavelet_standard_nn, + my_custom_config ] ########################################## From 9f584640b89ed4673328f73166a088010581a948 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 7 Dec 2022 08:54:42 +0100 Subject: [PATCH 14/51] small changes to noise induction --- code/experiments/scp_experiment.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 827e762..d9eec9a 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -24,6 +24,8 @@ def __init__(self, experiment_name, task, datafolder, outputfolder, models, samp self.outputfolder = outputfolder self.datafolder = datafolder self.sampling_frequency = sampling_frequency + self.noise_mean = 0 + self.noise_std_scale = 0.1 # create folder structure if needed if not os.path.exists(self.outputfolder+self.experiment_name): @@ -61,7 +63,7 @@ def prepare(self): self.n_classes = self.y_train.shape[1] # Add noise to test data - noise = np.random.normal(self.X_test.mean(),self.X_test.std(),size=self.X_test.shape) + noise = np.random.normal(self.noise_mean,self.X_test.std() * self.noise_std_scale, size = self.X_test.shape) self.X_test = self.X_test + noise # save train and test labels From 680444c034e62958dcbaf934d0d9cba4790e567c Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 7 Dec 2022 09:35:32 +0100 Subject: [PATCH 15/51] fix --- code/models/your_model.py | 2 +- code/reproduce_results.py | 16 +++++++++------- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/code/models/your_model.py b/code/models/your_model.py index bb20516..64e8209 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -96,7 +96,7 @@ def build_model(input_shape, nb_classes, depth=10, use_residual=True): multi_label=True, ) ]) - + print("Inception model built.") return model def scheduler(epoch, lr): diff --git a/code/reproduce_results.py b/code/reproduce_results.py index 31f15ec..ce8a291 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -10,13 +10,13 @@ def main(datafolder, datafolder_icbeb, outputfolder): models = [ - conf_fastai_xresnet1d101, - conf_fastai_resnet1d_wang, - conf_fastai_lstm, - conf_fastai_lstm_bidir, - conf_fastai_fcn_wang, - conf_fastai_inception1d, - conf_wavelet_standard_nn, + #conf_fastai_xresnet1d101, + #conf_fastai_resnet1d_wang, + #conf_fastai_lstm, + #conf_fastai_lstm_bidir, + #conf_fastai_fcn_wang, + #conf_fastai_inception1d, + #conf_wavelet_standard_nn, my_custom_config ] @@ -34,6 +34,8 @@ def main(datafolder, datafolder_icbeb, outputfolder): ] for name, task in experiments: + print(name) + print(task) e = SCP_Experiment(name, task, datafolder, outputfolder, models) e.prepare() e.perform() From 0942c9066b55ee14bad52dbda3d5bf15394b0ba7 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 7 Dec 2022 09:47:11 +0100 Subject: [PATCH 16/51] Update your_configs.py --- code/configs/your_configs.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/configs/your_configs.py b/code/configs/your_configs.py index 1027669..34355f3 100644 --- a/code/configs/your_configs.py +++ b/code/configs/your_configs.py @@ -1,2 +1,2 @@ -my_custom_config = {'modelname':'tf_inception', 'modeltype':'MyModel', +conf_tf_inception = {'modelname':'tf_inception', 'modeltype':'MyModel', 'parameters':dict()} \ No newline at end of file From ec99295db5bb309f110ae5a6fb95e794875b137a Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 7 Dec 2022 16:49:02 +0100 Subject: [PATCH 17/51] change config --- code/configs/your_configs.py | 2 +- code/models/your_model.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/code/configs/your_configs.py b/code/configs/your_configs.py index 34355f3..964c990 100644 --- a/code/configs/your_configs.py +++ b/code/configs/your_configs.py @@ -1,2 +1,2 @@ -conf_tf_inception = {'modelname':'tf_inception', 'modeltype':'MyModel', +conf_tf_inception = {'modelname':'tf_inception', 'modeltype':'inception_time_model', 'parameters':dict()} \ No newline at end of file diff --git a/code/models/your_model.py b/code/models/your_model.py index 64e8209..f88cd9f 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -2,8 +2,9 @@ import tensorflow as tf -class MyModel(ClassificationModel): +class inception_time_model(ClassificationModel): def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape): + super().__init__() self.name = name self.n_classes = n_classes self.sampling_frequency = sampling_frequency @@ -18,6 +19,7 @@ def fit(self, X_train, y_train, X_val, y_val): validation_data=(X_val, y_val), callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)]) #self.model.save(self.outputfolder +'last_model.h5') def predict(self, X): + X = [l.astype(np.float32) for l in X] return self.model.predict(X) From 5c6bdc80dc92689bb1c002ef0f23fc888a696779 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 2 Jan 2023 12:26:48 +0100 Subject: [PATCH 18/51] FIX: found a change that had to be done in order to run my_model epoch = 2 for my model in order to test. --- code/experiments/scp_experiment.py | 6 +++--- code/models/your_model.py | 5 +++-- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index d9eec9a..6dc01ce 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -107,10 +107,10 @@ def perform(self): elif modeltype == "fastai_model": from models.fastai_model import fastai_model model = fastai_model(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) - elif modeltype == "YOUR_MODEL_TYPE": + elif modeltype == "inception_time_model": # YOUR MODEL GOES HERE! - from models.your_model import YourModel - model = YourModel(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) + from models.your_model import inception_time_model + model = inception_time_model(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) else: assert(True) break diff --git a/code/models/your_model.py b/code/models/your_model.py index f88cd9f..f93ceb2 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -1,17 +1,18 @@ from models.base_model import ClassificationModel import tensorflow as tf +import numpy as np class inception_time_model(ClassificationModel): def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape): - super().__init__() + super(inception_time_model, self).__init__() self.name = name self.n_classes = n_classes self.sampling_frequency = sampling_frequency self.outputfolder = outputfolder self.input_shape = input_shape self.model = build_model((self.sampling_frequency*10,12),self.n_classes) - self.epoch = 30 + self.epoch = 2 self.batch_size =32 def fit(self, X_train, y_train, X_val, y_val): From 1e17bf17b23e088fdffafe7b267a5251992232a6 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 2 Jan 2023 12:43:05 +0100 Subject: [PATCH 19/51] Update reproduce_results.py Add right config name --- code/reproduce_results.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index ce8a291..b9c58a9 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -17,7 +17,7 @@ def main(datafolder, datafolder_icbeb, outputfolder): #conf_fastai_fcn_wang, #conf_fastai_inception1d, #conf_wavelet_standard_nn, - my_custom_config + conf_tf_inception ] ########################################## From cd5b90ca45c81004dcee039226005f243e77330a Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 2 Jan 2023 13:05:23 +0100 Subject: [PATCH 20/51] Add IF-statement to control if noise should be added or not --- code/experiments/scp_experiment.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 6dc01ce..74faca9 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -37,7 +37,7 @@ def __init__(self, experiment_name, task, datafolder, outputfolder, models, samp if not os.path.exists(outputfolder+self.experiment_name+'/data/'): os.makedirs(self.outputfolder+self.experiment_name+'/data/') - def prepare(self): + def prepare(self, add_noise=True): # Load PTB-XL data self.data, self.raw_labels = utils.load_dataset(self.datafolder, self.sampling_frequency) @@ -63,8 +63,9 @@ def prepare(self): self.n_classes = self.y_train.shape[1] # Add noise to test data - noise = np.random.normal(self.noise_mean,self.X_test.std() * self.noise_std_scale, size = self.X_test.shape) - self.X_test = self.X_test + noise + if add_noise == True: + noise = np.random.normal(self.noise_mean,self.X_test.std() * self.noise_std_scale, size = self.X_test.shape) + self.X_test = self.X_test + noise # save train and test labels self.y_train.dump(self.outputfolder + self.experiment_name+ '/data/y_train.npy') From 09c1be502848e4121455c0f306d30040c0144d11 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 2 Jan 2023 13:24:00 +0100 Subject: [PATCH 21/51] change predict statment and set noise as False by default --- code/experiments/scp_experiment.py | 2 +- code/models/your_model.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 74faca9..1e20f54 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -37,7 +37,7 @@ def __init__(self, experiment_name, task, datafolder, outputfolder, models, samp if not os.path.exists(outputfolder+self.experiment_name+'/data/'): os.makedirs(self.outputfolder+self.experiment_name+'/data/') - def prepare(self, add_noise=True): + def prepare(self, add_noise=False): # Load PTB-XL data self.data, self.raw_labels = utils.load_dataset(self.datafolder, self.sampling_frequency) diff --git a/code/models/your_model.py b/code/models/your_model.py index f93ceb2..4baf205 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -20,7 +20,6 @@ def fit(self, X_train, y_train, X_val, y_val): validation_data=(X_val, y_val), callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)]) #self.model.save(self.outputfolder +'last_model.h5') def predict(self, X): - X = [l.astype(np.float32) for l in X] return self.model.predict(X) From 096ccc0c2db93362bd6f40dc764bbc3c715eda19 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Mon, 2 Jan 2023 13:44:21 +0100 Subject: [PATCH 22/51] Update to 30 epochs --- code/models/your_model.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/code/models/your_model.py b/code/models/your_model.py index 4baf205..17c19c4 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -12,7 +12,7 @@ def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_sha self.outputfolder = outputfolder self.input_shape = input_shape self.model = build_model((self.sampling_frequency*10,12),self.n_classes) - self.epoch = 2 + self.epoch = 30 self.batch_size =32 def fit(self, X_train, y_train, X_val, y_val): From cb84116f74b29ae7f73ab2cfeaa27f7bad231641 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 4 Jan 2023 15:44:03 +0100 Subject: [PATCH 23/51] Add my finetuning NB --- My_Finetuning.ipynb | 540 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 540 insertions(+) create mode 100644 My_Finetuning.ipynb diff --git a/My_Finetuning.ipynb b/My_Finetuning.ipynb new file mode 100644 index 0000000..f7f136c --- /dev/null +++ b/My_Finetuning.ipynb @@ -0,0 +1,540 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "IG6fwukq5oSe" + }, + "source": [ + "# Load your data\n", + "\n", + "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", + "\n", + "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", + "\n", + "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", + "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0L-abXib6HkK", + "outputId": "f1f52165-be2b-43a1-deef-487ad092e24f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting wget\n", + " Downloading wget-3.2.zip (10 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting wfdb\n", + " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", + "Building wheels for collected packages: wget\n", + " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=9ee2ac4220cf0050bbe1ff61078358ae5d397aff8bc8735d071f55a5e1653f46\n", + " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", + "Successfully built wget\n", + "Installing collected packages: wget, wfdb\n", + "Successfully installed wfdb-4.1.0 wget-3.2\n" + ] + } + ], + "source": [ + "!pip install wget wfdb" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Jqxss_rS6Jxn" + }, + "outputs": [], + "source": [ + "import wget\n", + "import numpy as np\n", + "import os\n", + "import zipfile\n", + "import tensorflow as tf\n", + "from sklearn.utils.class_weight import compute_class_weight\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn.metrics import confusion_matrix\n", + "import pickle" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AcjcSuO06o-6", + "outputId": "af36b0d7-b30a-467a-d49b-c929e10ce9a9" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--2023-01-04 13:54:56-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "Resolving physionet.org (physionet.org)... 18.18.42.54\n", + "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1842722380 (1.7G) [application/zip]\n", + "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", + "\n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 11.7MB/s in 2m 29s \n", + "\n", + "2023-01-04 13:57:26 (11.8 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "\n", + "os.mkdir(\"./data/\")\n", + "\n", + "\n", + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eTAXTEV86rEj" + }, + "outputs": [], + "source": [ + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3Qv9hVm-5wyi", + "outputId": "b34def82-b6f9-4cc9-d408-50ffce572ce3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting GitPython\n", + " Downloading GitPython-3.1.30-py3-none-any.whl (184 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m19.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m8.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Installing collected packages: smmap, gitdb, GitPython\n", + "Successfully installed GitPython-3.1.30 gitdb-4.0.10 smmap-5.0.0\n" + ] + } + ], + "source": [ + "!pip install GitPython\n", + "from git import Repo" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u4T-c5KI5y2W" + }, + "outputs": [], + "source": [ + "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", + "DEST_NAME = 'github_repo'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r8hm-j6751kC", + "outputId": "16cfb00e-d530-4761-d56e-4ce8993fbfbb" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "id": "SRUZICm6562J", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "0022dad4-3beb-42d3-e4eb-8cd2d975a3ae" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "from github_repo.code import *\n", + "%matplotlib inline\n", + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "aiM4gNgv5_V2" + }, + "outputs": [], + "source": [ + "/content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CmW7xaR_5oSf", + "outputId": "22fa5cc9-454a-4fbb-f3b2-e3c7b586854d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((19267, 1000, 12), (19267, 5), (2163, 1000, 12), (2163, 5))" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "source": [ + "from github_repo.code.utils import utils\n", + "\n", + "sampling_frequency=100\n", + "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", + "task='superdiagnostic'\n", + "outputfolder='./github_repo/output/'\n", + "\n", + "\n", + "# Load PTB-XL data\n", + "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", + "# Preprocess label data\n", + "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", + "# Select relevant data and convert to one-hot\n", + "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "# 1-9 for training \n", + "X_train = data[labels.strat_fold < 10]\n", + "y_train = Y[labels.strat_fold < 10]\n", + "# 10 for validation\n", + "X_val = data[labels.strat_fold == 10]\n", + "y_val = Y[labels.strat_fold == 10]\n", + "\n", + "num_classes = 5 # <=== number of classes in the finetuning dataset\n", + "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", + "\n", + "X_train.shape, y_train.shape, X_val.shape, y_val.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1UyIF9kv5oSg" + }, + "source": [ + "# Train or download models\n", + "There are two possibilities:\n", + " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", + " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", + "\n", + "# Load pretrained model\n", + "\n", + "For loading a pretrained model:\n", + " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", + " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", + " \n", + "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cEx-BdLJ5oSh", + "outputId": "8e58d9a2-d158-4478-af6c-e4ad1966ba63" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n" + ] + } + ], + "source": [ + "from github_repo.code.models.your_model import inception_time_model\n", + "\n", + "experiment = 'exp0'\n", + "modelname = 'fastai_xresnet1d101'\n", + "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", + "mpath='../output/' # <=== path where the finetuned model will be stored\n", + "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", + "\n", + "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", + "\n", + "#model = fastai_model(\n", + "# modelname, \n", + "# num_classes, \n", + "# sampling_frequency, \n", + "# mpath, \n", + "# input_shape=input_shape, \n", + "# pretrainedfolder=pretrainedfolder,\n", + "# n_classes_pretrained=n_classes_pretrained, \n", + "# pretrained=True,\n", + "# epochs_finetuning=2,\n", + "#)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V6dtMWU15oSh" + }, + "source": [ + "# Preprocess data with pretrained Standardizer\n", + "\n", + "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "uqSSsK_V5oSh" + }, + "outputs": [], + "source": [ + "import pickle\n", + "from github_repo.code.utils import utils\n", + "\n", + "standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", + "\n", + "X_train = utils.apply_standardizer(X_train, standard_scaler)\n", + "X_val = utils.apply_standardizer(X_val, standard_scaler)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vfdlaRZr5oSh" + }, + "source": [ + "# Finetune model\n", + "\n", + "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true, + "base_uri": "https://localhost:8080/" + }, + "id": "MxzCOgaP5oSi", + "outputId": "a516c2b7-c7e7-4aec-ef63-fd4cb070f57e" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Epoch 1: LearningRateScheduler setting learning rate to 0.0010000000474974513.\n", + "Epoch 1/30\n", + "603/603 [==============================] - 217s 338ms/step - loss: 0.3309 - binary_accuracy: 0.8579 - ROC: 0.8877 - PRC: 0.7383 - val_loss: 0.3352 - val_binary_accuracy: 0.8607 - val_ROC: 0.9058 - val_PRC: 0.7844 - lr: 0.0010\n", + "\n", + "Epoch 2: LearningRateScheduler setting learning rate to 0.0010000000474974513.\n", + "Epoch 2/30\n", + "319/603 [==============>...............] - ETA: 1:33 - loss: 0.2876 - binary_accuracy: 0.8797 - ROC: 0.9170 - PRC: 0.7969" + ] + } + ], + "source": [ + "model.fit(X_train, y_train, X_val, y_val)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kvnNlyCX5oSi" + }, + "source": [ + "# Evaluate model on validation data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "m1rgPocD5oSi", + "outputId": "6d91d6ab-7d00-4433-cdbd-2d7fd083cdaa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aggregating predictions...\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
macro_aucFmax
00.9314580.827961
\n", + "
" + ], + "text/plain": [ + " macro_auc Fmax\n", + "0 0.931458 0.827961" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_val_pred = model.predict(X_val)\n", + "utils.evaluate_experiment(y_val, y_val_pred)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", + "language": "python", + "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From cd4596fad9f2d6ea6a61535e5d5d846fa348338d Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 6 Jan 2023 12:45:00 +0100 Subject: [PATCH 24/51] Update your_model.py --- code/models/your_model.py | 35 ++++++++++++++++++----------------- 1 file changed, 18 insertions(+), 17 deletions(-) diff --git a/code/models/your_model.py b/code/models/your_model.py index 17c19c4..625f8e4 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -4,16 +4,19 @@ class inception_time_model(ClassificationModel): - def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape): + def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red="yes", model_depth=6, loss="bce", kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary"): super(inception_time_model, self).__init__() self.name = name self.n_classes = n_classes self.sampling_frequency = sampling_frequency self.outputfolder = outputfolder self.input_shape = input_shape - self.model = build_model((self.sampling_frequency*10,12),self.n_classes) - self.epoch = 30 - self.batch_size =32 + self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = 0.001, depth=model_depth, kernel_size=40, bottleneck_size=32, nb_filters=32,clf="binary") + self.epoch = epoch + self.batch_size = batch_size + self.lr_red = lr_red + self.loss = loss + def fit(self, X_train, y_train, X_val, y_val): self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, @@ -23,7 +26,7 @@ def predict(self, X): return self.model.predict(X) -def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=64, nb_filters=64): +def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32): if use_bottleneck and int(input_tensor.shape[-1]) > 1: input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1, @@ -62,7 +65,7 @@ def _shortcut_layer(input_tensor, out_tensor): x = tf.keras.layers.Activation('relu')(x) return x -def build_model(input_shape, nb_classes, depth=10, use_residual=True): +def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary"): input_layer = tf.keras.layers.Input(input_shape) x = input_layer @@ -70,18 +73,20 @@ def build_model(input_shape, nb_classes, depth=10, use_residual=True): for d in range(depth): - x = _inception_module(x) + x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters) if use_residual and d % 3 == 2: x = _shortcut_layer(input_res, x) input_res = x gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x) - - output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) - + if clf == "binary": + output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) + elif clf == "cat" + output_layer = tf.keras.layers.Dense(units=nb_classes,activation='softmax')(gap_layer) + model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer) - model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), + model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), metrics=[tf.keras.metrics.BinaryAccuracy(), tf.keras.metrics.AUC( num_thresholds=200, @@ -102,11 +107,7 @@ def build_model(input_shape, nb_classes, depth=10, use_residual=True): return model def scheduler(epoch, lr): - if epoch == 15: - return lr*0.1 - elif epoch == 30: - return lr*0.1 - elif epoch == 30: + if i%5 == 0: return lr*0.1 else: - return lr \ No newline at end of file + return lr From 0199427ac0ea5174f8ab249ed6d802350b5f965a Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sat, 21 Jan 2023 18:53:15 +0100 Subject: [PATCH 25/51] fix errors --- My_Finetuning.ipynb | 508 ++++++++++++++++++++++++++++++++------ code/models/your_model.py | 15 +- 2 files changed, 442 insertions(+), 81 deletions(-) diff --git a/My_Finetuning.ipynb b/My_Finetuning.ipynb index f7f136c..6d45eaa 100644 --- a/My_Finetuning.ipynb +++ b/My_Finetuning.ipynb @@ -18,18 +18,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0L-abXib6HkK", - "outputId": "f1f52165-be2b-43a1-deef-487ad092e24f" + "outputId": "3dd153ea-7535-4e1d-d5ad-28e5f72a6854" }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting wget\n", @@ -37,28 +37,28 @@ " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", "Collecting wfdb\n", " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", "Building wheels for collected packages: wget\n", " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=9ee2ac4220cf0050bbe1ff61078358ae5d397aff8bc8735d071f55a5e1653f46\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=6820786d45ca6ae353e9bfa386ce67f245a61ee785c721943cf032250b7f3e13\n", " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", "Successfully built wget\n", "Installing collected packages: wget, wfdb\n", @@ -72,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "id": "Jqxss_rS6Jxn" }, @@ -92,29 +92,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AcjcSuO06o-6", - "outputId": "af36b0d7-b30a-467a-d49b-c929e10ce9a9" + "outputId": "007d58e0-f461-407b-9359-cd2f6980c266" }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ - "--2023-01-04 13:54:56-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2023-01-21 17:17:21-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 11.7MB/s in 2m 29s \n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 1.73MB/s in 16m 32s \n", "\n", - "2023-01-04 13:57:26 (11.8 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "2023-01-21 17:33:54 (1.77 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", "\n" ] } @@ -131,38 +131,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "eTAXTEV86rEj" - }, - "outputs": [], - "source": [ - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3Qv9hVm-5wyi", - "outputId": "b34def82-b6f9-4cc9-d408-50ffce572ce3" + "outputId": "2f8465bf-bf9e-46f1-a200-e4c108d09d49" }, "outputs": [ { - "name": "stdout", "output_type": "stream", + "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", " Downloading GitPython-3.1.30-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m19.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m8.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m9.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hCollecting smmap<6,>=3.0.1\n", " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", "Installing collected packages: smmap, gitdb, GitPython\n", @@ -177,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": { "id": "u4T-c5KI5y2W" }, @@ -189,24 +177,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "r8hm-j6751kC", - "outputId": "16cfb00e-d530-4761-d56e-4ce8993fbfbb" + "outputId": "6d02001d-2b8f-4692-e4f2-100ed12ae6aa" }, "outputs": [ { + "output_type": "execute_result", "data": { "text/plain": [ "" ] }, - "execution_count": 7, "metadata": {}, - "output_type": "execute_result" + "execution_count": 6 } ], "source": [ @@ -215,13 +203,13 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 29, "metadata": { "id": "SRUZICm6562J", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "0022dad4-3beb-42d3-e4eb-8cd2d975a3ae" + "outputId": "66067ee4-5c80-41a4-f281-96122f1d2d46" }, "outputs": [ { @@ -241,35 +229,31 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "aiM4gNgv5_V2" - }, - "outputs": [], - "source": [ - "/content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1" - ] - }, - { - "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "CmW7xaR_5oSf", - "outputId": "22fa5cc9-454a-4fbb-f3b2-e3c7b586854d" + "outputId": "4ea3a0ed-8514-42bf-91af-c77fd45465ea" }, "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 21837/21837 [00:51<00:00, 427.90it/s]\n" + ] + }, { "output_type": "execute_result", "data": { "text/plain": [ - "((19267, 1000, 12), (19267, 5), (2163, 1000, 12), (2163, 5))" + "((19634, 1000, 12), (19634, 71), (2203, 1000, 12), (2203, 71))" ] }, "metadata": {}, - "execution_count": 10 + "execution_count": 8 } ], "source": [ @@ -277,7 +261,7 @@ "\n", "sampling_frequency=100\n", "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task='superdiagnostic'\n", + "task='all'\n", "outputfolder='./github_repo/output/'\n", "\n", "\n", @@ -297,12 +281,113 @@ "X_val = data[labels.strat_fold == 10]\n", "y_val = Y[labels.strat_fold == 10]\n", "\n", - "num_classes = 5 # <=== number of classes in the finetuning dataset\n", + "num_classes = 71 # <=== number of classes in the finetuning dataset\n", "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", "\n", "X_train.shape, y_train.shape, X_val.shape, y_val.shape" ] }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ], + "metadata": { + "id": "DIKpffEJMllK", + "outputId": "b3b59962-293b-45d2-9d6c-752c690d9145", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" + ], + "metadata": { + "id": "-a6LeAwqOm_i" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_grid.shape" + ], + "metadata": { + "id": "QW5xSWezMWo-", + "outputId": "18dd0833-4014-4926-e271-3caf856786b4", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1964, 1000, 12)" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ], + "metadata": { + "id": "fDz352LpQNds", + "outputId": "e37bb003-c3a2-4fe7-ff71-8d09e8742b4c", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, { "cell_type": "markdown", "metadata": { @@ -325,13 +410,136 @@ }, { "cell_type": "code", - "execution_count": 16, + "source": [ + "from github_repo.code.models.base_model import ClassificationModel\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "\n", + "def scheduler(epoch, lr):\n", + " if epoch % 5 == 0:\n", + " return lr*0.1\n", + " else:\n", + " return lr\n", + " \n", + "class inception_time_model(ClassificationModel):\n", + " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\"):\n", + " super(inception_time_model, self).__init__()\n", + " self.name = name\n", + " self.n_classes = n_classes\n", + " self.sampling_frequency = sampling_frequency\n", + " self.outputfolder = outputfolder\n", + " self.input_shape = input_shape\n", + " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = 0.001, depth=model_depth, kernel_size=40, bottleneck_size=32, nb_filters=32,clf=\"binary\")\n", + " self.epoch = epoch \n", + " self.batch_size = batch_size\n", + " self.lr_red = lr_red\n", + " self.loss = loss\n", + " \n", + "\n", + " def fit(self, X_train, y_train, X_val, y_val):\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), \n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)\n", + " ])\n", + " #self.model.save(self.outputfolder +'last_model.h5')\n", + " def predict(self, X):\n", + " return self.model.predict(X)\n", + "\n", + "\n", + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", + " strides=stride, padding='same', activation=activation, use_bias=False)(\n", + " input_inception))\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", + "\n", + " conv_list.append(conv_6)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='same', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + "\n", + " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\"):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\",\n", + " multi_label=True,\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\",\n", + " multi_label=True,\n", + " )\n", + " ])\n", + " print(\"Inception model built.\")\n", + " return model\n", + "\n", + "\n" + ], + "metadata": { + "id": "kg7-fD1ocLBB" + }, + "execution_count": 33, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cEx-BdLJ5oSh", - "outputId": "8e58d9a2-d158-4478-af6c-e4ad1966ba63" + "outputId": "83a21221-c5e0-492b-c90a-61830f336888" }, "outputs": [ { @@ -345,6 +553,8 @@ "source": [ "from github_repo.code.models.your_model import inception_time_model\n", "\n", + "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", + "\n", "experiment = 'exp0'\n", "modelname = 'fastai_xresnet1d101'\n", "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", @@ -372,6 +582,16 @@ "id": "V6dtMWU15oSh" }, "source": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "# Preprocess data with pretrained Standardizer\n", "\n", "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" @@ -379,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 24, "metadata": { "id": "uqSSsK_V5oSh" }, @@ -388,12 +608,38 @@ "import pickle\n", "from github_repo.code.utils import utils\n", "\n", - "standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", + "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", "\n", - "X_train = utils.apply_standardizer(X_train, standard_scaler)\n", - "X_val = utils.apply_standardizer(X_val, standard_scaler)" + "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", + "#X_val = utils.apply_standardizer(X_val, standard_scaler)" ] }, + { + "cell_type": "code", + "source": [ + "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", + "\n", + "def apply_standardizer(X, ss):\n", + " X_tmp = []\n", + " for x in X:\n", + " x_shape = x.shape\n", + " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", + " X_tmp = np.array(X_tmp)\n", + " return X_tmp\n", + "\n", + "def preprocess_signals(X_train, X_validation):\n", + " # Standardize data such that mean 0 and variance 1\n", + " ss = StandardScaler()\n", + " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", + " \n", + " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" + ], + "metadata": { + "id": "lOSQURgFUycV" + }, + "execution_count": 25, + "outputs": [] + }, { "cell_type": "markdown", "metadata": { @@ -410,30 +656,145 @@ "execution_count": null, "metadata": { "colab": { - "background_save": true, "base_uri": "https://localhost:8080/" }, "id": "MxzCOgaP5oSi", - "outputId": "a516c2b7-c7e7-4aec-ef63-fd4cb070f57e" + "outputId": "33ec21c7-4e2e-4c74-86b2-c2ca4e4a0f07" }, "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, { "output_type": "stream", "name": "stdout", "text": [ + "Inception model built.\n", "\n", - "Epoch 1: LearningRateScheduler setting learning rate to 0.0010000000474974513.\n", + "Epoch 1: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", "Epoch 1/30\n", - "603/603 [==============================] - 217s 338ms/step - loss: 0.3309 - binary_accuracy: 0.8579 - ROC: 0.8877 - PRC: 0.7383 - val_loss: 0.3352 - val_binary_accuracy: 0.8607 - val_ROC: 0.9058 - val_PRC: 0.7844 - lr: 0.0010\n", + "41/41 [==============================] - 16s 115ms/step - loss: 0.6748 - binary_accuracy: 0.5771 - ROC: 0.5002 - PRC: 0.0492 - val_loss: 0.7851 - val_binary_accuracy: 0.5439 - val_ROC: 0.4735 - val_PRC: 0.0526 - lr: 1.0000e-04\n", "\n", - "Epoch 2: LearningRateScheduler setting learning rate to 0.0010000000474974513.\n", + "Epoch 2: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", "Epoch 2/30\n", - "319/603 [==============>...............] - ETA: 1:33 - loss: 0.2876 - binary_accuracy: 0.8797 - ROC: 0.9170 - PRC: 0.7969" + "41/41 [==============================] - 4s 89ms/step - loss: 0.5111 - binary_accuracy: 0.8372 - ROC: 0.5278 - PRC: 0.0672 - val_loss: 0.5755 - val_binary_accuracy: 0.8213 - val_ROC: 0.5248 - val_PRC: 0.0599 - lr: 1.0000e-04\n", + "\n", + "Epoch 3: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", + "Epoch 3/30\n", + "41/41 [==============================] - 4s 89ms/step - loss: 0.3971 - binary_accuracy: 0.9104 - ROC: 0.5705 - PRC: 0.0735 - val_loss: 0.4401 - val_binary_accuracy: 0.9192 - val_ROC: 0.5569 - val_PRC: 0.0774 - lr: 1.0000e-04\n", + "\n", + "Epoch 4: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", + "Epoch 4/30\n", + "41/41 [==============================] - 4s 89ms/step - loss: 0.3128 - binary_accuracy: 0.9483 - ROC: 0.5890 - PRC: 0.0767 - val_loss: 0.3574 - val_binary_accuracy: 0.9609 - val_ROC: 0.5774 - val_PRC: 0.0905 - lr: 1.0000e-04\n", + "\n", + "Epoch 5: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", + "Epoch 5/30\n", + "41/41 [==============================] - 4s 91ms/step - loss: 0.2521 - binary_accuracy: 0.9613 - ROC: 0.6225 - PRC: 0.0881 - val_loss: 0.2830 - val_binary_accuracy: 0.9705 - val_ROC: 0.5914 - val_PRC: 0.0959 - lr: 1.0000e-04\n", + "\n", + "Epoch 6: LearningRateScheduler setting learning rate to 1.0000000474974514e-05.\n", + "Epoch 6/30\n", + "41/41 [==============================] - 4s 89ms/step - loss: 0.2254 - binary_accuracy: 0.9682 - ROC: 0.6402 - PRC: 0.0982 - val_loss: 0.2577 - val_binary_accuracy: 0.9708 - val_ROC: 0.5949 - val_PRC: 0.0995 - lr: 1.0000e-05\n", + "\n", + "Epoch 7: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", + "Epoch 7/30\n", + "41/41 [==============================] - 4s 88ms/step - loss: 0.2212 - binary_accuracy: 0.9687 - ROC: 0.6472 - PRC: 0.0993 - val_loss: 0.2411 - val_binary_accuracy: 0.9709 - val_ROC: 0.5957 - val_PRC: 0.1064 - lr: 1.0000e-05\n", + "\n", + "Epoch 8: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", + "Epoch 8/30\n", + "41/41 [==============================] - 4s 88ms/step - loss: 0.2172 - binary_accuracy: 0.9690 - ROC: 0.6455 - PRC: 0.0997 - val_loss: 0.2295 - val_binary_accuracy: 0.9710 - val_ROC: 0.5975 - val_PRC: 0.1066 - lr: 1.0000e-05\n", + "\n", + "Epoch 9: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", + "Epoch 9/30\n", + "41/41 [==============================] - 4s 88ms/step - loss: 0.2132 - binary_accuracy: 0.9695 - ROC: 0.6519 - PRC: 0.0994 - val_loss: 0.2213 - val_binary_accuracy: 0.9711 - val_ROC: 0.5995 - val_PRC: 0.1070 - lr: 1.0000e-05\n", + "\n", + "Epoch 10: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", + "Epoch 10/30\n", + "41/41 [==============================] - 4s 88ms/step - loss: 0.2092 - binary_accuracy: 0.9698 - ROC: 0.6604 - PRC: 0.1018 - val_loss: 0.2139 - val_binary_accuracy: 0.9713 - val_ROC: 0.5986 - val_PRC: 0.1079 - lr: 1.0000e-05\n", + "\n", + "Epoch 11: LearningRateScheduler setting learning rate to 1.0000000656873453e-06.\n", + "Epoch 11/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2070 - binary_accuracy: 0.9700 - ROC: 0.6595 - PRC: 0.1022 - val_loss: 0.2116 - val_binary_accuracy: 0.9711 - val_ROC: 0.6005 - val_PRC: 0.1077 - lr: 1.0000e-06\n", + "\n", + "Epoch 12: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", + "Epoch 12/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2067 - binary_accuracy: 0.9701 - ROC: 0.6518 - PRC: 0.1012 - val_loss: 0.2099 - val_binary_accuracy: 0.9710 - val_ROC: 0.6023 - val_PRC: 0.1082 - lr: 1.0000e-06\n", + "\n", + "Epoch 13: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", + "Epoch 13/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2062 - binary_accuracy: 0.9699 - ROC: 0.6559 - PRC: 0.1020 - val_loss: 0.2086 - val_binary_accuracy: 0.9709 - val_ROC: 0.5973 - val_PRC: 0.1076 - lr: 1.0000e-06\n", + "\n", + "Epoch 14: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", + "Epoch 14/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2058 - binary_accuracy: 0.9701 - ROC: 0.6580 - PRC: 0.1015 - val_loss: 0.2077 - val_binary_accuracy: 0.9709 - val_ROC: 0.5987 - val_PRC: 0.1079 - lr: 1.0000e-06\n", + "\n", + "Epoch 15: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", + "Epoch 15/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2053 - binary_accuracy: 0.9703 - ROC: 0.6627 - PRC: 0.1046 - val_loss: 0.2068 - val_binary_accuracy: 0.9709 - val_ROC: 0.5977 - val_PRC: 0.1075 - lr: 1.0000e-06\n", + "\n", + "Epoch 16: LearningRateScheduler setting learning rate to 1.0000001111620805e-07.\n", + "Epoch 16/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2052 - binary_accuracy: 0.9700 - ROC: 0.6489 - PRC: 0.1033 - val_loss: 0.2066 - val_binary_accuracy: 0.9709 - val_ROC: 0.5986 - val_PRC: 0.1077 - lr: 1.0000e-07\n", + "\n", + "Epoch 17: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", + "Epoch 17/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2052 - binary_accuracy: 0.9701 - ROC: 0.6592 - PRC: 0.1024 - val_loss: 0.2064 - val_binary_accuracy: 0.9709 - val_ROC: 0.5980 - val_PRC: 0.1076 - lr: 1.0000e-07\n", + "\n", + "Epoch 18: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", + "Epoch 18/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2050 - binary_accuracy: 0.9699 - ROC: 0.6592 - PRC: 0.1021 - val_loss: 0.2063 - val_binary_accuracy: 0.9709 - val_ROC: 0.5982 - val_PRC: 0.1076 - lr: 1.0000e-07\n", + "\n", + "Epoch 19: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", + "Epoch 19/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2051 - binary_accuracy: 0.9700 - ROC: 0.6565 - PRC: 0.1012 - val_loss: 0.2061 - val_binary_accuracy: 0.9709 - val_ROC: 0.5988 - val_PRC: 0.1076 - lr: 1.0000e-07\n", + "\n", + "Epoch 20: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", + "Epoch 20/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9704 - ROC: 0.6535 - PRC: 0.1022 - val_loss: 0.2060 - val_binary_accuracy: 0.9709 - val_ROC: 0.5994 - val_PRC: 0.1076 - lr: 1.0000e-07\n", + "\n", + "Epoch 21: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", + "Epoch 21/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9700 - ROC: 0.6611 - PRC: 0.1035 - val_loss: 0.2061 - val_binary_accuracy: 0.9709 - val_ROC: 0.5990 - val_PRC: 0.1076 - lr: 1.0000e-08\n", + "\n", + "Epoch 22: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", + "Epoch 22/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9702 - ROC: 0.6498 - PRC: 0.1032 - val_loss: 0.2060 - val_binary_accuracy: 0.9708 - val_ROC: 0.5996 - val_PRC: 0.1077 - lr: 1.0000e-08\n", + "\n", + "Epoch 23: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", + "Epoch 23/30\n", + "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9702 - ROC: 0.6671 - PRC: 0.1011 - val_loss: 0.2059 - val_binary_accuracy: 0.9708 - val_ROC: 0.5997 - val_PRC: 0.1079 - lr: 1.0000e-08\n", + "\n", + "Epoch 24: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", + "Epoch 24/30\n", + "41/41 [==============================] - 4s 88ms/step - loss: 0.2049 - binary_accuracy: 0.9701 - ROC: 0.6547 - PRC: 0.1045 - val_loss: 0.2059 - val_binary_accuracy: 0.9708 - val_ROC: 0.5994 - val_PRC: 0.1078 - lr: 1.0000e-08\n", + "\n", + "Epoch 25: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", + "Epoch 25/30\n", + "41/41 [==============================] - 4s 88ms/step - loss: 0.2049 - binary_accuracy: 0.9701 - ROC: 0.6551 - PRC: 0.1050 - val_loss: 0.2059 - val_binary_accuracy: 0.9708 - val_ROC: 0.5996 - val_PRC: 0.1078 - lr: 1.0000e-08\n", + "\n", + "Epoch 26: LearningRateScheduler setting learning rate to 1.000000082740371e-09.\n", + "Epoch 26/30\n", + "41/41 [==============================] - ETA: 0s - loss: 0.2050 - binary_accuracy: 0.9703 - ROC: 0.6498 - PRC: 0.1030" ] } ], "source": [ - "model.fit(X_train, y_train, X_val, y_val)" + "from sklearn.model_selection import StratifiedKFold\n", + "\n", + "skf = StratifiedKFold(n_splits=3)\n", + "for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", + " model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", + " cv_x_train = X_grid[train_index]\n", + " cv_y_train = y_grid[train_index] \n", + " cv_x_test = X_grid[test_index]\n", + " cv_y_test = y_grid[test_index]\n", + " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", + "\n", + " model.fit(cv_x_train, cv_y_train, cv_x_test, cv_y_test)" ] }, { @@ -514,7 +875,8 @@ "metadata": { "accelerator": "GPU", "colab": { - "provenance": [] + "provenance": [], + "machine_shape": "hm" }, "gpuClass": "standard", "kernelspec": { diff --git a/code/models/your_model.py b/code/models/your_model.py index 625f8e4..473315b 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -2,7 +2,7 @@ import tensorflow as tf import numpy as np - + class inception_time_model(ClassificationModel): def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red="yes", model_depth=6, loss="bce", kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary"): super(inception_time_model, self).__init__() @@ -20,7 +20,9 @@ def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_sha def fit(self, X_train, y_train, X_val, y_val): self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, - validation_data=(X_val, y_val), callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)]) + validation_data=(X_val, y_val), + #callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1) + ]) #self.model.save(self.outputfolder +'last_model.h5') def predict(self, X): return self.model.predict(X) @@ -80,11 +82,8 @@ def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0 input_res = x gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x) - if clf == "binary": - output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) - elif clf == "cat" - output_layer = tf.keras.layers.Dense(units=nb_classes,activation='softmax')(gap_layer) - + + output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer) model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), metrics=[tf.keras.metrics.BinaryAccuracy(), @@ -107,7 +106,7 @@ def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0 return model def scheduler(epoch, lr): - if i%5 == 0: + if epoch % 5 == 0: return lr*0.1 else: return lr From e2de13edd68237202993944caacdc6176a872bbb Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Tue, 7 Feb 2023 22:26:50 +0100 Subject: [PATCH 26/51] Add grid search files --- gridsearch_params.csv | 973 +++++++++++++++++++++++++++++++++++++ make_gridsearch_file.ipynb | 236 +++++++++ 2 files changed, 1209 insertions(+) create mode 100644 gridsearch_params.csv create mode 100644 make_gridsearch_file.ipynb diff --git a/gridsearch_params.csv b/gridsearch_params.csv new file mode 100644 index 0000000..65c80d8 --- /dev/null +++ b/gridsearch_params.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)" +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)" +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)" +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)" +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)" +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)" +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)" +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)" +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)" +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)" +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)" +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)" +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)" +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)" +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)" +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)" +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)" +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)" +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)" +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)" +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)" +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)" +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)" +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)" +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)" +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)" +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)" +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)" +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)" +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)" +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)" +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)" +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)" +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)" +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)" +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)" +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)" +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)" +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)" +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)" +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)" +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)" +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)" +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)" +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)" +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)" +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)" +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)" +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)" +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)" +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)" +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)" +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)" +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)" +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)" +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)" +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)" +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)" +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)" +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)" +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)" +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)" +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)" +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)" +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)" +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)" +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)" +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)" +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)" +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)" +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)" +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)" +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)" +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)" +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)" +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)" +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)" +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)" +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)" +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)" +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)" +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)" +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)" +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)" +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)" +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)" +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)" +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)" +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)" +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)" +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)" +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)" +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)" +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)" +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)" +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)" +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)" +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)" +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)" +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)" +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)" +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)" +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)" +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)" +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)" +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)" +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)" +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)" +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)" +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)" +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)" +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)" +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)" +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)" +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)" +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)" +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)" +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)" +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)" +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)" +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)" +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)" +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)" +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)" +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)" +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)" +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)" +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)" +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)" +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)" +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)" +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)" +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)" +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)" +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)" +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)" +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)" +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)" +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)" +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)" +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)" +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)" +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)" +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)" +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)" +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)" +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)" +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)" +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)" +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)" +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)" +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)" +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)" +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)" +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)" +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)" +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)" +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)" +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)" +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)" +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)" +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)" +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)" +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)" +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)" +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)" +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)" +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)" +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)" +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)" +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)" +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)" +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)" +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)" +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)" +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)" +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)" +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)" +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)" +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)" +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)" +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)" +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)" +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)" +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)" +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)" +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)" +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)" +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)" +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)" +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)" +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)" +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)" +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)" +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)" +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)" +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)" +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)" +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)" +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)" +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)" +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)" +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)" +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)" +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)" +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)" +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)" +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)" +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)" +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)" +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)" +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)" +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)" +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)" +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)" +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)" +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)" +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)" +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)" +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)" +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)" +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)" +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)" +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)" +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)" +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)" +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)" +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)" +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)" +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)" +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)" +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)" +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)" +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)" +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)" +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)" +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)" +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)" +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)" +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)" +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)" +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)" +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)" +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)" +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)" +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)" +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)" +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)" +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)" +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)" +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)" +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)" +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)" +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)" +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)" +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)" +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)" +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)" +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)" +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)" +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)" +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)" +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)" +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)" +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)" +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)" +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)" +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)" +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)" +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)" +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)" +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)" +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)" +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)" +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)" +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)" +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)" +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)" +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)" +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)" +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)" +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)" +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)" +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)" +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)" +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)" +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)" +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)" +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)" +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)" +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)" +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)" +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)" +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)" +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)" +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)" +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)" +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)" +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)" +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)" +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)" +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)" +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)" +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)" +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)" +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)" +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)" +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)" +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)" +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)" +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)" +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)" +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)" +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)" +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)" +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)" +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)" +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)" +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)" +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)" +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)" +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)" +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)" +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)" +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)" +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)" +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)" +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)" +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)" +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)" +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)" +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)" +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)" +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)" +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)" +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)" +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)" +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)" +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)" +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)" +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)" +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)" +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)" +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)" +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)" +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)" +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)" +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)" +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)" +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)" +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)" +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)" +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)" +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)" +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)" +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)" +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)" +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)" +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)" +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)" +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)" +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)" +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)" +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)" +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)" +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)" +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)" +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)" +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)" +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)" +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)" +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)" +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)" +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)" +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)" +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)" +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)" +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)" +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)" +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)" +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)" +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)" +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)" +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)" +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)" +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)" +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)" +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)" +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)" +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)" +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)" +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)" +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)" +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)" +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)" +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)" +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)" +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)" +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)" +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)" +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)" +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)" +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)" +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)" +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)" +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)" +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)" +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)" +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)" +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)" +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)" +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)" +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)" +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)" +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)" +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)" +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)" +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)" +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)" +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)" +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)" +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)" +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)" +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)" +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)" +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)" +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)" +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)" +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)" +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)" +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)" +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)" +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)" +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)" +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)" +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)" +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)" +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)" +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)" +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)" +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)" +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)" +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)" +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)" +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)" +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)" +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)" +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)" +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)" +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)" +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)" diff --git a/make_gridsearch_file.ipynb b/make_gridsearch_file.ipynb new file mode 100644 index 0000000..a03f3dd --- /dev/null +++ b/make_gridsearch_file.ipynb @@ -0,0 +1,236 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "_e4S68CJtRn4" + }, + "outputs": [], + "source": [ + "epochs = [15,20,25]\n", + "batch_size = [16, 32, 64]\n", + "init_lr = [0.001, 0.0001, 0.00001]\n", + "lr_red = [\"yes\", \"no\"]\n", + "model_depth = [6, 9, 12]\n", + "loss = [\"bce\", \"wbce\"]\n", + "kernel_size = [(20,10,5), (40,20,10), (60,30,15)]" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd" + ], + "metadata": { + "id": "BM3En7Scuji-" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df = pd.DataFrame({\"epochs\": [], \"batch_size\":[], \"init_lr\": [], \"lr_red\": [], \"model_depth\": [],\"loss\": [], \"kernel_size\": []})" + ], + "metadata": { + "id": "q8ihRunfuWx5" + }, + "execution_count": 11, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49 + }, + "id": "t7cA7I-Yuit3", + "outputId": "89acf5d5-9551-410c-8231-7c670053ed29" + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Empty DataFrame\n", + "Columns: [epochs, batch_size, init_lr, lr_red, model_depth, loss, kernel_size]\n", + "Index: []" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
epochsbatch_sizeinit_lrlr_redmodel_depthlosskernel_size
\n", + "
\n", + " \n", + " \n", + " \n", + "\n", + " \n", + "
\n", + "
\n", + " " + ] + }, + "metadata": {}, + "execution_count": 12 + } + ] + }, + { + "cell_type": "code", + "source": [ + "for epoch in epochs:\n", + " for batch in batch_size:\n", + " for lr_val in init_lr:\n", + " for lr_onoff in lr_red:\n", + " for depth in model_depth:\n", + " for l in loss:\n", + " for ks in kernel_size:\n", + " df = df.append({\"epochs\": epoch, \"batch_size\":batch, \"init_lr\": lr_val, \"lr_red\": lr_onoff, \"model_depth\": depth,\"loss\": l, \"kernel_size\": ks}, ignore_index=True)" + ], + "metadata": { + "id": "piCQhBa8uqGL" + }, + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.to_csv(\"gridsearch_params.csv\", index=False)" + ], + "metadata": { + "id": "qmS2-3hMv0kp" + }, + "execution_count": 18, + "outputs": [] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "0UpdTQaVwgKz" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file From f35b22f971e66a0b87929a60f48e57a5d63dad3a Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 8 Feb 2023 21:26:10 +0100 Subject: [PATCH 27/51] Update My_Finetuning.ipynb --- My_Finetuning.ipynb | 1360 +++++++++++++++++++++++++++++++++++-------- 1 file changed, 1109 insertions(+), 251 deletions(-) diff --git a/My_Finetuning.ipynb b/My_Finetuning.ipynb index 6d45eaa..ba65262 100644 --- a/My_Finetuning.ipynb +++ b/My_Finetuning.ipynb @@ -18,13 +18,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0L-abXib6HkK", - "outputId": "3dd153ea-7535-4e1d-d5ad-28e5f72a6854" + "outputId": "9195fc47-5a83-4da7-d9de-6380794e0780" }, "outputs": [ { @@ -32,47 +32,43 @@ "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting wget\n", - " Downloading wget-3.2.zip (10 kB)\n", - " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "Collecting wfdb\n", - " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "Requirement already satisfied: wget in /usr/local/lib/python3.8/dist-packages (3.2)\n", + "Requirement already satisfied: wfdb in /usr/local/lib/python3.8/dist-packages (4.1.0)\n", + "Collecting tensorflow-addons\n", + " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m16.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", + "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", - "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Building wheels for collected packages: wget\n", - " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=6820786d45ca6ae353e9bfa386ce67f245a61ee785c721943cf032250b7f3e13\n", - " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", - "Successfully built wget\n", - "Installing collected packages: wget, wfdb\n", - "Successfully installed wfdb-4.1.0 wget-3.2\n" + "Installing collected packages: tensorflow-addons\n", + "Successfully installed tensorflow-addons-0.19.0\n" ] } ], "source": [ - "!pip install wget wfdb" + "!pip install wget wfdb tensorflow-addons" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": { "id": "Jqxss_rS6Jxn" }, @@ -87,34 +83,36 @@ "import pandas as pd\n", "import seaborn as sns\n", "from sklearn.metrics import confusion_matrix\n", - "import pickle" + "import pickle\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.model_selection import StratifiedKFold" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AcjcSuO06o-6", - "outputId": "007d58e0-f461-407b-9359-cd2f6980c266" + "outputId": "be744e1b-2e40-4e12-f735-0182402c6108" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-01-21 17:17:21-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2023-02-08 08:07:05-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 1.73MB/s in 16m 32s \n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 1.76MB/s in 14m 26s \n", "\n", - "2023-01-21 17:33:54 (1.77 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "2023-02-08 08:21:31 (2.03 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", "\n" ] } @@ -131,13 +129,13 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3Qv9hVm-5wyi", - "outputId": "2f8465bf-bf9e-46f1-a200-e4c108d09d49" + "outputId": "0462259a-3378-4590-fe3c-441eea0a5f93" }, "outputs": [ { @@ -147,10 +145,10 @@ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", " Downloading GitPython-3.1.30-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m9.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hCollecting smmap<6,>=3.0.1\n", " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", "Installing collected packages: smmap, gitdb, GitPython\n", @@ -165,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "id": "u4T-c5KI5y2W" }, @@ -177,13 +175,13 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "r8hm-j6751kC", - "outputId": "6d02001d-2b8f-4692-e4f2-100ed12ae6aa" + "outputId": "180a7b25-f676-4462-8d74-f4bc9507cb32" }, "outputs": [ { @@ -203,13 +201,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": { "id": "SRUZICm6562J", "colab": { "base_uri": "https://localhost:8080/" }, - "outputId": "66067ee4-5c80-41a4-f281-96122f1d2d46" + "outputId": "b88ccb7c-79cd-4b5a-90f7-e030de2f6fef" }, "outputs": [ { @@ -229,22 +227,15 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "CmW7xaR_5oSf", - "outputId": "4ea3a0ed-8514-42bf-91af-c77fd45465ea" + "outputId": "39005e7c-389c-41a3-9c4e-a5ea436c04be" }, "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 21837/21837 [00:51<00:00, 427.90it/s]\n" - ] - }, { "output_type": "execute_result", "data": { @@ -253,7 +244,7 @@ ] }, "metadata": {}, - "execution_count": 8 + "execution_count": 172 } ], "source": [ @@ -297,13 +288,13 @@ ], "metadata": { "id": "DIKpffEJMllK", - "outputId": "b3b59962-293b-45d2-9d6c-752c690d9145", + "outputId": "cf3ae66c-a95e-4670-ff05-64ce78602e27", "colab": { "base_uri": "https://localhost:8080/", "height": 265 } }, - "execution_count": 9, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -329,7 +320,7 @@ "metadata": { "id": "-a6LeAwqOm_i" }, - "execution_count": 10, + "execution_count": null, "outputs": [] }, { @@ -339,12 +330,12 @@ ], "metadata": { "id": "QW5xSWezMWo-", - "outputId": "18dd0833-4014-4926-e271-3caf856786b4", + "outputId": "c723adea-2161-4f0b-fd64-90ef25f84106", "colab": { "base_uri": "https://localhost:8080/" } }, - "execution_count": 11, + "execution_count": null, "outputs": [ { "output_type": "execute_result", @@ -354,7 +345,7 @@ ] }, "metadata": {}, - "execution_count": 11 + "execution_count": 182 } ] }, @@ -366,13 +357,13 @@ ], "metadata": { "id": "fDz352LpQNds", - "outputId": "e37bb003-c3a2-4fe7-ff71-8d09e8742b4c", + "outputId": "f0194fae-4695-4aa8-e7cc-a3cd8773e042", "colab": { "base_uri": "https://localhost:8080/", "height": 265 } }, - "execution_count": 12, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -380,7 +371,7 @@ "text/plain": [ "
" ], - "image/png": "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\n" + "image/png": "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\n" }, "metadata": { "needs_background": "light" @@ -528,18 +519,181 @@ "metadata": { "id": "kg7-fD1ocLBB" }, - "execution_count": 33, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "model.model.loss" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gAY6-vMvAZmH", + "outputId": "f52575d5-5e99-44f4-cd34-22ed4c315dff" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 210 + } + ] + }, + { + "cell_type": "code", + "source": [ + "from github_repo.code.models.base_model import ClassificationModel\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "import tensorflow_addons as tfa\n", + "\n", + " \n", + "class inception_time_model(ClassificationModel):\n", + " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", + " super(inception_time_model, self).__init__()\n", + " self.name = name\n", + " self.n_classes = n_classes\n", + " self.sampling_frequency = sampling_frequency\n", + " self.outputfolder = outputfolder\n", + " self.input_shape = input_shape\n", + " if loss == \"bce\":\n", + " self.loss = tf.keras.losses.BinaryCrossentropy()\n", + " elif loss == \"wbce\":\n", + " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", + " self.model = build_modelol((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", + " self.epoch = epoch\n", + " self.batch_size = batch_size\n", + " self.lr_red = lr_red\n", + " self.verbose = verbose\n", + "\n", + " \n", + " \n", + "\n", + " def fit(self, X_train, y_train, X_val, y_val):\n", + "\n", + " if self.lr_red == \"no\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose)\n", + " elif self.lr_red == \"yes\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose,\n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", + " else:\n", + " print(\"Error: wrong lr_red argument\")\n", + "\n", + " #self.model.save(self.outputfolder +'last_model.h5')\n", + " def predict(self, X):\n", + " return self.model.predict(X)\n", + "\n", + "\n", + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", + " strides=stride, padding='same', activation=activation, use_bias=False)(\n", + " input_inception))\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", + "\n", + " conv_list.append(conv_6)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='same', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + "\n", + " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_modelol(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=loss,\n", + " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\",\n", + " multi_label=True,\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\",\n", + " multi_label=True,\n", + " )\n", + " ])\n", + " print(\"Inception model built.\")\n", + " return model\n", + "\n", + "def scheduler(epoch, lr):\n", + " if epoch % 5 == 0:\n", + " return lr*0.1\n", + " else:\n", + " return lr\n" + ], + "metadata": { + "id": "_sdQPeYY_1_o" + }, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cEx-BdLJ5oSh", - "outputId": "83a21221-c5e0-492b-c90a-61830f336888" + "outputId": "0d90955e-0671-49ee-9485-4c3a695c041a" }, "outputs": [ { @@ -551,7 +705,7 @@ } ], "source": [ - "from github_repo.code.models.your_model import inception_time_model\n", + "#from github_repo.code.models.your_model import inception_time_model\n", "\n", "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", "\n", @@ -599,7 +753,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "id": "uqSSsK_V5oSh" }, @@ -637,7 +791,7 @@ "metadata": { "id": "lOSQURgFUycV" }, - "execution_count": 25, + "execution_count": null, "outputs": [] }, { @@ -656,219 +810,923 @@ "execution_count": null, "metadata": { "colab": { - "base_uri": "https://localhost:8080/" + "base_uri": "https://localhost:8080/", + "height": 1000 }, "id": "MxzCOgaP5oSi", - "outputId": "33ec21c7-4e2e-4c74-86b2-c2ca4e4a0f07" + "outputId": "4ba7077e-2803-46e3-eca4-a9ef40b945fc" }, "outputs": [ { + "metadata": { + "tags": null + }, + "name": "stdout", "output_type": "stream", + "text": [ + "Running gridsearch nr 0 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, "name": "stderr", + "output_type": "stream", "text": [ "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", " warnings.warn(\n" ] }, { - "output_type": "stream", + "metadata": { + "tags": null + }, "name": "stdout", + "output_type": "stream", "text": [ "Inception model built.\n", - "\n", - "Epoch 1: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", - "Epoch 1/30\n", - "41/41 [==============================] - 16s 115ms/step - loss: 0.6748 - binary_accuracy: 0.5771 - ROC: 0.5002 - PRC: 0.0492 - val_loss: 0.7851 - val_binary_accuracy: 0.5439 - val_ROC: 0.4735 - val_PRC: 0.0526 - lr: 1.0000e-04\n", - "\n", - "Epoch 2: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", - "Epoch 2/30\n", - "41/41 [==============================] - 4s 89ms/step - loss: 0.5111 - binary_accuracy: 0.8372 - ROC: 0.5278 - PRC: 0.0672 - val_loss: 0.5755 - val_binary_accuracy: 0.8213 - val_ROC: 0.5248 - val_PRC: 0.0599 - lr: 1.0000e-04\n", - "\n", - "Epoch 3: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", - "Epoch 3/30\n", - "41/41 [==============================] - 4s 89ms/step - loss: 0.3971 - binary_accuracy: 0.9104 - ROC: 0.5705 - PRC: 0.0735 - val_loss: 0.4401 - val_binary_accuracy: 0.9192 - val_ROC: 0.5569 - val_PRC: 0.0774 - lr: 1.0000e-04\n", - "\n", - "Epoch 4: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", - "Epoch 4/30\n", - "41/41 [==============================] - 4s 89ms/step - loss: 0.3128 - binary_accuracy: 0.9483 - ROC: 0.5890 - PRC: 0.0767 - val_loss: 0.3574 - val_binary_accuracy: 0.9609 - val_ROC: 0.5774 - val_PRC: 0.0905 - lr: 1.0000e-04\n", - "\n", - "Epoch 5: LearningRateScheduler setting learning rate to 0.00010000000474974513.\n", - "Epoch 5/30\n", - "41/41 [==============================] - 4s 91ms/step - loss: 0.2521 - binary_accuracy: 0.9613 - ROC: 0.6225 - PRC: 0.0881 - val_loss: 0.2830 - val_binary_accuracy: 0.9705 - val_ROC: 0.5914 - val_PRC: 0.0959 - lr: 1.0000e-04\n", - "\n", - "Epoch 6: LearningRateScheduler setting learning rate to 1.0000000474974514e-05.\n", - "Epoch 6/30\n", - "41/41 [==============================] - 4s 89ms/step - loss: 0.2254 - binary_accuracy: 0.9682 - ROC: 0.6402 - PRC: 0.0982 - val_loss: 0.2577 - val_binary_accuracy: 0.9708 - val_ROC: 0.5949 - val_PRC: 0.0995 - lr: 1.0000e-05\n", - "\n", - "Epoch 7: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", - "Epoch 7/30\n", - "41/41 [==============================] - 4s 88ms/step - loss: 0.2212 - binary_accuracy: 0.9687 - ROC: 0.6472 - PRC: 0.0993 - val_loss: 0.2411 - val_binary_accuracy: 0.9709 - val_ROC: 0.5957 - val_PRC: 0.1064 - lr: 1.0000e-05\n", - "\n", - "Epoch 8: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", - "Epoch 8/30\n", - "41/41 [==============================] - 4s 88ms/step - loss: 0.2172 - binary_accuracy: 0.9690 - ROC: 0.6455 - PRC: 0.0997 - val_loss: 0.2295 - val_binary_accuracy: 0.9710 - val_ROC: 0.5975 - val_PRC: 0.1066 - lr: 1.0000e-05\n", - "\n", - "Epoch 9: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", - "Epoch 9/30\n", - "41/41 [==============================] - 4s 88ms/step - loss: 0.2132 - binary_accuracy: 0.9695 - ROC: 0.6519 - PRC: 0.0994 - val_loss: 0.2213 - val_binary_accuracy: 0.9711 - val_ROC: 0.5995 - val_PRC: 0.1070 - lr: 1.0000e-05\n", - "\n", - "Epoch 10: LearningRateScheduler setting learning rate to 1.0000000656873453e-05.\n", - "Epoch 10/30\n", - "41/41 [==============================] - 4s 88ms/step - loss: 0.2092 - binary_accuracy: 0.9698 - ROC: 0.6604 - PRC: 0.1018 - val_loss: 0.2139 - val_binary_accuracy: 0.9713 - val_ROC: 0.5986 - val_PRC: 0.1079 - lr: 1.0000e-05\n", - "\n", - "Epoch 11: LearningRateScheduler setting learning rate to 1.0000000656873453e-06.\n", - "Epoch 11/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2070 - binary_accuracy: 0.9700 - ROC: 0.6595 - PRC: 0.1022 - val_loss: 0.2116 - val_binary_accuracy: 0.9711 - val_ROC: 0.6005 - val_PRC: 0.1077 - lr: 1.0000e-06\n", - "\n", - "Epoch 12: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", - "Epoch 12/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2067 - binary_accuracy: 0.9701 - ROC: 0.6518 - PRC: 0.1012 - val_loss: 0.2099 - val_binary_accuracy: 0.9710 - val_ROC: 0.6023 - val_PRC: 0.1082 - lr: 1.0000e-06\n", - "\n", - "Epoch 13: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", - "Epoch 13/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2062 - binary_accuracy: 0.9699 - ROC: 0.6559 - PRC: 0.1020 - val_loss: 0.2086 - val_binary_accuracy: 0.9709 - val_ROC: 0.5973 - val_PRC: 0.1076 - lr: 1.0000e-06\n", - "\n", - "Epoch 14: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", - "Epoch 14/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2058 - binary_accuracy: 0.9701 - ROC: 0.6580 - PRC: 0.1015 - val_loss: 0.2077 - val_binary_accuracy: 0.9709 - val_ROC: 0.5987 - val_PRC: 0.1079 - lr: 1.0000e-06\n", - "\n", - "Epoch 15: LearningRateScheduler setting learning rate to 1.0000001111620804e-06.\n", - "Epoch 15/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2053 - binary_accuracy: 0.9703 - ROC: 0.6627 - PRC: 0.1046 - val_loss: 0.2068 - val_binary_accuracy: 0.9709 - val_ROC: 0.5977 - val_PRC: 0.1075 - lr: 1.0000e-06\n", - "\n", - "Epoch 16: LearningRateScheduler setting learning rate to 1.0000001111620805e-07.\n", - "Epoch 16/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2052 - binary_accuracy: 0.9700 - ROC: 0.6489 - PRC: 0.1033 - val_loss: 0.2066 - val_binary_accuracy: 0.9709 - val_ROC: 0.5986 - val_PRC: 0.1077 - lr: 1.0000e-07\n", - "\n", - "Epoch 17: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", - "Epoch 17/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2052 - binary_accuracy: 0.9701 - ROC: 0.6592 - PRC: 0.1024 - val_loss: 0.2064 - val_binary_accuracy: 0.9709 - val_ROC: 0.5980 - val_PRC: 0.1076 - lr: 1.0000e-07\n", - "\n", - "Epoch 18: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", - "Epoch 18/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2050 - binary_accuracy: 0.9699 - ROC: 0.6592 - PRC: 0.1021 - val_loss: 0.2063 - val_binary_accuracy: 0.9709 - val_ROC: 0.5982 - val_PRC: 0.1076 - lr: 1.0000e-07\n", - "\n", - "Epoch 19: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", - "Epoch 19/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2051 - binary_accuracy: 0.9700 - ROC: 0.6565 - PRC: 0.1012 - val_loss: 0.2061 - val_binary_accuracy: 0.9709 - val_ROC: 0.5988 - val_PRC: 0.1076 - lr: 1.0000e-07\n", - "\n", - "Epoch 20: LearningRateScheduler setting learning rate to 1.000000082740371e-07.\n", - "Epoch 20/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9704 - ROC: 0.6535 - PRC: 0.1022 - val_loss: 0.2060 - val_binary_accuracy: 0.9709 - val_ROC: 0.5994 - val_PRC: 0.1076 - lr: 1.0000e-07\n", - "\n", - "Epoch 21: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", - "Epoch 21/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9700 - ROC: 0.6611 - PRC: 0.1035 - val_loss: 0.2061 - val_binary_accuracy: 0.9709 - val_ROC: 0.5990 - val_PRC: 0.1076 - lr: 1.0000e-08\n", - "\n", - "Epoch 22: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", - "Epoch 22/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9702 - ROC: 0.6498 - PRC: 0.1032 - val_loss: 0.2060 - val_binary_accuracy: 0.9708 - val_ROC: 0.5996 - val_PRC: 0.1077 - lr: 1.0000e-08\n", - "\n", - "Epoch 23: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", - "Epoch 23/30\n", - "41/41 [==============================] - 4s 87ms/step - loss: 0.2049 - binary_accuracy: 0.9702 - ROC: 0.6671 - PRC: 0.1011 - val_loss: 0.2059 - val_binary_accuracy: 0.9708 - val_ROC: 0.5997 - val_PRC: 0.1079 - lr: 1.0000e-08\n", - "\n", - "Epoch 24: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", - "Epoch 24/30\n", - "41/41 [==============================] - 4s 88ms/step - loss: 0.2049 - binary_accuracy: 0.9701 - ROC: 0.6547 - PRC: 0.1045 - val_loss: 0.2059 - val_binary_accuracy: 0.9708 - val_ROC: 0.5994 - val_PRC: 0.1078 - lr: 1.0000e-08\n", - "\n", - "Epoch 25: LearningRateScheduler setting learning rate to 1.000000082740371e-08.\n", - "Epoch 25/30\n", - "41/41 [==============================] - 4s 88ms/step - loss: 0.2049 - binary_accuracy: 0.9701 - ROC: 0.6551 - PRC: 0.1050 - val_loss: 0.2059 - val_binary_accuracy: 0.9708 - val_ROC: 0.5996 - val_PRC: 0.1078 - lr: 1.0000e-08\n", - "\n", - "Epoch 26: LearningRateScheduler setting learning rate to 1.000000082740371e-09.\n", - "Epoch 26/30\n", - "41/41 [==============================] - ETA: 0s - loss: 0.2050 - binary_accuracy: 0.9703 - ROC: 0.6498 - PRC: 0.1030" + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.785309 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 17ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.804568 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 17ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.791498 (AUROC score)\n", + "Running gridsearch nr 1 of 972...\n" ] - } - ], - "source": [ - "from sklearn.model_selection import StratifiedKFold\n", - "\n", - "skf = StratifiedKFold(n_splits=3)\n", - "for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", - " model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", - " cv_x_train = X_grid[train_index]\n", - " cv_y_train = y_grid[train_index] \n", - " cv_x_test = X_grid[test_index]\n", - " cv_y_test = y_grid[test_index]\n", - " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", - "\n", - " model.fit(cv_x_train, cv_y_train, cv_x_test, cv_y_test)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kvnNlyCX5oSi" - }, - "source": [ - "# Evaluate model on validation data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "m1rgPocD5oSi", - "outputId": "6d91d6ab-7d00-4433-cdbd-2d7fd083cdaa" - }, - "outputs": [ + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, { + "metadata": { + "tags": null + }, "name": "stdout", "output_type": "stream", "text": [ - "aggregating predictions...\n" + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.81849 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.820807 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.821093 (AUROC score)\n", + "Running gridsearch nr 2 of 972...\n" ] }, { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
macro_aucFmax
00.9314580.827961
\n", - "
" - ], - "text/plain": [ - " macro_auc Fmax\n", - "0 0.931458 0.827961" - ] + "metadata": { + "tags": null }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.83337 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.821804 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.837105 (AUROC score)\n", + "Running gridsearch nr 3 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 17ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.773381 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.748142 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.726756 (AUROC score)\n", + "Running gridsearch nr 4 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.820982 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.778317 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.819262 (AUROC score)\n", + "Running gridsearch nr 5 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.824672 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.789657 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.812811 (AUROC score)\n", + "Running gridsearch nr 6 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.821719 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.81206 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.794849 (AUROC score)\n", + "Running gridsearch nr 7 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 28ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.836565 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 28ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.803726 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 28ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.817623 (AUROC score)\n", + "Running gridsearch nr 8 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.834711 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.805836 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.825461 (AUROC score)\n", + "Running gridsearch nr 9 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.796138 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.749337 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.804074 (AUROC score)\n", + "Running gridsearch nr 10 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 32ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.836407 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 28ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.806131 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 28ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.793941 (AUROC score)\n", + "Running gridsearch nr 11 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.805754 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.79209 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.808169 (AUROC score)\n", + "Running gridsearch nr 12 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 35ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.816178 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 35ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.78194 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 35ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.81159 (AUROC score)\n", + "Running gridsearch nr 13 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 2s 38ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.82238 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 38ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.825624 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 38ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.807163 (AUROC score)\n", + "Running gridsearch nr 14 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 2s 39ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.823611 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 39ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.799625 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 39ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.829105 (AUROC score)\n", + "Running gridsearch nr 15 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 2s 35ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.775262 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 36ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.758773 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 35ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.803473 (AUROC score)\n", + "Running gridsearch nr 16 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 2s 38ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.823635 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 38ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.776986 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 38ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.804917 (AUROC score)\n", + "Running gridsearch nr 17 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 2s 39ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.816949 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 39ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.772254 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 39ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.82311 (AUROC score)\n", + "Running gridsearch nr 18 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 2s 17ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.88794 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.86945 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.888054 (AUROC score)\n", + "Running gridsearch nr 19 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.895454 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.870784 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.88359 (AUROC score)\n", + "Running gridsearch nr 20 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.87756 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.879005 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 20ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.879999 (AUROC score)\n", + "Running gridsearch nr 21 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.882987 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.869587 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 18ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.883509 (AUROC score)\n", + "Running gridsearch nr 22 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.866746 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.870394 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.886791 (AUROC score)\n", + "Running gridsearch nr 23 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.876125 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 20ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.860956 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 19ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.875806 (AUROC score)\n", + "Running gridsearch nr 24 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.888203 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 26ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.881306 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 27ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.887909 (AUROC score)\n", + "Running gridsearch nr 25 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 28ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.882829 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 2s 28ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.880861 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 28ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.895306 (AUROC score)\n", + "Running gridsearch nr 26 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.880683 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 29ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.879229 (AUROC score)\n", + "Inception model built.\n" + ] + }, + { + "output_type": "error", + "ename": "KeyboardInterrupt", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0mcv_x_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcv_x_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpreprocess_signals\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_x_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcv_x_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_x_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv_y_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv_x_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv_y_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0my_hat_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_x_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0mscore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate_experiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcv_y_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_y_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my_hat_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_hat_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X_train, y_train, X_val, y_val)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr_red\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"no\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n\u001b[0m\u001b[1;32m 32\u001b[0m validation_data=(X_val, y_val), verbose=self.verbose)\n\u001b[1;32m 33\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr_red\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"yes\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 65\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1407\u001b[0m _r=1):\n\u001b[1;32m 1408\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1409\u001b[0;31m \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1410\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1411\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 151\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 913\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 915\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 916\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 917\u001b[0m \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 961\u001b[0m \u001b[0;31m# This is the first call of __call__, so we have to initialize.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 962\u001b[0m \u001b[0minitializers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 963\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0madd_initializers_to\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minitializers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 964\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 965\u001b[0m \u001b[0;31m# At this point we know that the initialization is complete (or less\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_initialize\u001b[0;34m(self, args, kwds, add_initializers_to)\u001b[0m\n\u001b[1;32m 783\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_graph_deleter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFunctionDeleter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lifted_initializer_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 784\u001b[0m self._concrete_stateful_fn = (\n\u001b[0;32m--> 785\u001b[0;31m self._stateful_fn._get_concrete_function_internal_garbage_collected( # pylint: disable=protected-access\n\u001b[0m\u001b[1;32m 786\u001b[0m *args, **kwds))\n\u001b[1;32m 787\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_get_concrete_function_internal_garbage_collected\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2478\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2479\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2480\u001b[0;31m \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2481\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2482\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_maybe_define_function\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 2709\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcache_key\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_placeholder_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2710\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2711\u001b[0;31m \u001b[0mgraph_function\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_graph_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2712\u001b[0m self._function_cache.add(cache_key, cache_key_deletion_observer,\n\u001b[1;32m 2713\u001b[0m graph_function)\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_create_graph_function\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 2625\u001b[0m \u001b[0marg_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbase_arg_names\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmissing_arg_names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2626\u001b[0m graph_function = ConcreteFunction(\n\u001b[0;32m-> 2627\u001b[0;31m func_graph_module.func_graph_from_py_func(\n\u001b[0m\u001b[1;32m 2628\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2629\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_python_function\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mfunc_graph_from_py_func\u001b[0;34m(name, python_func, args, kwargs, signature, func_graph, autograph, autograph_options, add_control_dependencies, arg_names, op_return_value, collections, capture_by_value, acd_record_initial_resource_uses)\u001b[0m\n\u001b[1;32m 1139\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moriginal_func\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_decorator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munwrap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpython_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1140\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1141\u001b[0;31m \u001b[0mfunc_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpython_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfunc_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfunc_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1143\u001b[0m \u001b[0;31m# invariant: `func_outputs` contains only Tensors, CompositeTensors,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36mwrapped_fn\u001b[0;34m(*args, **kwds)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[0;31m# the function a weak reference to itself to avoid a reference cycle.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcompile_with_xla\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 677\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mweak_wrapped_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__wrapped__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 678\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mautograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1114\u001b[0m \u001b[0;31m# TODO(mdan): Push this block higher in tf.function's call stack.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1115\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1116\u001b[0;31m return autograph.converted_call(\n\u001b[0m\u001b[1;32m 1117\u001b[0m \u001b[0moriginal_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1118\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mconverted_call\u001b[0;34m(f, args, kwargs, caller_fn_scope, options)\u001b[0m\n\u001b[1;32m 437\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 438\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 439\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconverted_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meffective_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 440\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 441\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconverted_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meffective_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mtf__train_function\u001b[0;34m(iterator)\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mdo_return\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mretval_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconverted_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_function\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfscope\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mdo_return\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mconverted_call\u001b[0;34m(f, args, kwargs, caller_fn_scope, options)\u001b[0m\n\u001b[1;32m 375\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_requested\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mconversion\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_allowlisted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_call_unconverted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 378\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[0;31m# internal_convert_user_code is for example turned off when issuing a dynamic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36m_call_unconverted\u001b[0;34m(f, args, kwargs, options, update_cache)\u001b[0m\n\u001b[1;32m 457\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 458\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 459\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mstep_function\u001b[0;34m(model, iterator)\u001b[0m\n\u001b[1;32m 1038\u001b[0m run_step, jit_compile=True, reduce_retracing=True)\n\u001b[1;32m 1039\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1040\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistribute_strategy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1041\u001b[0m outputs = reduce_per_replica(\n\u001b[1;32m 1042\u001b[0m outputs, self.distribute_strategy, reduction='first')\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 1310\u001b[0m fn = autograph.tf_convert(\n\u001b[1;32m 1311\u001b[0m fn, autograph_ctx.control_status_ctx(), convert_by_default=False)\n\u001b[0;32m-> 1312\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_extended\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1313\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1314\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36mcall_for_each_replica\u001b[0;34m(self, fn, args, kwargs)\u001b[0m\n\u001b[1;32m 2886\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2887\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_container_strategy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2888\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2889\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2890\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_call_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36m_call_for_each_replica\u001b[0;34m(self, fn, args, kwargs)\u001b[0m\n\u001b[1;32m 3687\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_call_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3688\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mReplicaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_container_strategy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreplica_id_in_sync_group\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3689\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3690\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3691\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_reduce_to\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdestinations\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 687\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 688\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mconversion_ctx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 689\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mconverted_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 690\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pylint:disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 691\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ag_error_metadata'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mconverted_call\u001b[0;34m(f, args, kwargs, caller_fn_scope, options)\u001b[0m\n\u001b[1;32m 375\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_requested\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mconversion\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_allowlisted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_call_unconverted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 378\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[0;31m# internal_convert_user_code is for example turned off when issuing a dynamic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36m_call_unconverted\u001b[0;34m(f, args, kwargs, options, update_cache)\u001b[0m\n\u001b[1;32m 456\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 457\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 458\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 459\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mrun_step\u001b[0;34m(data)\u001b[0m\n\u001b[1;32m 1028\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1029\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrun_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1030\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1031\u001b[0m \u001b[0;31m# Ensure counter is updated only if `train_step` succeeds.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1032\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontrol_dependencies\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_minimum_control_deps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mtrain_step\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 891\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_target_and_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 892\u001b[0m \u001b[0;31m# Run backwards pass.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 893\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mminimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrainable_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 894\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_metrics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 895\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/optimizer_v2.py\u001b[0m in \u001b[0;36mminimize\u001b[0;34m(self, loss, var_list, grad_loss, name, tape)\u001b[0m\n\u001b[1;32m 535\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 536\u001b[0m \"\"\"\n\u001b[0;32m--> 537\u001b[0;31m grads_and_vars = self._compute_gradients(\n\u001b[0m\u001b[1;32m 538\u001b[0m loss, var_list=var_list, grad_loss=grad_loss, tape=tape)\n\u001b[1;32m 539\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrads_and_vars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/optimizer_v2.py\u001b[0m in \u001b[0;36m_compute_gradients\u001b[0;34m(self, loss, var_list, grad_loss, tape)\u001b[0m\n\u001b[1;32m 588\u001b[0m \u001b[0mvar_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 589\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/gradients\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 590\u001b[0;31m \u001b[0mgrads_and_vars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 591\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 592\u001b[0m self._assert_valid_dtypes([\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/optimizer_v2.py\u001b[0m in \u001b[0;36m_get_gradients\u001b[0;34m(self, tape, loss, var_list, grad_loss)\u001b[0m\n\u001b[1;32m 469\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_get_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_loss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m \u001b[0;34m\"\"\"Called in `minimize` to compute gradients from loss.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 471\u001b[0;31m \u001b[0mgrads\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 472\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 473\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36mgradient\u001b[0;34m(self, target, sources, output_gradients, unconnected_gradients)\u001b[0m\n\u001b[1;32m 1098\u001b[0m for x in output_gradients]\n\u001b[1;32m 1099\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1100\u001b[0;31m flat_grad = imperative_grad.imperative_grad(\n\u001b[0m\u001b[1;32m 1101\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1102\u001b[0m \u001b[0mflat_targets\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/imperative_grad.py\u001b[0m in \u001b[0;36mimperative_grad\u001b[0;34m(tape, target, sources, output_gradients, sources_raw, unconnected_gradients)\u001b[0m\n\u001b[1;32m 65\u001b[0m \"Unknown value for unconnected_gradients: %r\" % unconnected_gradients)\n\u001b[1;32m 66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m return pywrap_tfe.TFE_Py_TapeGradient(\n\u001b[0m\u001b[1;32m 68\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36m_gradient_function\u001b[0;34m(op_name, attr_tuple, num_inputs, inputs, outputs, out_grads, skip_input_indices, forward_pass_name_scope)\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0mgradient_name_scope\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mforward_pass_name_scope\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgradient_name_scope\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 157\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 158\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/ops/nn_grad.py\u001b[0m in \u001b[0;36m_MaxPoolGrad\u001b[0;34m(op, grad)\u001b[0m\n\u001b[1;32m 672\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRegisterGradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"MaxPool\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 673\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_MaxPoolGrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 674\u001b[0;31m return gen_nn_ops.max_pool_grad(\n\u001b[0m\u001b[1;32m 675\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/ops/gen_nn_ops.py\u001b[0m in \u001b[0;36mmax_pool_grad\u001b[0;34m(orig_input, orig_output, grad, ksize, strides, padding, explicit_paddings, data_format, name)\u001b[0m\n\u001b[1;32m 5839\u001b[0m \u001b[0mdata_format\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"NHWC\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5840\u001b[0m \u001b[0mdata_format\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_execute\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_str\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_format\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"data_format\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5841\u001b[0;31m _, _, _op, _outputs = _op_def_library._apply_op_helper(\n\u001b[0m\u001b[1;32m 5842\u001b[0m \u001b[0;34m\"MaxPoolGrad\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morig_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morig_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morig_output\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morig_output\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5843\u001b[0m \u001b[0mgrad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mksize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstrides\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstrides\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_apply_op_helper\u001b[0;34m(op_type_name, name, **keywords)\u001b[0m\n\u001b[1;32m 782\u001b[0m _ExtractRemainingAttrs(op_type_name, op_def, keywords,\n\u001b[1;32m 783\u001b[0m default_type_attr_map, attrs)\n\u001b[0;32m--> 784\u001b[0;31m \u001b[0m_ExtractAttrProto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop_type_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr_protos\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 785\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mattrs\u001b[0m \u001b[0;31m# attrs is no longer authoritative, use attr_protos instead\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 786\u001b[0m _ExtractOutputStructure(op_type_name, op_def, attr_protos,\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_ExtractAttrProto\u001b[0;34m(op_type_name, op_def, attrs, attr_protos)\u001b[0m\n\u001b[1;32m 341\u001b[0m \u001b[0m_SatisfiesIntMinimumConstraint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattr_value\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_type_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 342\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"type\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m \u001b[0m_SatisfiesTypeConstraint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattr_value\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 344\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"list(type)\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mattr_value\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_SatisfiesTypeConstraint\u001b[0;34m(dtype, attr_def, param_name)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHasField\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"allowed_values\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0mallowed_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallowed_values\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mallowed_values\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\", \"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m raise TypeError(\n", + "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHasField\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"allowed_values\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0mallowed_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallowed_values\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mallowed_values\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\", \"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m raise TypeError(\n", + "\u001b[0;31mKeyboardInterrupt\u001b[0m: " + ] + } + ], + "source": [ + "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", + "df_grid = pd.read_csv(\"/content/gridsearch_params.csv\")\n", + "df_score = pd.read_csv(\"/content/gridsearch_scores.csv\")\n", + "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", + "init_rows = df_score.shape[0]\n", + "\n", + "for gsr in range(gs_left):\n", + " gsr = gsr + init_rows #if previous gridsearch results exists\n", + " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", + " auc_score = []\n", + " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", + " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", + " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", + " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", + " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", + " cv_x_train = X_grid[train_index]\n", + " cv_y_train = y_grid[train_index] \n", + " cv_x_test = X_grid[test_index]\n", + " cv_y_test = y_grid[test_index]\n", + " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", + "\n", + " model.fit(cv_x_train, cv_y_train, cv_x_test, cv_y_test)\n", + " y_hat_test = model.predict(cv_x_test)\n", + " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", + " auc_score.append(score)\n", + " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", + " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", + " df_score=df_score.append(df_grid.loc[gsr])\n", + "df_score.to_csv(\"gridsearch_scores_updated.csv\", index=False) " + ] + }, + { + "cell_type": "code", "source": [ - "y_val_pred = model.predict(X_val)\n", - "utils.evaluate_experiment(y_val, y_val_pred)" + "df_score.to_csv(\"gridsearch_scores_updated.csv\", index=False) " + ], + "metadata": { + "id": "P3NeuYETgz1E" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kvnNlyCX5oSi" + }, + "source": [ + "# Evaluate model on validation data" ] } ], From 9284812ba03a134459092eb2d61924c9ccb71a3e Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 8 Feb 2023 21:54:57 +0100 Subject: [PATCH 28/51] Create My_Finetuning2.ipynb --- My_Finetuning2.ipynb | 830 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 830 insertions(+) create mode 100644 My_Finetuning2.ipynb diff --git a/My_Finetuning2.ipynb b/My_Finetuning2.ipynb new file mode 100644 index 0000000..ae90616 --- /dev/null +++ b/My_Finetuning2.ipynb @@ -0,0 +1,830 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "IG6fwukq5oSe" + }, + "source": [ + "# Load your data\n", + "\n", + "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", + "\n", + "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", + "\n", + "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", + "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0L-abXib6HkK", + "outputId": "2cbd6d86-7440-4d5d-cd53-7220ea7017da" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: wget in /usr/local/lib/python3.8/dist-packages (3.2)\n", + "Requirement already satisfied: wfdb in /usr/local/lib/python3.8/dist-packages (4.1.0)\n", + "Collecting tensorflow-addons\n", + " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m38.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", + "Installing collected packages: tensorflow-addons\n", + "Successfully installed tensorflow-addons-0.19.0\n" + ] + } + ], + "source": [ + "!pip install wget wfdb tensorflow-addons" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "Jqxss_rS6Jxn" + }, + "outputs": [], + "source": [ + "import wget\n", + "import numpy as np\n", + "import os\n", + "import zipfile\n", + "import tensorflow as tf\n", + "from sklearn.utils.class_weight import compute_class_weight\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn.metrics import confusion_matrix\n", + "import pickle\n", + "import tensorflow_addons as tfa\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.model_selection import StratifiedKFold" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AcjcSuO06o-6", + "outputId": "687dd966-ba6c-45b4-826c-095174e9e81b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2023-02-08 20:30:22-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "Resolving physionet.org (physionet.org)... 18.18.42.54\n", + "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1842722380 (1.7G) [application/zip]\n", + "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", + "\n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 3.83MB/s in 6m 28s \n", + "\n", + "2023-02-08 20:36:50 (4.53 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "\n", + "os.mkdir(\"./data/\")\n", + "\n", + "\n", + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3Qv9hVm-5wyi", + "outputId": "a3698e07-705d-4f83-ded8-3c2efff5cd9b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting GitPython\n", + " Downloading GitPython-3.1.30-py3-none-any.whl (184 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m11.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m8.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Installing collected packages: smmap, gitdb, GitPython\n", + "Successfully installed GitPython-3.1.30 gitdb-4.0.10 smmap-5.0.0\n" + ] + } + ], + "source": [ + "!pip install GitPython\n", + "from git import Repo" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "u4T-c5KI5y2W" + }, + "outputs": [], + "source": [ + "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", + "DEST_NAME = 'github_repo'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r8hm-j6751kC", + "outputId": "e185e68e-c70d-4430-9e7d-1e1b5bd48bcd" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ], + "source": [ + "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "SRUZICm6562J" + }, + "outputs": [], + "source": [ + "from github_repo.code import *\n", + "%matplotlib inline\n", + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CmW7xaR_5oSf", + "outputId": "d8eca41c-a5fa-4df2-8002-093026c79770" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 21837/21837 [00:57<00:00, 380.28it/s]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((19634, 1000, 12), (19634, 71), (2203, 1000, 12), (2203, 71))" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "from github_repo.code.utils import utils\n", + "\n", + "sampling_frequency=100\n", + "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", + "task='all'\n", + "outputfolder='./github_repo/output/'\n", + "\n", + "\n", + "# Load PTB-XL data\n", + "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", + "# Preprocess label data\n", + "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", + "# Select relevant data and convert to one-hot\n", + "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "# 1-9 for training \n", + "X_train = data[labels.strat_fold < 10]\n", + "y_train = Y[labels.strat_fold < 10]\n", + "# 10 for validation\n", + "X_val = data[labels.strat_fold == 10]\n", + "y_val = Y[labels.strat_fold == 10]\n", + "\n", + "num_classes = 71 # <=== number of classes in the finetuning dataset\n", + "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", + "\n", + "X_train.shape, y_train.shape, X_val.shape, y_val.shape" + ] + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ], + "metadata": { + "id": "DIKpffEJMllK", + "outputId": "8d4b38a9-e83c-484b-f761-d9319655dd56", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" + ], + "metadata": { + "id": "-a6LeAwqOm_i" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "X_grid.shape" + ], + "metadata": { + "id": "QW5xSWezMWo-", + "outputId": "e6a121dd-cb79-4e09-da17-c8ca10d492c5", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1964, 1000, 12)" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ], + "metadata": { + "id": "fDz352LpQNds", + "outputId": "36096d82-a448-437d-ab9a-89414d7f3d76", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + } + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1UyIF9kv5oSg" + }, + "source": [ + "# Train or download models\n", + "There are two possibilities:\n", + " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", + " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", + "\n", + "# Load pretrained model\n", + "\n", + "For loading a pretrained model:\n", + " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", + " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", + " \n", + "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." + ] + }, + { + "cell_type": "code", + "source": [ + "from github_repo.code.models.base_model import ClassificationModel\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "import tensorflow_addons as tfa\n", + "\n", + " \n", + "class inception_time_model(ClassificationModel):\n", + " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", + " super(inception_time_model, self).__init__()\n", + " self.name = name\n", + " self.n_classes = n_classes\n", + " self.sampling_frequency = sampling_frequency\n", + " self.outputfolder = outputfolder\n", + " self.input_shape = input_shape\n", + " if loss == \"bce\":\n", + " self.loss = tf.keras.losses.BinaryCrossentropy()\n", + " elif loss == \"wbce\":\n", + " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", + " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", + " self.epoch = epoch\n", + " self.batch_size = batch_size\n", + " self.lr_red = lr_red\n", + " self.verbose = verbose\n", + "\n", + " \n", + " \n", + "\n", + " def fit(self, X_train, y_train, X_val, y_val):\n", + "\n", + " if self.lr_red == \"no\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose)\n", + " elif self.lr_red == \"yes\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose,\n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", + " else:\n", + " print(\"Error: wrong lr_red argument\")\n", + "\n", + " #self.model.save(self.outputfolder +'last_model.h5')\n", + " def predict(self, X):\n", + " return self.model.predict(X)\n", + "\n", + "\n", + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", + " strides=stride, padding='same', activation=activation, use_bias=False)(\n", + " input_inception))\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", + "\n", + " conv_list.append(conv_6)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='same', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + "\n", + " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=loss,\n", + " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\",\n", + " multi_label=True,\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\",\n", + " multi_label=True,\n", + " )\n", + " ])\n", + " print(\"Inception model built.\")\n", + " return model\n", + "\n", + "def scheduler(epoch, lr):\n", + " if epoch % 5 == 0:\n", + " return lr*0.1\n", + " else:\n", + " return lr\n" + ], + "metadata": { + "id": "kg7-fD1ocLBB" + }, + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cEx-BdLJ5oSh", + "outputId": "22535169-4e2f-438a-8062-0fce2e9c33e9" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n" + ] + } + ], + "source": [ + "#from github_repo.code.models.your_model import inception_time_model\n", + "\n", + "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", + "\n", + "experiment = 'exp0'\n", + "modelname = 'fastai_xresnet1d101'\n", + "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", + "mpath='../output/' # <=== path where the finetuned model will be stored\n", + "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", + "\n", + "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", + "\n", + "#model = fastai_model(\n", + "# modelname, \n", + "# num_classes, \n", + "# sampling_frequency, \n", + "# mpath, \n", + "# input_shape=input_shape, \n", + "# pretrainedfolder=pretrainedfolder,\n", + "# n_classes_pretrained=n_classes_pretrained, \n", + "# pretrained=True,\n", + "# epochs_finetuning=2,\n", + "#)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V6dtMWU15oSh" + }, + "source": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# Preprocess data with pretrained Standardizer\n", + "\n", + "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "id": "uqSSsK_V5oSh" + }, + "outputs": [], + "source": [ + "import pickle\n", + "from github_repo.code.utils import utils\n", + "\n", + "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", + "\n", + "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", + "#X_val = utils.apply_standardizer(X_val, standard_scaler)" + ] + }, + { + "cell_type": "code", + "source": [ + "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", + "\n", + "def apply_standardizer(X, ss):\n", + " X_tmp = []\n", + " for x in X:\n", + " x_shape = x.shape\n", + " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", + " X_tmp = np.array(X_tmp)\n", + " return X_tmp\n", + "\n", + "def preprocess_signals(X_train, X_validation):\n", + " # Standardize data such that mean 0 and variance 1\n", + " ss = StandardScaler()\n", + " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", + " \n", + " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" + ], + "metadata": { + "id": "lOSQURgFUycV" + }, + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vfdlaRZr5oSh" + }, + "source": [ + "# Finetune model\n", + "\n", + "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MxzCOgaP5oSi", + "outputId": "4ec349e4-6aee-4c73-9bc4-bb307d5c3e74" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Running gridsearch nr 0 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 1s 17ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.781634 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 1s 17ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.786307 (AUROC score)\n", + "Inception model built.\n" + ] + } + ], + "source": [ + "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", + "df_grid = pd.read_csv(\"/content/gridsearch_params.csv\")\n", + "df_score = pd.read_csv(\"/content/gridsearch_scores.csv\")\n", + "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", + "init_rows = df_score.shape[0]\n", + "\n", + "for gsr in range(gs_left):\n", + " gsr = gsr + init_rows #if previous gridsearch results exists\n", + " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", + " auc_score = []\n", + " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", + " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", + " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", + " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", + " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", + " cv_x_train = X_grid[train_index]\n", + " cv_y_train = y_grid[train_index] \n", + " cv_x_test = X_grid[test_index]\n", + " cv_y_test = y_grid[test_index]\n", + " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", + "\n", + " model.fit(cv_x_train, cv_y_train, cv_x_test, cv_y_test)\n", + " y_hat_test = model.predict(cv_x_test)\n", + " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", + " auc_score.append(score)\n", + " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", + " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", + " df_score=df_score.append(df_grid.loc[gsr])\n", + "df_score.to_csv(\"gridsearch_scores_updated.csv\", index=False) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kvnNlyCX5oSi" + }, + "source": [ + "# Evaluate model on validation data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "m1rgPocD5oSi", + "outputId": "6d91d6ab-7d00-4433-cdbd-2d7fd083cdaa" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aggregating predictions...\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
macro_aucFmax
00.9314580.827961
\n", + "
" + ], + "text/plain": [ + " macro_auc Fmax\n", + "0 0.931458 0.827961" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_val_pred = model.predict(X_val)\n", + "utils.evaluate_experiment(y_val, y_val_pred)" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [], + "machine_shape": "hm" + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", + "language": "python", + "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 3b771f5824f746fd112ff2b4e51e91478bcb2508 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Thu, 9 Feb 2023 19:28:10 +0100 Subject: [PATCH 29/51] Update My_Finetuning2.ipynb Save results from gridsearch to Google Drive (save each gridsearch round to ensure that results gets stored) --- My_Finetuning2.ipynb | 260 ++++++++++++++----------------------------- 1 file changed, 84 insertions(+), 176 deletions(-) diff --git a/My_Finetuning2.ipynb b/My_Finetuning2.ipynb index ae90616..cba3cee 100644 --- a/My_Finetuning2.ipynb +++ b/My_Finetuning2.ipynb @@ -18,13 +18,13 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0L-abXib6HkK", - "outputId": "2cbd6d86-7440-4d5d-cd53-7220ea7017da" + "outputId": "472d330c-0510-416a-cfe0-a545e80d38c5" }, "outputs": [ { @@ -32,33 +32,42 @@ "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wget in /usr/local/lib/python3.8/dist-packages (3.2)\n", - "Requirement already satisfied: wfdb in /usr/local/lib/python3.8/dist-packages (4.1.0)\n", - "Collecting tensorflow-addons\n", + "Collecting wget\n", + " Downloading wget-3.2.zip (10 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting wfdb\n", + " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting tensorflow-addons\n", " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m38.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m29.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Installing collected packages: tensorflow-addons\n", - "Successfully installed tensorflow-addons-0.19.0\n" + "Building wheels for collected packages: wget\n", + " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=09ec8b04d514d3cf890037f4569ee419b94f145c81bb1a85b7cffa31ae0205b6\n", + " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", + "Successfully built wget\n", + "Installing collected packages: wget, tensorflow-addons, wfdb\n", + "Successfully installed tensorflow-addons-0.19.0 wfdb-4.1.0 wget-3.2\n" ] } ], @@ -68,7 +77,31 @@ }, { "cell_type": "code", - "execution_count": 27, + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\")" + ], + "metadata": { + "id": "Y4NQeLDBZUlm", + "outputId": "597b0155-5c98-4d66-d50c-fb8f8ed81794", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": { "id": "Jqxss_rS6Jxn" }, @@ -91,30 +124,27 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "AcjcSuO06o-6", - "outputId": "687dd966-ba6c-45b4-826c-095174e9e81b" + "outputId": "f35858d8-1bb1-4e24-d948-e301f0d56732" }, "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ - "--2023-02-08 20:30:22-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "--2023-02-09 18:21:51-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "Resolving physionet.org (physionet.org)... 18.18.42.54\n", "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", "HTTP request sent, awaiting response... 200 OK\n", "Length: 1842722380 (1.7G) [application/zip]\n", "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 3.83MB/s in 6m 28s \n", - "\n", - "2023-02-08 20:36:50 (4.53 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", - "\n" + "b-xl-a-large-public 28%[====> ] 495.66M 2.07MB/s eta 12m 40s" ] } ], @@ -130,33 +160,11 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3Qv9hVm-5wyi", - "outputId": "a3698e07-705d-4f83-ded8-3c2efff5cd9b" + "id": "3Qv9hVm-5wyi" }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting GitPython\n", - " Downloading GitPython-3.1.30-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m11.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m8.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Installing collected packages: smmap, gitdb, GitPython\n", - "Successfully installed GitPython-3.1.30 gitdb-4.0.10 smmap-5.0.0\n" - ] - } - ], + "outputs": [], "source": [ "!pip install GitPython\n", "from git import Repo" @@ -164,7 +172,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": { "id": "u4T-c5KI5y2W" }, @@ -176,33 +184,18 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "r8hm-j6751kC", - "outputId": "e185e68e-c70d-4430-9e7d-1e1b5bd48bcd" + "id": "r8hm-j6751kC" }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 6 - } - ], + "outputs": [], "source": [ "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": { "id": "SRUZICm6562J" }, @@ -215,33 +208,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CmW7xaR_5oSf", - "outputId": "d8eca41c-a5fa-4df2-8002-093026c79770" + "id": "CmW7xaR_5oSf" }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 21837/21837 [00:57<00:00, 380.28it/s]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "((19634, 1000, 12), (19634, 71), (2203, 1000, 12), (2203, 71))" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ], + "outputs": [], "source": [ "from github_repo.code.utils import utils\n", "\n", @@ -282,28 +253,10 @@ "plt.show()" ], "metadata": { - "id": "DIKpffEJMllK", - "outputId": "8d4b38a9-e83c-484b-f761-d9319655dd56", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - } + "id": "DIKpffEJMllK" }, - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", @@ -315,7 +268,7 @@ "metadata": { "id": "-a6LeAwqOm_i" }, - "execution_count": 10, + "execution_count": null, "outputs": [] }, { @@ -324,25 +277,10 @@ "X_grid.shape" ], "metadata": { - "id": "QW5xSWezMWo-", - "outputId": "e6a121dd-cb79-4e09-da17-c8ca10d492c5", - "colab": { - "base_uri": "https://localhost:8080/" - } + "id": "QW5xSWezMWo-" }, - "execution_count": 11, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(1964, 1000, 12)" - ] - }, - "metadata": {}, - "execution_count": 11 - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "code", @@ -351,28 +289,10 @@ "plt.show()" ], "metadata": { - "id": "fDz352LpQNds", - "outputId": "36096d82-a448-437d-ab9a-89414d7f3d76", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - } + "id": "fDz352LpQNds" }, - "execution_count": 12, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] + "execution_count": null, + "outputs": [] }, { "cell_type": "markdown", @@ -528,28 +448,16 @@ "metadata": { "id": "kg7-fD1ocLBB" }, - "execution_count": 22, + "execution_count": null, "outputs": [] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cEx-BdLJ5oSh", - "outputId": "22535169-4e2f-438a-8062-0fce2e9c33e9" + "id": "cEx-BdLJ5oSh" }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n" - ] - } - ], + "outputs": [], "source": [ "#from github_repo.code.models.your_model import inception_time_model\n", "\n", @@ -599,7 +507,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "id": "uqSSsK_V5oSh" }, @@ -637,7 +545,7 @@ "metadata": { "id": "lOSQURgFUycV" }, - "execution_count": 25, + "execution_count": null, "outputs": [] }, { @@ -695,8 +603,8 @@ ], "source": [ "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", - "df_grid = pd.read_csv(\"/content/gridsearch_params.csv\")\n", - "df_score = pd.read_csv(\"/content/gridsearch_scores.csv\")\n", + "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", + "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\")\n", "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", "init_rows = df_score.shape[0]\n", "\n", @@ -722,7 +630,7 @@ " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", " df_score=df_score.append(df_grid.loc[gsr])\n", - "df_score.to_csv(\"gridsearch_scores_updated.csv\", index=False) " + " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\", index=False) " ] }, { From 1125219add3355d3c375696913522e6a36827429 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 17 Feb 2023 17:12:17 +0100 Subject: [PATCH 30/51] Add files via upload --- My_Finetuning170223.ipynb | 833 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 833 insertions(+) create mode 100644 My_Finetuning170223.ipynb diff --git a/My_Finetuning170223.ipynb b/My_Finetuning170223.ipynb new file mode 100644 index 0000000..286d61f --- /dev/null +++ b/My_Finetuning170223.ipynb @@ -0,0 +1,833 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "IG6fwukq5oSe" + }, + "source": [ + "# Load your data\n", + "\n", + "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", + "\n", + "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", + "\n", + "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", + "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0L-abXib6HkK", + "outputId": "35e28bc5-ef4d-4049-c602-0b35e8b02800" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: wget in /usr/local/lib/python3.8/dist-packages (3.2)\n", + "Requirement already satisfied: wfdb in /usr/local/lib/python3.8/dist-packages (4.1.0)\n", + "Requirement already satisfied: tensorflow-addons in /usr/local/lib/python3.8/dist-packages (0.19.0)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", + "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", + "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n" + ] + } + ], + "source": [ + "!pip install wget wfdb tensorflow-addons" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y4NQeLDBZUlm", + "outputId": "6e80f07e-9549-402b-8046-6d2970b28bc9" + }, + "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" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "id": "Jqxss_rS6Jxn" + }, + "outputs": [], + "source": [ + "import wget\n", + "import numpy as np\n", + "import os\n", + "import zipfile\n", + "import tensorflow as tf\n", + "from sklearn.utils.class_weight import compute_class_weight\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn.metrics import confusion_matrix\n", + "import pickle\n", + "import tensorflow_addons as tfa\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.model_selection import StratifiedKFold" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true + }, + "id": "AcjcSuO06o-6" + }, + "outputs": [], + "source": [ + "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "\n", + "os.mkdir(\"./data/\")\n", + "\n", + "\n", + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3Qv9hVm-5wyi", + "outputId": "1f46551e-a54b-4640-da13-ea8f0c56cd10" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting GitPython\n", + " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m7.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Installing collected packages: smmap, gitdb, GitPython\n", + "Successfully installed GitPython-3.1.31 gitdb-4.0.10 smmap-5.0.0\n" + ] + } + ], + "source": [ + "!pip install GitPython\n", + "from git import Repo" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "id": "u4T-c5KI5y2W" + }, + "outputs": [], + "source": [ + "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", + "DEST_NAME = 'github_repo'" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r8hm-j6751kC", + "outputId": "7571e604-d6f4-4f3c-f5c3-0dd1ba5ca4aa" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ], + "source": [ + "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "SRUZICm6562J" + }, + "outputs": [], + "source": [ + "from github_repo.code import *\n", + "%matplotlib inline\n", + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CmW7xaR_5oSf", + "outputId": "2380fbee-9312-49ee-949e-276d0dcf1b47" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 21837/21837 [00:55<00:00, 393.75it/s]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((19634, 1000, 12), (19634, 71), (2203, 1000, 12), (2203, 71))" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ], + "source": [ + "from github_repo.code.utils import utils\n", + "\n", + "sampling_frequency=100\n", + "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", + "task='all'\n", + "outputfolder='./github_repo/output/'\n", + "\n", + "\n", + "# Load PTB-XL data\n", + "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", + "# Preprocess label data\n", + "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", + "# Select relevant data and convert to one-hot\n", + "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "# 1-9 for training \n", + "X_train = data[labels.strat_fold < 10]\n", + "y_train = Y[labels.strat_fold < 10]\n", + "# 10 for validation\n", + "X_val = data[labels.strat_fold == 10]\n", + "y_val = Y[labels.strat_fold == 10]\n", + "\n", + "num_classes = y_train.shape[1] # <=== number of classes in the finetuning dataset\n", + "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", + "\n", + "X_train.shape, y_train.shape, X_val.shape, y_val.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "DIKpffEJMllK", + "outputId": "20d28be0-a801-4c65-c611-7116d44b3f8c" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "id": "-a6LeAwqOm_i" + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QW5xSWezMWo-", + "outputId": "93b74274-7428-4dcc-c95e-3d15fe2c9b85" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1964, 1000, 12)" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ], + "source": [ + "X_grid.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "fDz352LpQNds", + "outputId": "bc810a87-821e-468c-b57d-3343a4f310bb" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1UyIF9kv5oSg" + }, + "source": [ + "# Train or download models\n", + "There are two possibilities:\n", + " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", + " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", + "\n", + "# Load pretrained model\n", + "\n", + "For loading a pretrained model:\n", + " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", + " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", + " \n", + "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "id": "kg7-fD1ocLBB" + }, + "outputs": [], + "source": [ + "from github_repo.code.models.base_model import ClassificationModel\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "import tensorflow_addons as tfa\n", + "\n", + " \n", + "class inception_time_model(ClassificationModel):\n", + " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", + " super(inception_time_model, self).__init__()\n", + " self.name = name\n", + " self.n_classes = n_classes\n", + " self.sampling_frequency = sampling_frequency\n", + " self.outputfolder = outputfolder\n", + " self.input_shape = input_shape\n", + " if loss == \"bce\":\n", + " self.loss = tf.keras.losses.BinaryCrossentropy()\n", + " elif loss == \"wbce\":\n", + " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", + " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", + " self.epoch = epoch\n", + " self.batch_size = batch_size\n", + " self.lr_red = lr_red\n", + " self.verbose = verbose\n", + "\n", + " \n", + " \n", + "\n", + " def fit(self, X_train, y_train, X_val, y_val):\n", + "\n", + " if self.lr_red == \"no\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose)\n", + " elif self.lr_red == \"yes\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose,\n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", + " else:\n", + " print(\"Error: wrong lr_red argument\")\n", + "\n", + " \n", + " def fit_tf(self, traindata, valdata):\n", + "\n", + " if self.lr_red == \"no\":\n", + " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=valdata, verbose=self.verbose)\n", + " elif self.lr_red == \"yes\":\n", + " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=valdata, verbose=self.verbose,\n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", + " else:\n", + " print(\"Error: wrong lr_red argument\")\n", + "\n", + " #self.model.save(self.outputfolder +'last_model.h5')\n", + " def predict(self, X):\n", + " return self.model.predict(X)\n", + "\n", + "\n", + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", + " strides=stride, padding='same', activation=activation, use_bias=False)(\n", + " input_inception))\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", + "\n", + " conv_list.append(conv_6)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='same', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + "\n", + " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=loss,\n", + " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\",\n", + " multi_label=True,\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\",\n", + " multi_label=True,\n", + " )\n", + " ])\n", + " print(\"Inception model built.\")\n", + " return model\n", + "\n", + "def scheduler(epoch, lr):\n", + " if epoch % 5 == 0:\n", + " return lr*0.1\n", + " else:\n", + " return lr\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cEx-BdLJ5oSh", + "outputId": "34f8305d-822f-4ecd-b6cc-aa7d0811dfc1" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n" + ] + } + ], + "source": [ + "#from github_repo.code.models.your_model import inception_time_model\n", + "\n", + "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", + "\n", + "experiment = 'exp0'\n", + "modelname = 'fastai_xresnet1d101'\n", + "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", + "mpath='../output/' # <=== path where the finetuned model will be stored\n", + "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", + "\n", + "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", + "\n", + "#model = fastai_model(\n", + "# modelname, \n", + "# num_classes, \n", + "# sampling_frequency, \n", + "# mpath, \n", + "# input_shape=input_shape, \n", + "# pretrainedfolder=pretrainedfolder,\n", + "# n_classes_pretrained=n_classes_pretrained, \n", + "# pretrained=True,\n", + "# epochs_finetuning=2,\n", + "#)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V6dtMWU15oSh" + }, + "source": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# Preprocess data with pretrained Standardizer\n", + "\n", + "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "id": "uqSSsK_V5oSh" + }, + "outputs": [], + "source": [ + "import pickle\n", + "from github_repo.code.utils import utils\n", + "\n", + "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", + "\n", + "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", + "#X_val = utils.apply_standardizer(X_val, standard_scaler)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "id": "lOSQURgFUycV" + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", + "\n", + "def apply_standardizer(X, ss):\n", + " X_tmp = []\n", + " for x in X:\n", + " x_shape = x.shape\n", + " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", + " X_tmp = np.array(X_tmp)\n", + " return X_tmp\n", + "\n", + "def preprocess_signals(X_train, X_validation):\n", + " # Standardize data such that mean 0 and variance 1\n", + " ss = StandardScaler()\n", + " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", + " \n", + " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vfdlaRZr5oSh" + }, + "source": [ + "# Finetune model\n", + "\n", + "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PlLyg3zHQVFh", + "outputId": "303f11c5-56c8-459b-f1de-0ba2c6e6e0ae" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "All devices: [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]\n" + ] + } + ], + "source": [ + "resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n", + "tf.config.experimental_connect_to_cluster(resolver)\n", + "# This is the TPU initialization code that has to be at the beginning.\n", + "tf.tpu.experimental.initialize_tpu_system(resolver)\n", + "print(\"All devices: \", tf.config.list_logical_devices('TPU'))\n", + "strategy = tf.distribute.TPUStrategy(resolver)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true, + "base_uri": "https://localhost:8080/" + }, + "id": "MxzCOgaP5oSi", + "outputId": "bd27baac-c15c-47eb-b590-07aa31a3777d" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Running gridsearch nr 436 of 972...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", + " warnings.warn(\n" + ] + } + ], + "source": [ + "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", + "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", + "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\")\n", + "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", + "init_rows = df_score.shape[0]\n", + "\n", + "for gsr in range(gs_left):\n", + " gsr = gsr + init_rows #if previous gridsearch results exists\n", + " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", + " auc_score = []\n", + " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", + " with strategy.scope():\n", + " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", + " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", + " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", + " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", + " cv_x_train = X_grid[train_index]\n", + " cv_y_train = y_grid[train_index] \n", + " cv_x_test = X_grid[test_index]\n", + " cv_y_test = y_grid[test_index]\n", + " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", + " \n", + " tf_dataset_train = tf.data.Dataset.from_tensor_slices((cv_x_train, cv_y_train)) #tf.data.Dataset.from_tensor_slices((X_train, y_train))\n", + " tf_dataset_train = tf_dataset_train.cache()\n", + " tf_dataset_train = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", + " tf_dataset_train = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", + "\n", + " tf_dataset_val = tf.data.Dataset.from_tensor_slices((cv_x_test, cv_y_test))\n", + " tf_dataset_val = tf_dataset_train.cache()\n", + " tf_dataset_val = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", + " tf_dataset_val = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", + "\n", + " model.fit_tf(tf_dataset_train, tf_dataset_val)\n", + " y_hat_test = model.predict(cv_x_test)\n", + " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", + " auc_score.append(score)\n", + " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", + " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", + " df_score=df_score.append(df_grid.loc[gsr])\n", + " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\", index=False) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true + }, + "id": "SPSC9F4wPf9J" + }, + "outputs": [], + "source": [ + "utils.utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kvnNlyCX5oSi" + }, + "source": [ + "# Evaluate model on validation data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "background_save": true + }, + "id": "m1rgPocD5oSi" + }, + "outputs": [], + "source": [ + "y_val_pred = model.predict(X_val)\n", + "utils.evaluate_experiment(y_val, y_val_pred)" + ] + } + ], + "metadata": { + "accelerator": "TPU", + "colab": { + "machine_shape": "hm", + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", + "language": "python", + "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From d5e0e476ec36d6ed74dd813fee8cc88830994aa8 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sun, 19 Feb 2023 19:46:07 +0100 Subject: [PATCH 31/51] Update My_Finetuning170223.ipynb --- My_Finetuning170223.ipynb | 144 ++++++++++++++++++++++++-------------- 1 file changed, 90 insertions(+), 54 deletions(-) diff --git a/My_Finetuning170223.ipynb b/My_Finetuning170223.ipynb index 286d61f..8127864 100644 --- a/My_Finetuning170223.ipynb +++ b/My_Finetuning170223.ipynb @@ -18,13 +18,13 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0L-abXib6HkK", - "outputId": "35e28bc5-ef4d-4049-c602-0b35e8b02800" + "outputId": "809c59a7-9ff2-430f-f627-b6e94dc0f4ef" }, "outputs": [ { @@ -32,29 +32,47 @@ "name": "stdout", "text": [ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wget in /usr/local/lib/python3.8/dist-packages (3.2)\n", - "Requirement already satisfied: wfdb in /usr/local/lib/python3.8/dist-packages (4.1.0)\n", - "Requirement already satisfied: tensorflow-addons in /usr/local/lib/python3.8/dist-packages (0.19.0)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Collecting wget\n", + " Downloading wget-3.2.zip (10 kB)\n", + " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + "Collecting wfdb\n", + " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting tensorflow-addons\n", + " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hRequirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", + "Collecting SoundFile<0.12.0,>=0.10.0\n", + " Downloading soundfile-0.11.0-py2.py3-none-any.whl (23 kB)\n", "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", + "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n" + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", + "Building wheels for collected packages: wget\n", + " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=0c010b4ac873a3810927fbc4110402b55c605341cc2410eee2934b2cb04d2b35\n", + " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", + "Successfully built wget\n", + "Installing collected packages: wget, tensorflow-addons, SoundFile, wfdb\n", + " Attempting uninstall: SoundFile\n", + " Found existing installation: soundfile 0.12.1\n", + " Uninstalling soundfile-0.12.1:\n", + " Successfully uninstalled soundfile-0.12.1\n", + "Successfully installed SoundFile-0.11.0 tensorflow-addons-0.19.0 wfdb-4.1.0 wget-3.2\n" ] } ], @@ -64,20 +82,20 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Y4NQeLDBZUlm", - "outputId": "6e80f07e-9549-402b-8046-6d2970b28bc9" + "outputId": "8cd2652c-134d-48b7-8f83-c0902d5e09f9" }, "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" + "Mounted at /content/drive\n" ] } ], @@ -88,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": { "id": "Jqxss_rS6Jxn" }, @@ -111,14 +129,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "colab": { - "background_save": true + "base_uri": "https://localhost:8080/" }, - "id": "AcjcSuO06o-6" + "id": "AcjcSuO06o-6", + "outputId": "7d3e9e1a-af41-4cc5-dc8c-70be7d269596" }, - "outputs": [], + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2023-02-19 17:49:54-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "Resolving physionet.org (physionet.org)... 18.18.42.54\n", + "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1842722380 (1.7G) [application/zip]\n", + "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", + "\n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 3.08MB/s in 11m 41s \n", + "\n", + "2023-02-19 18:01:35 (2.51 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "\n" + ] + } + ], "source": [ "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", "\n", @@ -131,13 +168,13 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "3Qv9hVm-5wyi", - "outputId": "1f46551e-a54b-4640-da13-ea8f0c56cd10" + "outputId": "159e0c4e-f603-4946-8a5c-18183c5ec5bf" }, "outputs": [ { @@ -147,10 +184,10 @@ "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", "Collecting GitPython\n", " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m7.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25hCollecting smmap<6,>=3.0.1\n", " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", "Installing collected packages: smmap, gitdb, GitPython\n", @@ -165,7 +202,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": { "id": "u4T-c5KI5y2W" }, @@ -177,13 +214,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "r8hm-j6751kC", - "outputId": "7571e604-d6f4-4f3c-f5c3-0dd1ba5ca4aa" + "outputId": "72d7691d-d731-4b81-de52-cbf96716b853" }, "outputs": [ { @@ -194,7 +231,7 @@ ] }, "metadata": {}, - "execution_count": 12 + "execution_count": 7 } ], "source": [ @@ -203,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": { "id": "SRUZICm6562J" }, @@ -216,20 +253,20 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "CmW7xaR_5oSf", - "outputId": "2380fbee-9312-49ee-949e-276d0dcf1b47" + "outputId": "5ed7d833-2bfd-4671-a5b7-6fc816a9bed9" }, "outputs": [ { "output_type": "stream", "name": "stderr", "text": [ - "100%|██████████| 21837/21837 [00:55<00:00, 393.75it/s]\n" + "100%|██████████| 21837/21837 [01:05<00:00, 334.86it/s]\n" ] }, { @@ -240,7 +277,7 @@ ] }, "metadata": {}, - "execution_count": 19 + "execution_count": 9 } ], "source": [ @@ -248,10 +285,9 @@ "\n", "sampling_frequency=100\n", "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task='all'\n", + "task= 'YOUR_EXPERIMENT_NAME' # 'all' , 'diagnostic' , 'subdiagnostic', 'superdiagnostic', 'form', 'rhythm'\n", "outputfolder='./github_repo/output/'\n", "\n", - "\n", "# Load PTB-XL data\n", "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", "# Preprocess label data\n", @@ -276,14 +312,14 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 265 }, "id": "DIKpffEJMllK", - "outputId": "20d28be0-a801-4c65-c611-7116d44b3f8c" + "outputId": "5767901f-bc87-4953-9a94-ad55abe64dcd" }, "outputs": [ { @@ -308,7 +344,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 11, "metadata": { "id": "-a6LeAwqOm_i" }, @@ -321,13 +357,13 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "QW5xSWezMWo-", - "outputId": "93b74274-7428-4dcc-c95e-3d15fe2c9b85" + "outputId": "6d4f9c1a-e082-4d91-cee2-c8929948a050" }, "outputs": [ { @@ -338,7 +374,7 @@ ] }, "metadata": {}, - "execution_count": 23 + "execution_count": 12 } ], "source": [ @@ -347,14 +383,14 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 265 }, "id": "fDz352LpQNds", - "outputId": "bc810a87-821e-468c-b57d-3343a4f310bb" + "outputId": "0aef9990-146b-4d91-c940-8fe5685c3a51" }, "outputs": [ { @@ -397,7 +433,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "metadata": { "id": "kg7-fD1ocLBB" }, @@ -547,13 +583,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cEx-BdLJ5oSh", - "outputId": "34f8305d-822f-4ecd-b6cc-aa7d0811dfc1" + "outputId": "ccfa4460-1fb9-4be8-96e6-eefe3ac15a75" }, "outputs": [ { @@ -613,7 +649,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 16, "metadata": { "id": "uqSSsK_V5oSh" }, @@ -630,7 +666,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 17, "metadata": { "id": "lOSQURgFUycV" }, @@ -667,13 +703,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "PlLyg3zHQVFh", - "outputId": "303f11c5-56c8-459b-f1de-0ba2c6e6e0ae" + "outputId": "e2644fda-d890-4c9b-f5de-7c547608a0f1" }, "outputs": [ { @@ -724,7 +760,7 @@ "source": [ "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", - "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\")\n", + "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_YOUR_EXPERIMENT_NAME.csv\")\n", "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", "init_rows = df_score.shape[0]\n", "\n", @@ -761,7 +797,7 @@ " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", " df_score=df_score.append(df_grid.loc[gsr])\n", - " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\", index=False) " + " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_YOUR_EXPERIMENT_NAME.csv\", index=False) " ] }, { From 0223e140127a03a8b6efe0ad5c011c843fc6cdec Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Tue, 28 Mar 2023 12:36:34 +0200 Subject: [PATCH 32/51] Add files via upload --- Gridsearch280323.ipynb | 1810 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1810 insertions(+) create mode 100644 Gridsearch280323.ipynb diff --git a/Gridsearch280323.ipynb b/Gridsearch280323.ipynb new file mode 100644 index 0000000..4707f4c --- /dev/null +++ b/Gridsearch280323.ipynb @@ -0,0 +1,1810 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "IG6fwukq5oSe" + }, + "source": [ + "# Load your data\n", + "\n", + "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", + "\n", + "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", + "\n", + "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", + "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0L-abXib6HkK", + "outputId": "61aa2656-a0f0-49ce-a597-dd343bb689dc" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Requirement already satisfied: wget in /usr/local/lib/python3.9/dist-packages (3.2)\n", + "Requirement already satisfied: wfdb in /usr/local/lib/python3.9/dist-packages (4.1.0)\n", + "Requirement already satisfied: tensorflow-addons in /usr/local/lib/python3.9/dist-packages (0.19.0)\n", + "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from wfdb) (1.4.4)\n", + "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from wfdb) (2.27.1)\n", + "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.9/dist-packages (from wfdb) (0.11.0)\n", + "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from wfdb) (1.10.1)\n", + "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.9/dist-packages (from wfdb) (1.24.2)\n", + "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.9/dist-packages (from wfdb) (3.7.1)\n", + "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.9/dist-packages (from tensorflow-addons) (3.0.2)\n", + "Requirement already satisfied: packaging in /usr/local/lib/python3.9/dist-packages (from tensorflow-addons) (23.0)\n", + "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.0.7)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (4.39.2)\n", + "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (5.12.0)\n", + "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (8.4.0)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", + "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.26.15)\n", + "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.0.12)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.4)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", + "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.9/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", + "Requirement already satisfied: importlib-metadata>=3.6 in /usr/local/lib/python3.9/dist-packages (from typeguard>=2.7->tensorflow-addons) (6.1.0)\n", + "Requirement already satisfied: typing-extensions>=4.4.0 in /usr/local/lib/python3.9/dist-packages (from typeguard>=2.7->tensorflow-addons) (4.5.0)\n", + "Requirement already satisfied: pycparser in /usr/local/lib/python3.9/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", + "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata>=3.6->typeguard>=2.7->tensorflow-addons) (3.15.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.2.2->wfdb) (1.16.0)\n" + ] + } + ], + "source": [ + "!pip install wget wfdb tensorflow-addons" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y4NQeLDBZUlm", + "outputId": "1ecdd03f-a324-4889-a390-032358123033" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "Jqxss_rS6Jxn" + }, + "outputs": [], + "source": [ + "import wget\n", + "import numpy as np\n", + "import os\n", + "import zipfile\n", + "import tensorflow as tf\n", + "from sklearn.utils.class_weight import compute_class_weight\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from sklearn.metrics import confusion_matrix\n", + "import pickle\n", + "import tensorflow_addons as tfa\n", + "from sklearn.metrics import roc_auc_score\n", + "from sklearn.model_selection import StratifiedKFold" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AcjcSuO06o-6", + "outputId": "ba24cbd7-8791-4df2-8dcd-f28176ff5b68" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2023-03-28 06:32:23-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "Resolving physionet.org (physionet.org)... 18.18.42.54\n", + "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 1842722380 (1.7G) [application/zip]\n", + "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", + "\n", + "ptb-xl-a-large-publ 100%[===================>] 1.72G 704KB/s in 39m 59s \n", + "\n", + "2023-03-28 07:12:22 (750 KB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", + "\n" + ] + } + ], + "source": [ + "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", + "\n", + "os.mkdir(\"./data/\")\n", + "\n", + "\n", + "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", + " zip_ref.extractall(\"./data/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3Qv9hVm-5wyi", + "outputId": "9491eee6-ec8c-4197-fdf1-2c86885dedd4" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", + "Collecting GitPython\n", + " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", + " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hCollecting smmap<6,>=3.0.1\n", + " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", + "Installing collected packages: smmap, gitdb, GitPython\n", + "Successfully installed GitPython-3.1.31 gitdb-4.0.10 smmap-5.0.0\n" + ] + } + ], + "source": [ + "!pip install GitPython\n", + "from git import Repo" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "u4T-c5KI5y2W" + }, + "outputs": [], + "source": [ + "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", + "DEST_NAME = 'github_repo'" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "r8hm-j6751kC", + "outputId": "16d381b0-9ba6-4de6-8bce-6587ff9d8b0e" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ], + "source": [ + "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "id": "SRUZICm6562J" + }, + "outputs": [], + "source": [ + "from github_repo.code import *\n", + "%matplotlib inline\n", + "%load_ext autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CmW7xaR_5oSf", + "outputId": "a0c6929e-9631-4c0d-e1ae-03051df706ee" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 21837/21837 [01:05<00:00, 334.36it/s]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "((19267, 1000, 12), (19267, 5), (2163, 1000, 12), (2163, 5))" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ], + "source": [ + "from github_repo.code.utils import utils\n", + "\n", + "sampling_frequency=100\n", + "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", + "task= 'superdiagnostic' # 'all' , 'diagnostic' , 'subdiagnostic', 'superdiagnostic', 'form', 'rhythm'\n", + "outputfolder='./github_repo/output/'\n", + "\n", + "# Load PTB-XL data\n", + "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", + "# Preprocess label data\n", + "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", + "# Select relevant data and convert to one-hot\n", + "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", + "\n", + "# 1-9 for training \n", + "X_train = data[labels.strat_fold < 10]\n", + "y_train = Y[labels.strat_fold < 10]\n", + "# 10 for validation\n", + "X_val = data[labels.strat_fold == 10]\n", + "y_val = Y[labels.strat_fold == 10]\n", + "\n", + "num_classes = y_train.shape[1] # <=== number of classes in the finetuning dataset\n", + "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", + "\n", + "X_train.shape, y_train.shape, X_val.shape, y_val.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "DIKpffEJMllK", + "outputId": "8c22fd61-1e45-4dbf-e8fd-7e094a3a89de" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "id": "-a6LeAwqOm_i" + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QW5xSWezMWo-", + "outputId": "a17b552a-4e2c-4900-df2f-22c0ce9a6f41" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(1927, 1000, 12)" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ], + "source": [ + "X_grid.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 265 + }, + "id": "fDz352LpQNds", + "outputId": "ecfc7875-1aa0-4b3c-9b3a-fa00ec07253c" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAAsTAAALEwEAmpwYAAAQ0UlEQVR4nO3dW4xdV33H8e+vMeHa4lymVmpbdSQsUIRESEepUaqqjUuVS4XzAFFoS6zIlfsQWihIYPpCkfoQpIpA1CqShSlOS4E0gGJBRGs5QahSE5hACCQGZUgTbCuJh5CES8Ql8O/DLIsTM545M3NmDl7z/UhHZ+211p7937Lm5601+5ydqkKS1JffGHcBkqTRM9wlqUOGuyR1yHCXpA4Z7pLUoXXjLgDg3HPPrS1btoy7DEk6rdx7773fraqJucZ+LcJ9y5YtTE1NjbsMSTqtJHn0VGMuy0hShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1KGhwj3J3yV5IMk3knw8yYuSnJ/kniTTST6Z5Mw294Vte7qNb1nRM5Ak/YoFwz3JRuBvgcmqejVwBnAN8H7gxqp6BfAUsKvtsgt4qvXf2OZJklbRsJ9QXQe8OMnPgJcAjwGXAn/exvcD/wDcDOxobYDbgH9OkvKpINJIbdnzuXGXMBKP3HDluEvo0oJX7lV1DPgn4DvMhvozwL3A01X1XJt2FNjY2huBI23f59r8c07+uUl2J5lKMjUzM7Pc85AkDRhmWeYsZq/Gzwd+B3gpcNlyD1xVe6tqsqomJybm/N4bSdISDfMH1T8B/q+qZqrqZ8CngUuA9UlOLOtsAo619jFgM0Abfznw5EirliTNa5hw/w6wLclLkgTYDjwI3AW8sc3ZCdze2gfaNm38TtfbJWl1DbPmfg+zfxj9CvD1ts9e4N3AO5JMM7umvq/tsg84p/W/A9izAnVLkuYx1N0yVfVe4L0ndT8MXDzH3B8Db1p+aZKkpfITqpLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDg3zgOxXJrlv4PX9JG9PcnaSg0keau9ntflJclOS6ST3J7lo5U9DkjRomMfsfauqLqyqC4HfA54FPsPs4/MOVdVW4BC/fJze5cDW9toN3LwCdUuS5rHYZZntwLer6lFgB7C/9e8HrmrtHcAtNetuYH2S80ZRrCRpOIsN92uAj7f2hqp6rLUfBza09kbgyMA+R1ufJGmVDB3uSc4E3gD858ljVVVALebASXYnmUoyNTMzs5hdJUkLWMyV++XAV6rqibb9xInllvZ+vPUfAzYP7Lep9T1PVe2tqsmqmpyYmFh85ZKkU1pMuL+ZXy7JABwAdrb2TuD2gf5r210z24BnBpZvJEmrYN0wk5K8FHg98NcD3TcAtybZBTwKXN367wCuAKaZvbPmupFVK0kaylDhXlU/As45qe9JZu+eOXluAdePpDpJ0pL4CVVJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nq0FDhnmR9ktuSfDPJ4SSvS3J2koNJHmrvZ7W5SXJTkukk9ye5aGVPQZJ0smGv3D8EfL6qXgW8BjgM7AEOVdVW4FDbBrgc2Npeu4GbR1qxJGlBC4Z7kpcDfwjsA6iqn1bV08AOYH+bth+4qrV3ALfUrLuB9UnOG3HdkqR5DHPlfj4wA/xrkq8m+XCSlwIbquqxNudxYENrbwSODOx/tPU9T5LdSaaSTM3MzCz9DCRJv2KYcF8HXATcXFWvBX7EL5dgAKiqAmoxB66qvVU1WVWTExMTi9lVkrSAYcL9KHC0qu5p27cxG/ZPnFhuae/H2/gxYPPA/ptanyRplSwY7lX1OHAkyStb13bgQeAAsLP17QRub+0DwLXtrpltwDMDyzeSpFWwbsh5fwN8LMmZwMPAdcz+x3Brkl3Ao8DVbe4dwBXANPBsmytJWkVDhXtV3QdMzjG0fY65BVy/vLIkScvhJ1QlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDhrskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ0OFe5JHknw9yX1Jplrf2UkOJnmovZ/V+pPkpiTTSe5PctFKnoAk6Vct5sr9j6vqwqo68bi9PcChqtoKHGrbAJcDW9trN3DzqIqVJA1nOcsyO4D9rb0fuGqg/5aadTewPsl5yziOJGmRhg33Av47yb1Jdre+DVX1WGs/Dmxo7Y3AkYF9j7a+50myO8lUkqmZmZkllC5JOpV1Q877g6o6luS3gYNJvjk4WFWVpBZz4KraC+wFmJycXNS+kqT5DXXlXlXH2vtx4DPAxcATJ5Zb2vvxNv0YsHlg902tT5K0ShYM9yQvTfKbJ9rAnwLfAA4AO9u0ncDtrX0AuLbdNbMNeGZg+UaStAqGWZbZAHwmyYn5/1FVn0/yZeDWJLuAR4Gr2/w7gCuAaeBZ4LqRVy1JmteC4V5VDwOvmaP/SWD7HP0FXD+S6iRJS+InVCWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6tCw3y3za2vLns+Nu4SReeSGK8ddgqROeOUuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdGjrck5yR5KtJPtu2z09yT5LpJJ9Mcmbrf2Hbnm7jW1aodknSKSzmyv1twOGB7fcDN1bVK4CngF2tfxfwVOu/sc2TJK2iocI9ySbgSuDDbTvApcBtbcp+4KrW3tG2aePb23xJ0ioZ9sr9g8C7gF+07XOAp6vqubZ9FNjY2huBIwBt/Jk2/3mS7E4ylWRqZmZmadVLkua0YLgn+TPgeFXdO8oDV9XeqpqsqsmJiYlR/mhJWvOG+crfS4A3JLkCeBHwW8CHgPVJ1rWr803AsTb/GLAZOJpkHfBy4MmRVy5JOqUFr9yr6j1VtamqtgDXAHdW1V8AdwFvbNN2Are39oG2TRu/s6pqpFVLkua1nPvc3w28I8k0s2vq+1r/PuCc1v8OYM/ySpQkLdainsRUVV8AvtDaDwMXzzHnx8CbRlCbJGmJ/ISqJHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1yHCXpA4Z7pLUIcNdkjpkuEtShwx3SeqQ4S5JHTLcJalDwzwg+0VJvpTka0keSPK+1n9+knuSTCf5ZJIzW/8L2/Z0G9+ywucgSTrJMFfuPwEurarXABcClyXZBrwfuLGqXgE8Bexq83cBT7X+G9s8SdIqGuYB2VVVP2ybL2ivAi4Fbmv9+4GrWntH26aNb0+SURUsSVrYUGvuSc5Ich9wHDgIfBt4uqqea1OOAhtbeyNwBKCNP8PsA7QlSatkqHCvqp9X1YXAJmYfiv2q5R44ye4kU0mmZmZmlvvjJEkDFnW3TFU9DdwFvA5Yn2RdG9oEHGvtY8BmgDb+cuDJOX7W3qqarKrJiYmJpVUvSZrTMHfLTCRZ39ovBl4PHGY25N/Ypu0Ebm/tA22bNn5nVdUIa5YkLWDdwlM4D9if5Axm/zO4tao+m+RB4BNJ/hH4KrCvzd8H/FuSaeB7wDUrULckaR4LhntV3Q+8do7+h5ldfz+5/8fAm0ZSnSRpSfyEqiR1aJhlGenX0pY9nxt3CSPzyA1XjrsEdcYrd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkd8usHJJ12/OqJhXnlLkkdMtwlqUOGuyR1yHCXpA4N8wzVzUnuSvJgkgeSvK31n53kYJKH2vtZrT9JbkoyneT+JBet9ElIkp5vmCv354B3VtUFwDbg+iQXAHuAQ1W1FTjUtgEuB7a2127g5pFXLUma14LhXlWPVdVXWvsHwGFgI7AD2N+m7Qeuau0dwC01625gfZLzRl24JOnUFrXmnmQLsw/LvgfYUFWPtaHHgQ2tvRE4MrDb0dZ38s/anWQqydTMzMxi65YkzWPocE/yMuBTwNur6vuDY1VVQC3mwFW1t6omq2pyYmJiMbtKkhYwVLgneQGzwf6xqvp0637ixHJLez/e+o8Bmwd239T6JEmrZJi7ZQLsAw5X1QcGhg4AO1t7J3D7QP+17a6ZbcAzA8s3kqRVMMx3y1wCvAX4epL7Wt/fAzcAtybZBTwKXN3G7gCuAKaBZ4HrRlmwJGlhC4Z7Vf0PkFMMb59jfgHXL7MuSdIy+AlVSeqQ4S5JHTLcJalDPqzjNNfLQwtW6oEF0lrllbskdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHhnmG6keSHE/yjYG+s5McTPJQez+r9SfJTUmmk9yf5KKVLF6SNLdhrtw/Clx2Ut8e4FBVbQUOtW2Ay4Gt7bUbuHk0ZUqSFmPBcK+qLwLfO6l7B7C/tfcDVw3031Kz7gbWJzlvRLVKkoa01DX3DVX1WGs/Dmxo7Y3AkYF5R1vfr0iyO8lUkqmZmZklliFJmsuy/6BaVQXUEvbbW1WTVTU5MTGx3DIkSQOWGu5PnFhuae/HW/8xYPPAvE2tT5K0ipYa7geAna29E7h9oP/adtfMNuCZgeUbSdIqWfAB2Uk+DvwRcG6So8B7gRuAW5PsAh4Frm7T7wCuAKaBZ4HrVqBmSdICFgz3qnrzKYa2zzG3gOuXW5QkaXn8hKokdchwl6QOGe6S1CHDXZI6ZLhLUocMd0nqkOEuSR0y3CWpQ4a7JHXIcJekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUOGuyR1aEXCPcllSb6VZDrJnpU4hiTp1EYe7knOAP4FuBy4AHhzkgtGfRxJ0qmtxJX7xcB0VT1cVT8FPgHsWIHjSJJOIbPPtB7hD0zeCFxWVX/Vtt8C/H5VvfWkebuB3W3zlcC3RlrI6J0LfHfcRYyJ5752reXzPx3O/XeramKugXWrXckJVbUX2Duu4y9Wkqmqmhx3HePgua/Nc4e1ff6n+7mvxLLMMWDzwPam1idJWiUrEe5fBrYmOT/JmcA1wIEVOI4k6RRGvixTVc8leSvwX8AZwEeq6oFRH2cMTpslpBXgua9da/n8T+tzH/kfVCVJ4+cnVCWpQ4a7JHXIcF/AWv4qhSQfSXI8yTfGXctqS7I5yV1JHkzyQJK3jbum1ZLkRUm+lORr7dzfN+6axiHJGUm+muSz465lKQz3efhVCnwUuGzcRYzJc8A7q+oCYBtw/Rr6t/8JcGlVvQa4ELgsybbxljQWbwMOj7uIpTLc57emv0qhqr4IfG/cdYxDVT1WVV9p7R8w+0u+cbxVrY6a9cO2+YL2WlN3XiTZBFwJfHjctSyV4T6/jcCRge2jrJFfcP1Ski3Aa4F7xlzKqmlLEvcBx4GDVbVmzr35IPAu4BdjrmPJDHdpHkleBnwKeHtVfX/c9ayWqvp5VV3I7CfML07y6jGXtGqS/BlwvKruHXcty2G4z8+vUljDkryA2WD/WFV9etz1jENVPQ3cxdr628slwBuSPMLsUuylSf59vCUtnuE+P79KYY1KEmAfcLiqPjDuelZTkokk61v7xcDrgW+OtahVVFXvqapNVbWF2d/5O6vqL8dc1qIZ7vOoqueAE1+lcBi4tZOvUhhKko8D/wu8MsnRJLvGXdMqugR4C7NXbfe11xXjLmqVnAfcleR+Zi9wDlbVaXk74Frm1w9IUoe8cpekDhnuktQhw12SOmS4S1KHDHdJ6pDhLkkdMtwlqUP/D94jeiawBvFhAAAAAElFTkSuQmCC\n" + }, + "metadata": { + "needs_background": "light" + } + } + ], + "source": [ + "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1UyIF9kv5oSg" + }, + "source": [ + "# Train or download models\n", + "There are two possibilities:\n", + " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", + " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", + "\n", + "# Load pretrained model\n", + "\n", + "For loading a pretrained model:\n", + " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", + " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", + " \n", + "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "id": "kg7-fD1ocLBB" + }, + "outputs": [], + "source": [ + "from github_repo.code.models.base_model import ClassificationModel\n", + "import tensorflow as tf\n", + "import numpy as np\n", + "import tensorflow_addons as tfa\n", + "\n", + " \n", + "class inception_time_model(ClassificationModel):\n", + " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", + " super(inception_time_model, self).__init__()\n", + " self.name = name\n", + " self.n_classes = n_classes\n", + " self.sampling_frequency = sampling_frequency\n", + " self.outputfolder = outputfolder\n", + " self.input_shape = input_shape\n", + " if loss == \"bce\":\n", + " self.loss = tf.keras.losses.BinaryCrossentropy()\n", + " elif loss == \"wbce\":\n", + " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", + " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", + " self.epoch = epoch\n", + " self.batch_size = batch_size\n", + " self.lr_red = lr_red\n", + " self.verbose = verbose\n", + "\n", + " \n", + " \n", + "\n", + " def fit(self, X_train, y_train, X_val, y_val):\n", + "\n", + " if self.lr_red == \"no\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose)\n", + " elif self.lr_red == \"yes\":\n", + " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=(X_val, y_val), verbose=self.verbose,\n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", + " else:\n", + " print(\"Error: wrong lr_red argument\")\n", + "\n", + " \n", + " def fit_tf(self, traindata, valdata):\n", + "\n", + " if self.lr_red == \"no\":\n", + " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=valdata, verbose=self.verbose)\n", + " elif self.lr_red == \"yes\":\n", + " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", + " validation_data=valdata, verbose=self.verbose,\n", + " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", + " else:\n", + " print(\"Error: wrong lr_red argument\")\n", + "\n", + " #self.model.save(self.outputfolder +'last_model.h5')\n", + " def predict(self, X):\n", + " return self.model.predict(X)\n", + "\n", + "\n", + "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", + "\n", + " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", + " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(input_tensor)\n", + " else:\n", + " input_inception = input_tensor\n", + "\n", + " # kernel_size_s = [3, 5, 8, 11, 17]\n", + " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", + "\n", + " conv_list = []\n", + "\n", + " for i in range(len(kernel_size_s)):\n", + " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", + " strides=stride, padding='same', activation=activation, use_bias=False)(\n", + " input_inception))\n", + "\n", + " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", + "\n", + " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", + " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", + "\n", + " conv_list.append(conv_6)\n", + "\n", + " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", + " x = tf.keras.layers.BatchNormalization()(x)\n", + " x = tf.keras.layers.Activation(activation='relu')(x)\n", + " return x\n", + "\n", + "def _shortcut_layer(input_tensor, out_tensor):\n", + " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", + " padding='same', use_bias=False)(input_tensor)\n", + " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", + "\n", + " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", + " x = tf.keras.layers.Activation('relu')(x)\n", + " return x\n", + "\n", + "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", + " input_layer = tf.keras.layers.Input(input_shape)\n", + "\n", + " x = input_layer\n", + " input_res = input_layer\n", + "\n", + " for d in range(depth):\n", + "\n", + " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", + "\n", + " if use_residual and d % 3 == 2:\n", + " x = _shortcut_layer(input_res, x)\n", + " input_res = x\n", + "\n", + " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", + "\n", + " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", + " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", + " model.compile(loss=loss,\n", + " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", + " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='ROC',\n", + " summation_method='interpolation',\n", + " name=\"ROC\",\n", + " multi_label=True,\n", + " ),\n", + " tf.keras.metrics.AUC(\n", + " num_thresholds=200,\n", + " curve='PR',\n", + " summation_method='interpolation',\n", + " name=\"PRC\",\n", + " multi_label=True,\n", + " )\n", + " ])\n", + " print(\"Inception model built.\")\n", + " return model\n", + "\n", + "def scheduler(epoch, lr):\n", + " if epoch % 5 == 0:\n", + " return lr*0.1\n", + " else:\n", + " return lr\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cEx-BdLJ5oSh", + "outputId": "597463e5-ead4-40ab-8850-a6b75e65be89" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n" + ] + } + ], + "source": [ + "#from github_repo.code.models.your_model import inception_time_model\n", + "\n", + "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", + "\n", + "experiment = 'exp0'\n", + "modelname = 'fastai_xresnet1d101'\n", + "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", + "mpath='../output/' # <=== path where the finetuned model will be stored\n", + "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", + "\n", + "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", + "\n", + "#model = fastai_model(\n", + "# modelname, \n", + "# num_classes, \n", + "# sampling_frequency, \n", + "# mpath, \n", + "# input_shape=input_shape, \n", + "# pretrainedfolder=pretrainedfolder,\n", + "# n_classes_pretrained=n_classes_pretrained, \n", + "# pretrained=True,\n", + "# epochs_finetuning=2,\n", + "#)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "V6dtMWU15oSh" + }, + "source": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "# Preprocess data with pretrained Standardizer\n", + "\n", + "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "uqSSsK_V5oSh" + }, + "outputs": [], + "source": [ + "import pickle\n", + "from github_repo.code.utils import utils\n", + "\n", + "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", + "\n", + "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", + "#X_val = utils.apply_standardizer(X_val, standard_scaler)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "id": "lOSQURgFUycV" + }, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", + "\n", + "def apply_standardizer(X, ss):\n", + " X_tmp = []\n", + " for x in X:\n", + " x_shape = x.shape\n", + " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", + " X_tmp = np.array(X_tmp)\n", + " return X_tmp\n", + "\n", + "def preprocess_signals(X_train, X_validation):\n", + " # Standardize data such that mean 0 and variance 1\n", + " ss = StandardScaler()\n", + " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", + " \n", + " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vfdlaRZr5oSh" + }, + "source": [ + "# Finetune model\n", + "\n", + "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PlLyg3zHQVFh", + "outputId": "8e2094e3-7a8c-4dbf-c8c9-b4236277b33a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "All devices: [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]\n" + ] + } + ], + "source": [ + "resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n", + "tf.config.experimental_connect_to_cluster(resolver)\n", + "# This is the TPU initialization code that has to be at the beginning.\n", + "tf.tpu.experimental.initialize_tpu_system(resolver)\n", + "print(\"All devices: \", tf.config.list_logical_devices('TPU'))\n", + "strategy = tf.distribute.TPUStrategy(resolver)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MxzCOgaP5oSi", + "outputId": "47708ddc-db9a-481e-e4f1-e1a2205739a1" + }, + "outputs": [ + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Running gridsearch nr 773 of 972...\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 230ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.875927 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 234ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.879164 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 237ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.893471 (AUROC score)\n", + "Running gridsearch nr 774 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 3s 109ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.851221 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 109ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.873682 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 109ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.868266 (AUROC score)\n", + "Running gridsearch nr 775 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 128ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.877054 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 128ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.88111 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 129ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.890032 (AUROC score)\n", + "Running gridsearch nr 776 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 176ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.859853 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 177ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.865822 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 176ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.857429 (AUROC score)\n", + "Running gridsearch nr 777 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 3s 112ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.879027 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 108ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.872127 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 111ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.887514 (AUROC score)\n", + "Running gridsearch nr 778 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 127ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.870224 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 128ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.875355 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 130ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.876755 (AUROC score)\n", + "Running gridsearch nr 779 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 180ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.880301 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 178ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.883572 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 183ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.862774 (AUROC score)\n", + "Running gridsearch nr 780 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 137ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.876724 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 134ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.868919 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 136ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.860753 (AUROC score)\n", + "Running gridsearch nr 781 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 154ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.872357 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 154ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.849907 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 153ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.871234 (AUROC score)\n", + "Running gridsearch nr 782 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 210ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.863062 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 210ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.873208 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 206ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.870427 (AUROC score)\n", + "Running gridsearch nr 783 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 137ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.862762 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 135ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.866377 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 135ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.876808 (AUROC score)\n", + "Running gridsearch nr 784 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 155ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.856176 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 157ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.866409 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 156ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.888049 (AUROC score)\n", + "Running gridsearch nr 785 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 6s 213ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.871113 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 209ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.879743 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 208ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.869063 (AUROC score)\n", + "Running gridsearch nr 786 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 161ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.862035 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 157ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.86776 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 159ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.88166 (AUROC score)\n", + "Running gridsearch nr 787 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 179ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.876252 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 181ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.88044 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 179ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.880374 (AUROC score)\n", + "Running gridsearch nr 788 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 6s 236ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.872432 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 235ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.875169 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 237ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.883025 (AUROC score)\n", + "Running gridsearch nr 789 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 158ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.877194 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 158ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.879591 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 159ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.871315 (AUROC score)\n", + "Running gridsearch nr 790 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 181ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.874268 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 179ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.870436 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 180ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.871527 (AUROC score)\n", + "Running gridsearch nr 791 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 6s 236ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.883336 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 241ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.846127 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 236ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.881243 (AUROC score)\n", + "Running gridsearch nr 792 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 3s 113ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.701763 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 111ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.75426 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 109ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.705248 (AUROC score)\n", + "Running gridsearch nr 793 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 129ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.798136 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 133ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.791599 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 131ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.789322 (AUROC score)\n", + "Running gridsearch nr 794 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 182ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.810941 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 182ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.850941 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 183ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.785455 (AUROC score)\n", + "Running gridsearch nr 795 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 113ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.698142 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 110ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.665589 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 3s 113ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.612971 (AUROC score)\n", + "Running gridsearch nr 796 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 130ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.722301 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 134ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.753098 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 132ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.813672 (AUROC score)\n", + "Running gridsearch nr 797 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 187ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.765699 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 184ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.770361 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 5s 184ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.786691 (AUROC score)\n", + "Running gridsearch nr 798 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 134ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.753515 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 135ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.779601 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 138ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.756694 (AUROC score)\n", + "Running gridsearch nr 799 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 159ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.786646 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 158ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.822237 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 162ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.818343 (AUROC score)\n", + "Running gridsearch nr 800 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 5s 211ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.789703 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 216ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.840821 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 6s 216ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.82497 (AUROC score)\n", + "Running gridsearch nr 801 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 136ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.729646 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 138ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.639953 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 139ms/step\n", + "Score CV 3 : macro_auc\n", + "0 0.641304 (AUROC score)\n", + "Running gridsearch nr 802 of 972...\n" + ] + }, + { + "metadata": { + "tags": null + }, + "name": "stderr", + "output_type": "stream", + "text": [ + ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", + " df_score=df_score.append(df_grid.loc[gsr])\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Inception model built.\n", + "21/21 [==============================] - 4s 157ms/step\n", + "Score CV 1 : macro_auc\n", + "0 0.750653 (AUROC score)\n", + "Inception model built.\n", + "21/21 [==============================] - 4s 158ms/step\n", + "Score CV 2 : macro_auc\n", + "0 0.805098 (AUROC score)\n", + "Inception model built.\n", + " 1/21 [>.............................] - ETA: 25s" + ] + } + ], + "source": [ + "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", + "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", + "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_superdiagnostic.csv\")\n", + "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", + "init_rows = df_score.shape[0]\n", + "\n", + "for gsr in range(gs_left):\n", + " gsr = gsr + init_rows #if previous gridsearch results exists\n", + " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", + " auc_score = []\n", + " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", + " with strategy.scope():\n", + " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", + " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", + " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", + " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", + " cv_x_train = X_grid[train_index]\n", + " cv_y_train = y_grid[train_index] \n", + " cv_x_test = X_grid[test_index]\n", + " cv_y_test = y_grid[test_index]\n", + " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", + " \n", + " tf_dataset_train = tf.data.Dataset.from_tensor_slices((cv_x_train, cv_y_train)) #tf.data.Dataset.from_tensor_slices((X_train, y_train))\n", + " tf_dataset_train = tf_dataset_train.cache()\n", + " tf_dataset_train = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", + " tf_dataset_train = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", + "\n", + " tf_dataset_val = tf.data.Dataset.from_tensor_slices((cv_x_test, cv_y_test))\n", + " tf_dataset_val = tf_dataset_train.cache()\n", + " tf_dataset_val = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", + " tf_dataset_val = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", + "\n", + " model.fit_tf(tf_dataset_train, tf_dataset_val)\n", + " y_hat_test = model.predict(cv_x_test)\n", + " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", + " auc_score.append(score)\n", + " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", + " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", + " df_score=df_score.append(df_grid.loc[gsr])\n", + " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_superdiagnostic.csv\", index=False) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SPSC9F4wPf9J" + }, + "outputs": [], + "source": [ + "utils.utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kvnNlyCX5oSi" + }, + "source": [ + "# Evaluate model on validation data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "m1rgPocD5oSi" + }, + "outputs": [], + "source": [ + "y_val_pred = model.predict(X_val)\n", + "utils.evaluate_experiment(y_val, y_val_pred)" + ] + } + ], + "metadata": { + "accelerator": "TPU", + "colab": { + "machine_shape": "hm", + "provenance": [] + }, + "gpuClass": "standard", + "kernelspec": { + "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", + "language": "python", + "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" + }, + "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.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From a7af6c0f3934ca7f582a9fab23648de6c3d72e9c Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sun, 16 Apr 2023 12:43:25 +0200 Subject: [PATCH 33/51] Update model params after grid search --- code/configs/your_configs.py | 22 +- code/models/your_model.py | 30 +- code/reproduce_results.py | 9 +- gridsearch/Find best params.ipynb | 270 +++++ gridsearch/gridsearch_score_all.csv | 973 ++++++++++++++++++ gridsearch/gridsearch_score_diagnostic.csv | 973 ++++++++++++++++++ gridsearch/gridsearch_score_form.csv | 973 ++++++++++++++++++ gridsearch/gridsearch_score_rhythm.csv | 973 ++++++++++++++++++ gridsearch/gridsearch_score_subdiagnostic.csv | 973 ++++++++++++++++++ .../gridsearch_score_superdiagnostic.csv | 973 ++++++++++++++++++ 10 files changed, 6156 insertions(+), 13 deletions(-) create mode 100644 gridsearch/Find best params.ipynb create mode 100644 gridsearch/gridsearch_score_all.csv create mode 100644 gridsearch/gridsearch_score_diagnostic.csv create mode 100644 gridsearch/gridsearch_score_form.csv create mode 100644 gridsearch/gridsearch_score_rhythm.csv create mode 100644 gridsearch/gridsearch_score_subdiagnostic.csv create mode 100644 gridsearch/gridsearch_score_superdiagnostic.csv diff --git a/code/configs/your_configs.py b/code/configs/your_configs.py index 964c990..21c8a68 100644 --- a/code/configs/your_configs.py +++ b/code/configs/your_configs.py @@ -1,2 +1,22 @@ conf_tf_inception = {'modelname':'tf_inception', 'modeltype':'inception_time_model', - 'parameters':dict()} \ No newline at end of file + 'parameters':dict()} + + +conf_tf_inception_all = {'modelname':'tf_inception_all', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=15, batch_size=16, lr_init=0.001, lr_red="no", model_depth=9 , loss="bce" , kernel_size=60)} + +conf_tf_inception_diagnostic = {'modelname':'tf_inception_diagnostic', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=32, lr_init=0.001 ,lr_red="no", model_depth=6 , loss="bce" , kernel_size=60)} + +conf_tf_inception_form = {'modelname':'tf_inception_form', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=64, lr_init=0.001 ,lr_red="no", model_depth=6 , loss="bce" , kernel_size=20)} + +conf_tf_inception_rhythm = {'modelname':'tf_inception_rhythm', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=16, lr_init=0.001, lr_red="no", model_depth=9 , loss="wbce" , kernel_size=40)} + +conf_tf_inception_subdiagnostic = {'modelname':'tf_inception_subdiagnostic', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=15, batch_size=64, lr_init=0.001 , lr_red="no", model_depth=6 , loss="wbce" , kernel_size=20)} + +conf_tf_inception_superdiagnostic = {'modelname':'tf_inception_superdiagnostic', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=64, lr_init=0.001 ,lr_red="yes", model_depth=12 , loss="bce" , kernel_size=40)} + diff --git a/code/models/your_model.py b/code/models/your_model.py index 473315b..84ab706 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -1,29 +1,37 @@ from models.base_model import ClassificationModel import tensorflow as tf import numpy as np - +import tensorflow_addons as tfa class inception_time_model(ClassificationModel): - def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red="yes", model_depth=6, loss="bce", kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary"): + def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red="yes", model_depth=6, loss="bce", kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary", verbose=1): super(inception_time_model, self).__init__() self.name = name self.n_classes = n_classes self.sampling_frequency = sampling_frequency self.outputfolder = outputfolder self.input_shape = input_shape - self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = 0.001, depth=model_depth, kernel_size=40, bottleneck_size=32, nb_filters=32,clf="binary") self.epoch = epoch self.batch_size = batch_size self.lr_red = lr_red - self.loss = loss + if loss == "bce": + self.loss = tf.keras.losses.BinaryCrossentropy() + elif loss == "wbce": + self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce + self.verbose = verbose + self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss = self.loss) def fit(self, X_train, y_train, X_val, y_val): - self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, - validation_data=(X_val, y_val), - #callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1) - ]) - #self.model.save(self.outputfolder +'last_model.h5') + if self.lr_red == "no": + self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, + validation_data=(X_val, y_val), verbose=self.verbose) + elif self.lr_red == "yes": + self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, + validation_data=(X_val, y_val), verbose=self.verbose, + callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)]) + else: + print("Error: wrong lr_red argument") def predict(self, X): return self.model.predict(X) @@ -67,7 +75,7 @@ def _shortcut_layer(input_tensor, out_tensor): x = tf.keras.layers.Activation('relu')(x) return x -def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary"): +def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary", loss= tf.keras.losses.BinaryCrossentropy()): input_layer = tf.keras.layers.Input(input_shape) x = input_layer @@ -85,7 +93,7 @@ def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0 output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer) - model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), + model.compile(loss=loss, optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), metrics=[tf.keras.metrics.BinaryAccuracy(), tf.keras.metrics.AUC( num_thresholds=200, diff --git a/code/reproduce_results.py b/code/reproduce_results.py index b9c58a9..9539fa8 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -17,7 +17,14 @@ def main(datafolder, datafolder_icbeb, outputfolder): #conf_fastai_fcn_wang, #conf_fastai_inception1d, #conf_wavelet_standard_nn, - conf_tf_inception + conf_tf_inception, + conf_tf_inception_all, + conf_tf_inception_diagnostic, + conf_tf_inception_form, + conf_tf_inception_rhythm, + conf_tf_inception_subdiagnostic, + conf_tf_inception_superdiagnostic + ] ########################################## diff --git a/gridsearch/Find best params.ipynb b/gridsearch/Find best params.ipynb new file mode 100644 index 0000000..28d290b --- /dev/null +++ b/gridsearch/Find best params.ipynb @@ -0,0 +1,270 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "384fcbe5", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "284c378a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "all\n", + "--------------------------\n", + "epochs 15.0\n", + "batch_size 16.0\n", + "init_lr 0.001\n", + "lr_red no\n", + "model_depth 9.0\n", + "loss bce\n", + "kernel_size (60, 30, 15)\n", + "auc 0.886827\n", + "Name: 26, dtype: object\n", + "--------------------------\n", + "diagnostic\n", + "--------------------------\n", + "epochs 25.0\n", + "batch_size 32.0\n", + "init_lr 0.001\n", + "lr_red no\n", + "model_depth 6.0\n", + "loss bce\n", + "kernel_size (60, 30, 15)\n", + "auc 0.87052\n", + "Name: 776, dtype: object\n", + "--------------------------\n", + "form\n", + "--------------------------\n", + "epochs 25.0\n", + "batch_size 64.0\n", + "init_lr 0.001\n", + "lr_red no\n", + "model_depth 6.0\n", + "loss bce\n", + "kernel_size (20, 10, 5)\n", + "auc 0.800552\n", + "Name: 882, dtype: object\n", + "--------------------------\n", + "rhythm\n", + "--------------------------\n", + "epochs 25.0\n", + "batch_size 16.0\n", + "init_lr 0.001\n", + "lr_red no\n", + "model_depth 9.0\n", + "loss wbce\n", + "kernel_size (40, 20, 10)\n", + "auc 0.91494\n", + "Name: 676, dtype: object\n", + "--------------------------\n", + "subdiagnostic\n", + "--------------------------\n", + "epochs 15.0\n", + "batch_size 64.0\n", + "init_lr 0.001\n", + "lr_red no\n", + "model_depth 6.0\n", + "loss wbce\n", + "kernel_size (20, 10, 5)\n", + "auc 0.877651\n", + "Name: 237, dtype: object\n", + "--------------------------\n", + "superdiagnostic\n", + "--------------------------\n", + "epochs 25.0\n", + "batch_size 64.0\n", + "init_lr 0.001\n", + "lr_red yes\n", + "model_depth 12.0\n", + "loss bce\n", + "kernel_size (40, 20, 10)\n", + "auc 0.895236\n", + "Name: 877, dtype: object\n", + "--------------------------\n" + ] + } + ], + "source": [ + "for csv in os.listdir(\"./\"):\n", + " if csv.endswith(\".csv\"):\n", + " df = pd.read_csv(\"./\" + csv)\n", + " print(csv.split(\".\")[0].split(\"_\")[-1])\n", + " print(\"--------------------------\")\n", + " print(df.iloc[np.argmax(df[\"auc\"])])\n", + " print(\"--------------------------\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81ece1f1", + "metadata": {}, + "outputs": [], + "source": [ + "for i in o" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a8d91785", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"gridsearch_score_all.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "92f45849", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "26" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.argmax(df[\"auc\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "71f92559", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "epochs 15.0\n", + "batch_size 16.0\n", + "init_lr 0.001\n", + "lr_red no\n", + "model_depth 9.0\n", + "loss bce\n", + "kernel_size (60, 30, 15)\n", + "auc 0.886827\n", + "Name: 26, dtype: object" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.iloc[np.argmax(df[\"auc\"])]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "780d4a21", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(\"gridsearch_score_superdiagnostic.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d889f59a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "116" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.argmax(df[\"auc\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "c82717f6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "epochs 15.0\n", + "batch_size 32.0\n", + "init_lr 0.001\n", + "lr_red yes\n", + "model_depth 9.0\n", + "loss bce\n", + "kernel_size (60, 30, 15)\n", + "auc 0.893365\n", + "Name: 116, dtype: object" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.iloc[np.argmax(df[\"auc\"])]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb50b4a9", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/gridsearch/gridsearch_score_all.csv b/gridsearch/gridsearch_score_all.csv new file mode 100644 index 0000000..f2b70eb --- /dev/null +++ b/gridsearch/gridsearch_score_all.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7863824497763839 +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8190563386183406 +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8181363021190023 +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7505600991244599 +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7880336409036636 +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8154746947664506 +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7981098204390205 +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8182684852209815 +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8174119749072202 +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7890123426608397 +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8073211024960784 +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8105281862362795 +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8072044339995856 +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8219151971739483 +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8208769699952921 +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7719755568009264 +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7963853479794768 +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8154424500137895 +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8768665534973792 +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8791675756320112 +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8798512300498107 +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8736329134208086 +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8826748109348131 +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8783904742358435 +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8851802420850005 +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8794909066211236 +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8868267284537089 +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8720892311716879 +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8768724302770609 +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8657906232897035 +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8829005424082653 +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.877862457567971 +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8867896703502075 +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8817933019760736 +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.875135969581454 +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8852737124528103 +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6869485870861061 +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6859953311019841 +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7054089920513751 +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6518848364440409 +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6486175626736054 +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6577968506555688 +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6654973215739547 +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7080256701687905 +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7271849920857378 +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6479603632821332 +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6484840382802277 +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6808321261134389 +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6712329721227688 +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7089061664603089 +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7196343280172846 +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6412975761990555 +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6692676661462557 +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6876385702393074 +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8448316597285114 +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8520848949192796 +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8594390025702277 +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8444167468119025 +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8466116109630638 +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8579586153436192 +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8479804633880237 +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8519610484928174 +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8551974049349133 +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8421328911778838 +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8566126614638515 +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8480709831163861 +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8542952796098399 +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8498848112989781 +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8530529888363602 +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8502960582204198 +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8549513021121203 +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8559107717392435 +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6158878929511561 +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6170393069481367 +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6388780383634183 +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6233786934764958 +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6329134537439843 +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6433939035056323 +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6286700666522074 +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6190720415318154 +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6364573568733669 +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6269273609856506 +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6453472952110634 +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6397865311819916 +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6379974682639711 +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6517260313819101 +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6491441410777474 +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6402116155283398 +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6279473834484081 +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6377503518972311 +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6996213442700561 +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7340152552041156 +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7582376554451766 +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6750085414763319 +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7012601821547929 +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7175086571083499 +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7187149696887739 +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7414139674221544 +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7493855242195778 +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6869281187462303 +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7012103463225942 +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7239392500521621 +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.723190166564485 +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7455175137212287 +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7445141117333874 +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6890199214990949 +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7064793884317148 +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7357739094904451 +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7511865740558316 +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7887880011558916 +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7980297216029673 +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.726772103492262 +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7450511123313461 +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.751795803282998 +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7585125979250713 +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7952799064166635 +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7759131686590527 +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.718038210621882 +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7586863812065395 +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7682930537495384 +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7518726611529539 +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7771227391350388 +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7905491802137581 +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7249083216934298 +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7633663385879718 +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7579819959561193 +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8719549204737432 +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8508180095598455 +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8500123537483791 +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8288552568268299 +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8469452040459532 +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8482482317709327 +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8399603936148857 +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8387605429208178 +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8413338108376717 +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8529976317229937 +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8475304207208162 +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8338563337703269 +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8272548683933815 +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8300600796662638 +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8345514607799106 +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8199442845768664 +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8281858288419324 +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8342866833376098 +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6451610701932317 +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6617919295858323 +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6586255633404166 +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.639021459662669 +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6281941837841444 +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6650512902372606 +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6391838901519621 +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.650690056113775 +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6821710616389041 +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6539333358435034 +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.63946352095554 +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6486301711501866 +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6427111205425361 +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6542618338403733 +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7012550470129045 +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6444874962151951 +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6483783663755225 +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6477514465519212 +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8114127760926665 +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8242245841702269 +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8271563928644353 +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7698364678026612 +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8114735608196023 +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8115030850459983 +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.812440257667697 +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8315572005853284 +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8314427084974932 +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8133176398941196 +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8283540546098788 +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8340147255340925 +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8366032110991958 +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8319669012673804 +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8400247159797418 +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8076867919240048 +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8229580292197465 +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8290351965530353 +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6469448505194998 +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6345579662244503 +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6267564855610125 +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6344528121319281 +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6285940115617952 +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6428355735052529 +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6458462132595918 +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6347855306495432 +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6395785984980316 +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6186579404806848 +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.636837340223408 +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6354240553392455 +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6290327189447473 +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6275747085664362 +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6420863440405125 +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6155888330162042 +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6191794668514591 +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6313506240511645 +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6643059099231211 +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6987491711314643 +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7372184452340861 +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6397978560951069 +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6519183364467517 +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6857052015438593 +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.690134198656304 +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7196834681829684 +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7416479543014299 +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6772874090617763 +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6799111595862461 +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6959826468242577 +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7035785980920579 +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7171766820007298 +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7378101165279348 +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6630838043351668 +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.692294456686623 +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7078523268473007 +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7167194567529506 +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7482063732884646 +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7526225798376031 +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6752024846792682 +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7183648529900261 +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7350970217101894 +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7302294338092649 +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7455688698478182 +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.756282941504861 +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.698459354561965 +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7152430410433782 +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7165863057458411 +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7205504566635476 +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7083974594223071 +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.746835213404597 +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6864205593660583 +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6906931856628417 +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7166322740433863 +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.845451528447157 +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8433004316999674 +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8382519997948469 +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8316189412097419 +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.855961035379926 +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8364676031735426 +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8358277274780354 +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8197397248534571 +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8211265184220475 +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8430590730516343 +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8557993284203333 +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8223589134155144 +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8501301070718825 +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8299108859649622 +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7988463693715987 +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8516645424876724 +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8386336459777114 +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8105787241035505 +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6431945042677834 +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6374023512620753 +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6636785628211145 +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6221794311392745 +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6350266782138735 +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6375874307651209 +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6452005477988134 +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6615195568809634 +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6628764334841305 +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.651524353830275 +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6414605271938819 +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6464088980265097 +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6538245189113214 +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6690232926883688 +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6824522321283456 +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6461915631463547 +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6243200736727726 +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6460219447922969 +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7800042470284891 +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7969654505769673 +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8134961557277495 +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7350233242533154 +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7695800031195811 +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7842246226584172 +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7834545690049325 +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8051788767912278 +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8149917951502482 +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7287386198126814 +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7770036683025238 +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7730739495208995 +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.772500042295794 +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8111250728028149 +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8097008225936828 +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7306282639955398 +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7796631674741965 +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7707681554133453 +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6139870958098438 +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6245979844485444 +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.635685573268426 +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6150228554851713 +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6630896341478505 +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6359122597375805 +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6447353283199518 +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.640939425080871 +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6379384783061767 +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6267840451387919 +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.619974645637232 +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6177186488953851 +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6338613767869639 +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.639674672031401 +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6238578864985492 +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.632520951529565 +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6208562706661619 +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6107326405247689 +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.654449727447128 +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6850035541091858 +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6927074568159058 +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6318105055777733 +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6543040831820054 +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6507424175720687 +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6644111482139979 +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6835908351901075 +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7090803148781286 +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6372498634842012 +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6427895559489278 +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6657919080770146 +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6694639400423422 +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7027327461280825 +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6980428674915587 +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6493800232758405 +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6598169201114139 +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6829360272744293 +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7559199424651695 +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7953243707690586 +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.817403228048001 +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.734141801841688 +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7605180624758713 +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7786957054968803 +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7807386270474922 +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8082718983929316 +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8081626632031839 +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7293341202933715 +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7612580214301411 +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.790861735392168 +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7663835778755801 +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7999683460963801 +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8159158783050389 +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7391138099007323 +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7714395689834391 +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7781770059548717 +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8370724147406463 +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8385880235602992 +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.84340450343225 +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8285143835594195 +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8341664743794056 +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8327247163694457 +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8360875563444624 +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8283121457086341 +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.836005279105037 +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8223185702956451 +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8332597561534776 +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8175230851178927 +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.835678540943016 +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8172978133018433 +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8259021724887421 +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8240112347584155 +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8119112637656586 +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8177888928706664 +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.640223377641524 +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.667574310562251 +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6696713729003502 +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6118592944906363 +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.654386810131538 +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6493980183571167 +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6544687878020579 +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6642935913508229 +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.681788023737738 +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6256235499187345 +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6464291597733333 +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6701961229186101 +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6416575643705427 +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6821630433880971 +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7040052405812359 +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.634660310416236 +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6411164932687224 +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6839098885421873 +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8227303722334609 +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8269936284751336 +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8346567582947501 +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8132494858143571 +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8297676471171057 +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8396492916978948 +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8230793491948827 +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8240899698712916 +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8313144407683571 +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8206328869806846 +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8334193604094181 +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8309497406838409 +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8241657464838773 +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8235472737205044 +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8084220726338569 +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8196919159572208 +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8211023091240565 +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8258559759721109 +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6434506319783491 +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6209910448917643 +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6409503356917952 +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6437133130940608 +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6342417813047269 +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6346144971093156 +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6227739117509477 +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6221361664363464 +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6494264134360807 +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6239552217760432 +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6257817248686893 +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6224554935322972 +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6352475688971079 +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6284267618052486 +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6481803320130483 +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6342334057490094 +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6547705077250642 +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6496661714089191 +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6908573578051529 +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7140317365052606 +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.735219428472846 +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6501231874622658 +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6782761224602525 +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7042183879020519 +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6976108450402596 +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7220758911064232 +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7438507265548259 +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6409158291104275 +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6962029696063657 +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7123397090483268 +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6838971882718031 +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.732211078132882 +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7467190453072226 +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.644161474118948 +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7043864553929281 +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.703785476629078 +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7277209304108713 +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7727935653785886 +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7790353008024655 +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6956009079328216 +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7338728913978226 +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.732590993055521 +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7447332469785529 +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7549189017159154 +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7847121113136432 +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7276166427219067 +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.738529821828935 +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7531893025688324 +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7524907544629676 +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.771587991805896 +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7742588213871394 +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7006533578240354 +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7485967600862229 +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7372014907348424 +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8345267256103104 +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.834679783658538 +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8454779630623429 +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8483233849862032 +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8508378015091242 +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8449272341246302 +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8375997943452512 +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8376070586507885 +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8382136418016014 +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8366557604424033 +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8283505189138843 +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8308207285101611 +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8303592241185077 +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8361257334180793 +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8196055033197469 +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8233655710041144 +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8251374848679774 +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8263715661063893 +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6119481192461622 +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6644318622548916 +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6738970019400708 +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6167316050173329 +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6494775453037508 +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6496456552351982 +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.657199152707212 +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6619487477850171 +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.666494892884571 +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6328394521599728 +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6101283324369037 +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6528247435396607 +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6558881566937994 +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6857173758911718 +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6882326343851198 +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6411355673096031 +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6448624334260306 +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6402951461695029 +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8331715983814165 +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8344783943923835 +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8335872848304772 +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8021333466818902 +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8297803434572099 +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8382061253399179 +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8226111641584181 +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8293962044146642 +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8243137643740955 +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8109234559517525 +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8340008917119038 +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8377971075418774 +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8087890435513133 +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8162039121388865 +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8096806890823863 +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8145575997156577 +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8297902195001359 +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8198826960189177 +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6221365473225715 +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6272744880446495 +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6361611890319403 +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6380104017695855 +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6217203706997106 +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6406316682271184 +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6370704339486463 +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6294678236881976 +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6295470269867492 +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6274987307309927 +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6247391360431378 +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6342575873392634 +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6354839501337746 +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6387016559853494 +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6399215984498905 +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6220272449510733 +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.630954178262114 +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6384200832642588 +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.678783751498413 +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7114057268305336 +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7240262123066628 +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6733612343418529 +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6515492747526515 +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6858521227994464 +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6736155490486947 +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7087793608417848 +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7250396564118763 +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6743638673654253 +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6868541961671042 +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.692055741339654 +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6833419054086161 +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7135667668987519 +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7352314970080153 +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6390643497055407 +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6834250106047319 +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6938408328557332 +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7090988480592921 +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7264127520703211 +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7596296559609471 +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.677906319213096 +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6931147643239591 +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7188187865862359 +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7057182691340803 +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7590308519306371 +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7556001191909129 +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.685371539152266 +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7146128314409917 +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7158671274355685 +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7119553622633612 +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7356359225625769 +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7429620675160574 +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6948709554233785 +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7219927504702318 +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7229586429874678 +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8359664436523588 +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8387707452000971 +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8415101557299295 +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8410035712915236 +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.857396175331289 +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8439267963737227 +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8349848136329054 +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8213601832373926 +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8313780697662123 +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8391873113796278 +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8401943089620406 +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8127436935459563 +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8424170998023289 +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8296450426755774 +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8201985353177129 +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8445568714382133 +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8530386231178175 +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8047808263237132 +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6356707443741128 +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6364931922907986 +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6596813176365388 +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6076554151050068 +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6363943410484856 +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.636877788687552 +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6373454777719553 +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6795403439878486 +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6723261980289394 +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6350040012631656 +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6456772245024721 +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6458385299832691 +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6479504402687746 +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6800929133995085 +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6693905581205021 +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6421524730164999 +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6463441460243164 +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6461336474601787 +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7865712745444983 +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8228236778200545 +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8189129418464202 +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7746949713613523 +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7978419731439083 +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8082929818857937 +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7838393317370381 +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8136577754143642 +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8235368077386479 +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7645730809806263 +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7914723957555044 +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7913781462349938 +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7940131804196452 +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8081723268371834 +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8100759903200029 +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7798196458828341 +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7901773850785162 +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7970906687122895 +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6181297278910057 +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6362002974365961 +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6335222411206148 +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6246513039881827 +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.623586294729891 +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6160759942495703 +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6435749516983441 +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6243105474190237 +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6228535589735208 +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6346240754828484 +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6534005446429704 +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6263319989094546 +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6326425665198124 +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6419929988265544 +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6146923490721842 +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6120457125089089 +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6370196448783939 +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6213498817311248 +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6612583303530373 +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6891785692558506 +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7143958192927699 +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6404187111480414 +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6546442433561765 +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6926373814037818 +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6703490616972924 +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6942439421250791 +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7068202477141011 +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6527641931379575 +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6627631661313704 +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.67532813675395 +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6708763076446201 +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7005818041171737 +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7100761096584387 +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6676363932464299 +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6730989049856632 +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6852464889635698 +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7677640902647495 +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7960412748085214 +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8103106084948936 +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7383231914876704 +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7611823078725016 +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7780167938592246 +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7754560981686435 +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7942022572025945 +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8028403166187289 +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7344154831788258 +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7664508553962176 +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7923436364425488 +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7631058458302542 +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8008350727187651 +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8029313214267759 +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.719759919080983 +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7825009377343441 +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7854426427030979 +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8345852388308805 +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8438527436854176 +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8486966289480482 +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8267592888844878 +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8324543184148548 +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8324987451553193 +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8210480751610602 +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8354027124960265 +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8198006216555428 +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8220783867573983 +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8143731194112287 +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8212914014520406 +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8126498860230944 +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8272013466372998 +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8256237923060253 +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8145321197005875 +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8089400651511843 +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8242682069530899 +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6394291103157848 +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6478860260240554 +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6841962757314012 +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6439058377308754 +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6546964424188042 +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6556455610192624 +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6516871064107176 +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6669757766737127 +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7002827626303779 +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6428327117965283 +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6473609858929917 +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6769239074426929 +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6412881133026898 +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6829440311498821 +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6947580070969259 +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6395622369338464 +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6527349481012925 +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6582911242775417 +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8282637877865419 +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8342767472698923 +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8342926770338449 +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8252861361811941 +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8254039572752278 +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8283229414889833 +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8289361008615049 +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8420458167272029 +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8316434344479205 +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8190213308869642 +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8369920478939398 +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8247243260759425 +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8209556951405514 +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8192277276647699 +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8353714579822112 +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.824150883934534 +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8392572880934389 +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8225041008133759 +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6119128103442631 +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6403831422837113 +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6229837651424476 +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6275405141105682 +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6396147795695118 +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.641328448570799 +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6280047237001981 +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6437021119131044 +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6500650346834156 +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6421182417111746 +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6373871574525927 +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6408382693925744 +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6396782704816877 +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6339079102733848 +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6238803773862172 +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6221184218014506 +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6291667591400126 +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6520951806341184 +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7038131407727288 +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7262781059478726 +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7459732595989598 +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6707729753900215 +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6849106602364067 +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7123230753392923 +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7253202707904522 +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7459577685379406 +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7693571816939051 +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6741605125535859 +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7048888717418097 +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7269227949112539 +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6988088542787553 +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7395687509161396 +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7714062765200013 +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6777687803100342 +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7041655558788085 +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7293709719603668 +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7401065797388675 +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7606728632497218 +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7849618642053652 +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6970330202154192 +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7356881513605286 +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7397524784506083 +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7505252327247766 +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7834229873071238 +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7929259145721783 +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6958668457270277 +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7310057761511182 +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7622286666567076 +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7469421138058503 +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.784701329893012 +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7717410695887784 +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7125685141552217 +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7194103706091574 +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7277289475256249 +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8379278286022358 +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8396737347439015 +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8443765754015908 +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8294756653999765 +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8328426538656197 +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8317386748157004 +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8345543726476201 +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8456109701594618 +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8393304062897009 +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8242713614464128 +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.83124559040162 +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8180250624491346 +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8249917868447966 +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8334768872222912 +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8289201779325529 +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8388974194422132 +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8281137799526667 +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8337212628540286 +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6289251750994866 +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6547971401718331 +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6810902294502362 +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6230190889662265 +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6537328272187471 +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6429087640652237 +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6453841506916244 +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6545602859817374 +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.693583005765852 +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6281413918065226 +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6416312690513327 +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6559758533304337 +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6446058695951286 +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6846411285246861 +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6906088400374549 +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6408019876024468 +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6416137822459987 +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6439109237647768 +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8111551717823874 +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8342659066009802 +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8277905224981765 +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8219089459564278 +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8398829279443026 +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8432532055316261 +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.834493164558307 +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.825820001025495 +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8248701378787829 +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8318555628497574 +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8323541564741234 +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8329003017774799 +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8202769964117861 +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8208225616523915 +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8242950490562991 +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8362120569902814 +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8287503572355003 +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8233471128976745 +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.621721974771217 +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6434559585606309 +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6444394571371436 +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.635643153813689 +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6401118993838182 +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6333040269976163 +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6375226949873586 +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6398257829781436 +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6336959421525712 +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6185105660368698 +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6358714568262952 +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6317066479947328 +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.614119337827678 +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6178732409594377 +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6255688515808621 +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6225939737551079 +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.636626173037525 +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.637715328123244 +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6951603281769202 +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7070830285520291 +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7434382049622276 +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6350470364743751 +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6838911141614404 +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7010790710763942 +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6919388338305058 +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7265148854475733 +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7535487511356594 +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.660111056376413 +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6904378362616047 +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7133153466602505 +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7029777853925601 +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7330335778767632 +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.726228517877689 +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6676776999336895 +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6883587094815882 +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6983349723061522 +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7030724703602013 +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7208149884155262 +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7489274179816924 +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6917422838741887 +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7046902019041502 +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7287451385549547 +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.734408300474562 +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7308020501973074 +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7585614647136523 +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6818432519345907 +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7105017354389482 +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7363186519218573 +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.719715928057942 +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7266615597032008 +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7461401457599123 +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6793832012453929 +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6925191556550229 +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7051486488882371 +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8445285233982447 +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8435720597924171 +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8254115719722153 +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.836378419600324 +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8368671282469057 +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8321122759357591 +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8521450700204237 +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8298067988470983 +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8235703755072726 +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8229649458508131 +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8202107795297521 +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8310890277644051 +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8408726650798256 +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8266716202388175 +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8345195167441228 +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8325129540994297 +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8145243891587922 +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8242244886146523 +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6523916599611871 +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.656462986773982 +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6627719707482004 +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6189836543603386 +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6290845859641211 +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6532185859901594 +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6491422160677859 +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6692630171368591 +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6770308103228105 +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6171795231477254 +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6413249633313308 +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6374238902705649 +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6512908458062358 +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6639511434955533 +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.670413771021625 +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6509929412015018 +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6250434503016119 +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6332139886348194 +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8054234027328103 +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8343347722790648 +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8239268476982226 +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7911927260854467 +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8075158533875731 +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8131828686523476 +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8143731730421279 +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8289234336968591 +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.799275530697375 +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7946300106316128 +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8134747974026073 +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8201858049519087 +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8058423993832758 +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8192038107656522 +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8058102685375267 +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7752265491324176 +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8092472397685362 +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7992786999034478 +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6317483636349666 +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6301045368823048 +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6394049401114651 +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6129550744903659 +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6266665551531779 +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6287132239772258 +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6212921690190637 +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.619562212560397 +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6490082056597446 +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6272594680861222 +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6273602688131535 +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6262672826813557 +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6391859596582666 +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6250120115602794 +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6334937088109288 +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.613772577633935 +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6281276700981523 +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6098928675059503 +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.657200010119767 +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.708972114885872 +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7283789387042231 +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6588892025751499 +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.681337933929458 +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6878619172290638 +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6790786037774258 +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7082908793712227 +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7264362413248932 +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.636570397368367 +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.67821830535122 +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6763692060317711 +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6781072788729495 +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7023352395317651 +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7217055588226723 +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6719753426605788 +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6798010679945964 +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6979701524714482 diff --git a/gridsearch/gridsearch_score_diagnostic.csv b/gridsearch/gridsearch_score_diagnostic.csv new file mode 100644 index 0000000..d0c7caa --- /dev/null +++ b/gridsearch/gridsearch_score_diagnostic.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7722236585456198 +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8091926515880186 +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8145831159804523 +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7360905085544135 +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7808003658296991 +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7914176961030076 +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.795159757975477 +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8070248881095899 +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8158954608214765 +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7633790911564153 +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7958860868011772 +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.793317040310503 +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7841049828718467 +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8261557686089217 +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8050293509403529 +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7598284168007963 +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7853155369187251 +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7745264097374226 +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8450734380629777 +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8477453355881591 +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.856750057839689 +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8313281728753935 +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8459541014104267 +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8358238586300989 +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8235986829971079 +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8414018104712438 +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8308804999253588 +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.82886864775353 +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8308400805034616 +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8346083793501435 +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8273421361862111 +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8402253151325073 +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.840361125785465 +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8242793443532271 +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.832698340065298 +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8330229118647597 +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6506607488124502 +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6522395375957902 +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6952049463484024 +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6300674716038083 +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6482654249889651 +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6495419316553147 +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6358426478218919 +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6625606419243181 +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7181659480605019 +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6362524443078763 +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6387411231040213 +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6588010600154983 +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6470330578811921 +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6811940659937125 +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6767543058403978 +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6334683454247925 +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6685811988494837 +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6766093607456828 +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8297841201336912 +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8323754402727223 +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8357231368602162 +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8052457820445037 +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8295706473882015 +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8409475184254998 +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8324144777064831 +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8349183324640954 +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8343611825408761 +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8302551226957235 +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8551413409017673 +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8550110527897951 +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8398105153724412 +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8439956870054042 +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8462793290908422 +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.818654206132812 +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8499670446818172 +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.839014353793441 +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6364332676877122 +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6191182198001437 +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6443952962007441 +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6123347508139134 +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6319630352855066 +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6501443817108856 +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6271923426288857 +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6078315857443853 +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6451460464906448 +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6332510751175261 +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6201097051075525 +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6339082084345434 +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6294170439043234 +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.636084047314497 +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6495692529036736 +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6118555660517643 +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6260788405988001 +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6068817766342122 +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6751008569396136 +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7000095039506089 +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7100044639051363 +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6441031248271488 +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6742590143111143 +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6872369730720326 +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6801902251996047 +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7178809846521824 +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7380885840615465 +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6524905838771379 +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7057063209308757 +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7135700939242572 +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6869209437395201 +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7407874566368745 +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.73295599643583 +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6792492600413448 +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.689430991993441 +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7118310594261633 +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7502654209186143 +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7737314791350517 +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7857634011703897 +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7254357800355754 +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7527348412909949 +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7502198826381473 +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.756995943332415 +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7892645660729164 +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7851475371837949 +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7168615394965 +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7285680306112178 +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7520953532994762 +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7546416540491508 +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7920770531570649 +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7708921696203729 +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7241325908967983 +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7594476998990277 +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7472805879798617 +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8600041620525527 +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8635649866123671 +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8616439561914001 +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8430581977435779 +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8442747299579524 +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8392219787148613 +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8578102429266784 +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8542099398338268 +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8389713860995793 +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8411563645034604 +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8436586636596707 +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8456841352128368 +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8453048419456355 +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8541716242245214 +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.852821999411077 +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8568704390789817 +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.84746780596751 +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8250182496044519 +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6329339579193853 +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6958273499191554 +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6695871307419258 +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6395700953082142 +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.656217032503556 +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.657168500145816 +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6600000170641839 +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6886976653712376 +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6800600573086154 +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6513038222602462 +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6533946983626467 +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6465388779270963 +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6624506395054836 +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6625922064741592 +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6942803234166117 +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6302332148135943 +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6655574495669906 +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6651174589951218 +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8208651366105246 +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8450219624169986 +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8413137579179352 +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7910833939850038 +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8356304372969955 +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8345310803810563 +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8153322506294632 +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8415615101411782 +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8449167359671085 +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7998036072521889 +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8300938732954347 +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8328854944190924 +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8214745434775007 +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8386253282570406 +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8296751167859523 +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8055279515110384 +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8296066051828784 +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.832622666905754 +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6243291231013154 +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6248790028715931 +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6182039243302784 +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6141684647363982 +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6221228176871264 +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6189115364987375 +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.610235553775938 +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6136108983568526 +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6302240451186555 +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6399595445343785 +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6214580894116353 +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6263543360353508 +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6425676675267823 +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.628461975147853 +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6325313234265778 +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6137196666734057 +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6266038705016653 +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6410717137063991 +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6820799412136211 +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7176710797044641 +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7290676959493405 +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6427296518900804 +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6838280206670682 +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6771025688158671 +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7005241326604469 +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7041227625336418 +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7429686369983363 +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6442421903533432 +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6862649630417531 +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6986773855401908 +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7049842883794261 +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7160639447374034 +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6979764261516737 +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6536274477239875 +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6743667727386393 +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6877588337638866 +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7270266321553273 +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7488436499404664 +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7634590882203107 +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6742037347776259 +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6953465202409822 +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7118231681510864 +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7495685394453186 +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7519935802981049 +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7633986144968343 +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7126629386317331 +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7058404365650993 +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7463298112817004 +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7173162080827042 +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7416868996272535 +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7635156272833145 +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7129236193092119 +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7009851191358595 +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7301816160539824 +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8545238852752323 +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.847962450340033 +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8464175794585881 +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8543512490261956 +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8641754907304079 +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8413805627158512 +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8476135691632173 +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8442037197020514 +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8226386186054513 +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8549521599839663 +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8647585558769615 +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8574271998861369 +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8603227960291818 +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.841256009143763 +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8254861973895937 +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8628903381657377 +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8465621005455701 +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8324086989193642 +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6416430767580467 +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.661079407048624 +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6486451207008582 +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6263415689243955 +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.635590910401623 +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6224453067841793 +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6549591879141277 +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6802283178503582 +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6912504070984857 +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.634485614888267 +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6186927157161327 +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6618402366652568 +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6382849425316346 +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.667682135526135 +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6715183834192467 +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6461399011162522 +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6244916879072732 +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6241752911348427 +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7657646865283353 +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8209938765813862 +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8151904111268973 +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7577071088608748 +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7659119759464965 +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7906511062453984 +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.786592594577412 +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8193406215151747 +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8203450592796581 +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7594538855371543 +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7961055505757737 +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7926307371840853 +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7681050102904914 +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7808438670139336 +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8095227727471705 +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7624924486433935 +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7858148451742523 +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7921631460998905 +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6281941147909991 +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6163620674117216 +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6439573210018835 +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6165349536022467 +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6060054091924107 +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5991817802405567 +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6136015876727992 +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6296985416853348 +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6505532440335124 +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6239037278408959 +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6302205321963498 +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6340589108678863 +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6250490107788739 +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6119095155492641 +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6249947528220952 +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6161478041207278 +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6314671452037598 +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.634691011528149 +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6601124679143067 +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7046762146260767 +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6893076062430912 +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6435054399806629 +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6726290133317381 +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6794274624020747 +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6742156338786581 +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.695424844416602 +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6949693981415134 +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6575209578566067 +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6737653903324933 +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.689295576355201 +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6815327732678823 +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7258612943749787 +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7198226919057276 +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6580525318705646 +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6622946891589011 +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6977489078168433 +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7655453887276957 +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8158181131131311 +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8112037776033193 +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7458928170118225 +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7712296430915995 +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7793462867878653 +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7915380339240307 +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8035723224760959 +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8063897719051517 +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.765867014399455 +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7922734968126445 +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7890183924921771 +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7899063363989357 +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8167097963666708 +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8002598180931199 +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.765543423187239 +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7751521415502758 +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7877944463775298 +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8425509973227866 +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8474498829431457 +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8434919251750816 +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.824557923530222 +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8354484691024284 +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8362328400456652 +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8344164545532676 +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8494248946578281 +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8361324501644759 +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8226310635465977 +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8196426704315013 +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8259607108790042 +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8335426242313408 +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8395626422232839 +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8454371340271245 +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8199098517284256 +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8391396642508498 +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.831995204540633 +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6308363450905471 +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6825938225375513 +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6723980599570843 +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6235431379359078 +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.639994736876136 +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6598942049323463 +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6372745550178988 +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6823058242036765 +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.698923079866392 +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6358957099631674 +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6567740962061696 +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6661886517570412 +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6481340096242155 +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.653257993730065 +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.710809216976206 +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6556226714676004 +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6544194294022211 +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6696112066564344 +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8275829160561746 +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.850211757075733 +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.845740672501872 +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8267776949683467 +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8424375851541209 +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8528350573688726 +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8376281167414529 +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8446299282132284 +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8446777256409054 +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8277303013952926 +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.863615265471 +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.853531941031663 +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8390682223829855 +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8327154633638122 +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8246480275980629 +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8305840214588486 +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8478887946271838 +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8371926204221274 +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6199018520272821 +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.623498769046706 +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.612494575804892 +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6114290161134667 +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6222575929894737 +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6383560423270143 +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6332442992659165 +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6445208594151138 +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6311475382503118 +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6407475144957093 +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6336045717246076 +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6254712344801264 +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6256572004530483 +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.646111789996255 +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.646893946953439 +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6165171282917132 +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6202029571585476 +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.62887229171663 +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.695370084266921 +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7287769888280405 +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7427510791953688 +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6601259002034809 +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6906818105636118 +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7131581409540743 +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7200614551318071 +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7295255215170582 +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7475919796195457 +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6770899585510768 +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7220649696499112 +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7182216533842603 +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7176285338556974 +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7400709734422378 +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7553436254098364 +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.674966775212298 +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7007252076317285 +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7280900456783672 +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7330601332039114 +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7620410984112859 +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7846149121279163 +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6871086506122687 +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7267326123922304 +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7600269078669503 +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7510846497356406 +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7923849813174152 +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7940111413344514 +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7060735476936738 +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7588881410991529 +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7549246154888422 +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7506191075052451 +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7746586077984534 +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8060596471299948 +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7239092331750117 +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7403729439327692 +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7286944277264839 +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8541108911865162 +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8610381794494817 +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8578149674472062 +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8446150402917446 +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8333703518189007 +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8420122519621612 +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8429582645743574 +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8497495439701767 +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.857076161545829 +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8385257441966351 +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8387023307164195 +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.830871304116673 +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8574837827292043 +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8553930794218174 +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.844204061349667 +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8365172400442141 +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8333557783884434 +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8399684884310097 +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6532955816138432 +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6931351361032481 +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6982058789200812 +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6178366681818731 +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6433178050924242 +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6574578007331957 +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6533316264372251 +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6798267953999112 +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6800741685692993 +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6506187460185825 +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6353110048055387 +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6639670442961249 +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6354360355310456 +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6523541758546503 +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.693107143410713 +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6307128181988467 +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6614988145535147 +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6801202129313179 +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8253511736915802 +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.857860161060545 +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8581778382767524 +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8125985764728005 +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8392645669455594 +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8478098533192039 +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8446942264178386 +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8479366726364986 +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8525224652559239 +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8233268155351894 +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8384164288560624 +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.848470100974663 +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8410253229952156 +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8428384500974953 +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.841762290161554 +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8323378657126049 +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8268948935584822 +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.834425246947042 +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.619423311686715 +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6253695511119095 +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6413517145731927 +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6262943631053736 +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6079423293757595 +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6153058460133138 +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.599654238550965 +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.627163527158773 +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6486836502571882 +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6326615844026247 +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6165087341347307 +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6188308220224011 +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6331055289795872 +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6266683949420756 +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6561817257468708 +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.610481800136836 +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6272150125996192 +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6306923718812717 +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6822833327060674 +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7245288190917698 +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7400490141005194 +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.666373427418544 +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6939650542809072 +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7005274655228604 +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6997849365718268 +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7273660944042457 +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7523101605461279 +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6817302921107489 +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7133722950972429 +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7263796293221283 +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7266834519955309 +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7244501057991742 +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7294209312066963 +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6877157866276598 +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.706746340008742 +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7083629549855877 +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7259018844639297 +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7265133783875136 +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.744092920484762 +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6630466931757706 +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7234946718977017 +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7415858596782069 +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.729515035958435 +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7322593918526451 +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7793977768794805 +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6730438890690372 +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7024073623639744 +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7177840085841357 +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7285868539549804 +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.735982381906504 +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7295622559859152 +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7229653617857065 +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6959556937715298 +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7265264558762055 +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8501743188462122 +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8634070533200946 +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.830733784320302 +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8520125367551143 +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8414652683330105 +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8373642289024511 +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8521647229866306 +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8581841755049368 +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8168685834172336 +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8541875984844433 +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8447462153583606 +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8343938746164209 +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8444422019108336 +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.841763003004198 +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8332180028308352 +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8347149171459854 +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8283853003232036 +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8367224779822052 +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6438249239712738 +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6510312002599158 +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6641281645368057 +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.647138016728109 +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6193487509393409 +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6575401204087418 +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6202268213894128 +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6657390765116306 +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6697029093540433 +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6371894308335008 +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6461703454635762 +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6471793153817935 +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6541903219905046 +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6820354449418325 +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6886456079419628 +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6295321154717305 +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6633651929792622 +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6538859930322282 +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.817343623493616 +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8205989864719548 +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8331059020248913 +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7754582929144953 +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8115682720113866 +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8213600673534361 +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7948101600983563 +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8176213952598593 +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8295371088461829 +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7840646087198349 +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8242591214505796 +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7992074486529946 +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8045398480119085 +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8196143725307382 +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8213532259031523 +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7689003216464382 +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8013314391044282 +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8032224326802706 +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6387639046903064 +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6262915349112337 +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6363800449062106 +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6086640746048174 +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6155843725941715 +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.608868401982782 +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6183990779580145 +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6310145669176105 +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6361102364522505 +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6373146178731575 +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6131411346574107 +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6348531116077294 +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6413217334854814 +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6378616546041305 +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6352113898462395 +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6068367723876045 +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6199298892580174 +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6211963060347997 +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6780354533598082 +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7036408094544281 +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.722104801839491 +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6644161971009691 +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6660529077671381 +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6979254820998527 +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6847119488698731 +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7057409586792603 +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7223390810723448 +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6531223372965238 +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6804089546396969 +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6824016407704399 +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6808503224117041 +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7111485461840035 +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7154936890919602 +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6447623065337059 +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6696952510781417 +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6836151808881835 +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.774578174708706 +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8103548417359576 +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8056097295981507 +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7498989072079709 +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7725125973340368 +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7883251888226418 +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7977966065773511 +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8013210539198637 +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8095878611175745 +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7625559926333402 +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.774613293970518 +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7870292935382223 +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7748450304021159 +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7961243112033657 +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8160178981758173 +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7653066686639853 +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.772747021673811 +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7896094075738179 +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8413270776519943 +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8474889257890436 +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8369910886868775 +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8172241723972323 +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8287115504158352 +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8408846156027043 +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.839086080608896 +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8479902091534885 +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.851396592560539 +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8436042487739871 +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8155891544278028 +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8475175646316299 +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8447292994031441 +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8393827547903677 +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8452821342925848 +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.846908896781959 +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8343762058724545 +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8473488816257554 +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6385135921242716 +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6739121049467296 +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6946236281118816 +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6295172989171725 +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.634314074883645 +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6584687920158792 +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6331172411332989 +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6685706105896423 +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7148169982397187 +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6467588048733717 +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6407511936465621 +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.666270003992938 +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6605864883715835 +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6880699360332797 +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7054005277277641 +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6541369308863381 +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6605883276061125 +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6665010312636777 +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8399850678009692 +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.848302030396523 +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.837204095296323 +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8311397303855438 +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8491588413226717 +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.844578995024139 +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.841319391544288 +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8395523050780117 +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8488595129843265 +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8303535064837259 +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8536807746887792 +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8366142282496277 +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8222463764930475 +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8358176904872564 +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8332016064681325 +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8274110691972041 +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8398685513225765 +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.822332639258535 +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6069586566848503 +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6170254080284638 +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6292084715632059 +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6116860676221998 +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6362166252311297 +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6348383850185336 +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.619875409291451 +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.62611388718717 +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6589961809042901 +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6212452532019683 +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.621992545904804 +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6100984540151829 +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6164528090827194 +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6282160111279677 +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.640055591537439 +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6389901989680195 +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.650849219763845 +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6229926463859883 +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7084430700779096 +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7373117313437131 +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.762756920470113 +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6725652930739313 +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7021932524312585 +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7211526448302389 +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7230714671915242 +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7637584509396881 +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7677930230608673 +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6886994123528885 +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7226317158998228 +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7507511388618022 +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7192997067402107 +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7290039726318648 +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.762710135961241 +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6871926514120296 +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.733486442057965 +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7368674068694262 +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7539297669719551 +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7830213671688343 +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7840859607415616 +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.701998117745357 +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7298655509989823 +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7718272677673231 +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7544093307819738 +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7905402852325318 +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.785771276371563 +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7146906901164751 +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7587271308008829 +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7742604845661338 +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7645978716674939 +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7753376767830873 +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7995743876048301 +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7276800160436769 +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7534301192781371 +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7692864636193013 +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.850686534311461 +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8560805211160512 +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8705203372555985 +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.85009464146072 +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8465727793713054 +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8537846384695728 +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8442482586983374 +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8434399648145728 +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8451884024073362 +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8408853544837364 +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8424803775982883 +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8513239316401968 +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8413363597578846 +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8403235124033953 +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8489940323345425 +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8359642053231151 +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8250463603332655 +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.820540883364845 +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6626508276423699 +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6536518664564617 +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6886202023581912 +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6491148835714317 +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6621305001380872 +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6669979638371671 +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6596325347730659 +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6778488795391615 +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7016336198644462 +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6320255917357819 +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6458102287954569 +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6656560339595884 +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6539298050073574 +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.70097310880655 +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6967794247259387 +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6321751791565055 +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6562136525427995 +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6603001748673529 +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8457449730404396 +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8629425381204975 +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8411052636821124 +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8356465310923635 +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8615942614725453 +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8568315008914426 +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8482334026051536 +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8452424692808633 +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8258562337578015 +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8561649386921765 +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8574999364309105 +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8501114045816379 +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8190942014422825 +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8303170435161586 +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8239210650588281 +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8426486617047249 +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8475942439176248 +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8498649104157324 +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.625898361658079 +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6297607877355517 +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6385945796422613 +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6161835682207909 +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6131157759917537 +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6335413630524341 +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6399697748962199 +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6325317229489928 +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6212391375362835 +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6372647164699083 +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6139758337004576 +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6214359962091794 +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6169406515673727 +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6441563361359645 +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6403418083402521 +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6139648773699006 +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6153050504737047 +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.622325353222084 +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7054843596255763 +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7448210726457981 +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7657611357721271 +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6742528396496651 +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7011589753247193 +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7138794518697669 +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.719440206837842 +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7381012377110786 +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7526820833119245 +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6752530019379307 +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6858168503323162 +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.730575126848137 +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7142629088742726 +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7688376579158475 +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7252666123196997 +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6841689587633293 +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6925099278347796 +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7239657102798054 +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.708969477240735 +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7326169752460627 +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7557367655202004 +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6817450276444893 +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7132667894381203 +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7284604793476387 +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7346547382675853 +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7542268707441983 +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7451193944035402 +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6903862636314239 +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7336111930374115 +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7389306454899969 +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.733677626662201 +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7644851302999239 +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7384559744675046 +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6886573714351741 +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7274144595700957 +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.717504454874522 +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8604266344288884 +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8498953168324789 +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.837765296795661 +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8508959471599561 +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8463876296250411 +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8365525628015549 +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8480848938815261 +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8376681102525979 +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8472892245956144 +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8369249824761112 +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8228667222687859 +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8372908741730193 +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8490980750968276 +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8387969767868645 +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8447451272345065 +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8357762272586613 +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8184207993568582 +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8143404171248892 +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6218731161650831 +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6463461287751998 +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6636881010974937 +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6377028119988081 +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6116266059115981 +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6386971987429416 +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6475528357075505 +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6763949717706234 +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.662915895816553 +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6332928810763404 +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.655264412269886 +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6543952532265319 +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6526278980224682 +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6551474782317952 +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6630143829458957 +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6312956862629818 +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6476740659461261 +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6446016168407006 +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8190877839770287 +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8350906983533029 +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8261130467912697 +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7901723520312135 +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8125138020975031 +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8295808339227184 +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8239678828578881 +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8180104754793242 +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8398616568763585 +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8368704075520008 +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.823661078136551 +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8367794901142558 +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8099428613480466 +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8260437645821916 +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8273082284386142 +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8031815409166896 +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8231076503860525 +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.806270693175647 +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6170983272479946 +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6322430095614017 +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.624019540158033 +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6107348264232637 +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6280439292037734 +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.635249118389477 +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6315824455535424 +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6035016777246555 +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6490821374804958 +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.61675666786601 +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6462352425839181 +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6186893538472845 +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6332567745653854 +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6280780717928026 +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.640995272442451 +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6174161416857412 +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6271880904869019 +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6207033694731554 +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6701183027582859 +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7094835976257476 +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.72393349424181 +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6697388143095518 +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.652240613822512 +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6922694982257654 +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7008790554534895 +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7049958238868639 +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7481354498406088 +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6484036981970913 +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6915381549487277 +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7012133276848628 +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6849299446714195 +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7292457746778477 +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7162998285111021 +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6596425226802988 +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6729637011851445 +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6985594954475526 diff --git a/gridsearch/gridsearch_score_form.csv b/gridsearch/gridsearch_score_form.csv new file mode 100644 index 0000000..ad0faeb --- /dev/null +++ b/gridsearch/gridsearch_score_form.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7160387950580872 +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7144788277230424 +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7299305547923088 +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.703111626173614 +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7146517412933583 +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7228458154752623 +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7163011257820728 +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.737570339125584 +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7394453900717924 +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6954147848463883 +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7204760464503567 +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7212486276501034 +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.703053140142894 +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7226220629547323 +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7103744088723009 +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7071765463310385 +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7215614019305564 +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7127601148014676 +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7558305513476992 +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7564449596744863 +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7672228945840186 +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7509187164192715 +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7661874445789488 +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7571355239133518 +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7756448306301601 +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.768445975966749 +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7574650192530444 +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7718464579812792 +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7638889418309538 +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7391723004701806 +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7566955163359316 +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7437789169352108 +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7602376661952507 +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7488406536453255 +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.753180155749717 +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7655449799284133 +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6487960147974497 +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6436177167449721 +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6762632135070482 +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6379234175710824 +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6285276186187928 +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6472131268737238 +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6483304269741791 +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6375063245371936 +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6562166656350847 +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6120442932590046 +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6351322741296026 +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6590284781991179 +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.634584933415101 +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6669115339610764 +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.677572718675099 +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6058128313392466 +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6312311937689855 +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6787999799504284 +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7655583575639403 +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7580444242567373 +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7640188734498441 +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.76081766258558 +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7672324816556957 +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7674119183651116 +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7676945532727938 +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7672833759575859 +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.754827223154232 +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7358401090687882 +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7687781385100182 +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7576726781644497 +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7548615942157544 +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7590523389510505 +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7416226505596115 +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7470269640158919 +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7526527993215631 +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7479642119309456 +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6068437772784668 +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6026471767623797 +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6240853146716069 +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.629363725085479 +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5787990319214243 +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5959522021540171 +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5964494261035104 +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6395864058914462 +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5962725549227254 +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6078568944294828 +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6070626317224673 +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6152501390845817 +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6291500189005409 +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5972752897354127 +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.600319317681044 +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5952597946670883 +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.605383815657354 +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6124337065957047 +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6882747859970099 +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6963294879303882 +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6965356674151276 +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6410631619358592 +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6552406876869387 +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.654952575429482 +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6534001890572241 +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6933746538294431 +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7062963293197674 +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6689497664172083 +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6695025497615165 +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6807515678631862 +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6733261472413584 +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6970907185793099 +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6932425324641632 +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6557974660229081 +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6479181117828735 +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6351737729985921 +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7019764420967749 +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7305452903260886 +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7384794390351401 +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6756240434999118 +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7066393700074519 +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7092547551066958 +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7095398995060714 +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7190115071175862 +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7344836412933091 +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6881061486700187 +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7221315664716202 +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7321037533722773 +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7136139445162781 +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7109234420909125 +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7217525290861447 +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6992300765418841 +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7059187595469005 +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6785993791662919 +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7786696710148906 +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7785322314543236 +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7770998601573513 +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.78670487506534 +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.773452757110579 +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7739285794955787 +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7801450201369272 +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7837513626017211 +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7755646716211572 +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7753195045053761 +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.77067950715408 +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7435233817857142 +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.770644034665175 +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7565015380540965 +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7535181966948782 +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.765800363305682 +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7657827114228635 +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.749156580691165 +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6527842730173239 +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6618692538559602 +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6754637895948568 +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6028601236939637 +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6283626866643379 +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.661428341980027 +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.5976215988792323 +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6835220823742807 +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6718915607146778 +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6231120281096749 +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6441151360456068 +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6376792217119948 +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6450468761880113 +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6665466052274437 +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6951305536729907 +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6418657360196639 +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6476857352684928 +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6480578891987511 +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7522931150825972 +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7623802877633574 +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7774891581643764 +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7346677209758313 +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7613846494618342 +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7398521810326756 +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7578649578390397 +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7522294216729204 +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.774077110796124 +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7220479446541824 +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.777382961696246 +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7509936910515459 +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7628232046595506 +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7525075908432278 +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.757873203979111 +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7194320882599569 +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7333689536991366 +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7372527613631993 +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5834789580176408 +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5990807109563424 +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6340293401072593 +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6365124614663092 +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5940914627160931 +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5995730979038502 +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5824941031227236 +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.611054417746321 +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.593732169295296 +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6102962424648715 +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5860931438213725 +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6364356117518694 +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5825620073219792 +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.610948135772343 +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6133579594958313 +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6123311610405925 +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6109244390646932 +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.634354447834824 +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6625669297517577 +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6781418968484756 +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7025314342968206 +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6387037741593651 +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6568792176009125 +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6672335549020008 +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6725585135230426 +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7049317421476986 +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6951952434594578 +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6419979763603703 +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6537043912031972 +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6677731937862661 +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6709720112246131 +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6760068293783821 +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6835140181110191 +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6623589160825732 +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6689159263072133 +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.648745572144844 +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6901929485509787 +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7117703278386466 +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7203994400972761 +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6432736373545418 +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7042027954099602 +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.6852238106633052 +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.706091161958169 +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.6967461982786033 +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.716901517689858 +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6625949396245437 +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6656574473096724 +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.6751882423357616 +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7073797618300924 +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.6806245766157225 +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7108384094156882 +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6568439199759862 +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6719613021674246 +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6952091195902824 +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7917804906622331 +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7691115298632821 +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7509647760509875 +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7839632379609766 +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7896384864890056 +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.775868564626375 +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7692688677215028 +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7648493229799159 +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7463004305198225 +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.775787639585832 +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7531658445897776 +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7558397838270569 +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7689089825009168 +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7601425414178559 +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7066350860084626 +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7847153656042455 +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7417856932947151 +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7330894345117306 +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5960969360936202 +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6131217312972851 +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6504672374776054 +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6593552252901995 +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6479868969246829 +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.663889787806803 +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.5975575555506076 +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6210226061707651 +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6542573275809811 +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5980902621930171 +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6446453445393793 +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6380808223630782 +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6166773586378037 +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6532363827168168 +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6579555164847019 +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6081461523033914 +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6328146021852963 +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6548293617959718 +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.731772228925066 +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7328297849802192 +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7550059517061446 +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.737661188829518 +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7282577924608301 +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7351204443851436 +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7372966006559173 +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7431425156950672 +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7267174524537374 +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7107584059790212 +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7099295191171557 +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7053944390393362 +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.6962443364270579 +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7292079815155065 +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7423791393836314 +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.6969873587753059 +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.6956786193321894 +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7121210726431193 +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6007105998877028 +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6301974516441536 +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6072985436120111 +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5985686807674563 +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6112649989024245 +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6032569213348621 +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6043248836231999 +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5940331141624484 +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5941236955187894 +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5901195279626251 +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5968927767380149 +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5825041094416749 +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6078769291013137 +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.61491224728874 +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.621559612018931 +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6266648396272045 +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.622525370033679 +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6377026606234623 +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6268597028936176 +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6727537494363983 +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6950370983702882 +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6053880837720257 +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.631288729960092 +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.638639183569825 +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6483292146480423 +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6868436142783995 +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6735347804580796 +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6396243181142749 +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6402750102547504 +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6239984358210742 +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6620857687414589 +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7131295873450866 +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6611033070870264 +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6420719791544385 +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6100463369482333 +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.608640289899495 +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.713881957902123 +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7291853776213593 +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7341335704119857 +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6840462231024782 +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7020661327164969 +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7238869074307074 +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7228247447584364 +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7311214282886986 +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7569700252093137 +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7175153047611924 +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7105867499947506 +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7391966665810511 +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7317623491493391 +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7293664423287268 +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7410342266815565 +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7265941534259243 +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7187491413615713 +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7220228904868159 +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7630364007208436 +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.769697472335699 +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.753424618023625 +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7465145427713792 +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7619443043444694 +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7637565473474514 +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7392055365083343 +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7505762662713037 +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7623140749212259 +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.750061138652669 +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7617632386565533 +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7774812264054168 +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7680724395596391 +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7682674521905919 +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7741887427501476 +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7595226424887144 +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7764248267696527 +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7642953485352993 +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6616161176870574 +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6740819527711069 +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6681382116551108 +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6172232826228674 +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6201203464586746 +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6451946121203934 +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6352623693686014 +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6736937636109387 +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6701666467302748 +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6218599114309832 +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6356862676809668 +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6484201562133175 +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6661470242989663 +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6791772784098752 +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6870442351638607 +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.609498854947861 +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6334879112762825 +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6563788710447747 +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7798814972577298 +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7665151805609757 +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7580437045857956 +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7628225973531642 +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7726336141541718 +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7749436842785986 +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.76083284095087 +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7762346188840104 +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7654342261814868 +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7654629146391709 +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7709134181615497 +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7566253306519282 +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7647524453659912 +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7531847191656394 +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7721564227188473 +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7658057262359937 +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7662907080550577 +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7483461641859707 +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5972459243376171 +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6384142105116318 +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6198395427143067 +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6272122401436079 +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6363255954238624 +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6279299526232411 +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5861692467500413 +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.604013920026239 +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6353301881114436 +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6029380586062892 +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6316611595289997 +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.62747869128029 +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5929152518004382 +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6188694282900321 +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6258667203923037 +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5916306951966656 +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6015053526842687 +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6243049751933835 +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6719169180937842 +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7124403941707783 +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7179912441441126 +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6720588949698385 +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6775651950223853 +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6892975859435088 +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6668297530233306 +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6903956547680986 +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7083838324171494 +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6532555367827332 +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6782284318377236 +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6844827883616146 +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6603024375798138 +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6982595783140301 +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6954196573033938 +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6483746581868645 +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6706304290490163 +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6781410614025525 +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6962142453007107 +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7154292003037446 +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7270757758069802 +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6676049305814789 +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7033268518296651 +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7219303856308947 +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.6929358830807969 +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7073917444430324 +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7254762923148261 +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6903935426354476 +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6977831156062647 +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.691939230846331 +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7188918056102344 +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7408666396670432 +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.731623562644769 +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6813212780405585 +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7152089215588756 +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6841872494940051 +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7587481780881561 +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.782371550275176 +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.787233501525454 +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.768804649600973 +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7769245400503145 +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7700262163084867 +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7794674328855683 +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7714558097196728 +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7709660074513418 +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.760368081519064 +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7675577620136798 +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7516545940673004 +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7591117360737899 +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7815121265942636 +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7832262885813113 +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7585392876445539 +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7613361596714118 +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7463168563368333 +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6376322445345638 +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6439968310245899 +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6702137305581561 +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5954127841756255 +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.636428786980087 +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6280769597091999 +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6541976638354261 +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6460893689959241 +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6631797026865714 +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6029640129719033 +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6162033202025018 +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6366674595998102 +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6384762264640851 +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6840330074344232 +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6717237341757128 +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.630709358118415 +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6354456533940271 +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6740285135804633 +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7624559129012737 +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7849017762145406 +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.762429416714092 +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7681188552515277 +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7558351472092695 +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7739021702894796 +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7671158976081257 +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7607981536685827 +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.778662684979194 +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7571316728140625 +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7468376790008578 +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.769500918021443 +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7650541204979705 +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7626468023265058 +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7457795959343722 +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7713882002523196 +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.748017573830985 +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7326944526640732 +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6036527441833667 +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6227144676937909 +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6449934498246425 +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6269609262164444 +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6042618984519755 +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5983172694024631 +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.580997133138477 +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6103580253107855 +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5977935373971685 +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5866755188642157 +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6074068518770415 +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6046510048864753 +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.60569965432137 +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6333345072215099 +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6227953712421116 +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6046653408284838 +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6061351916107101 +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5874284940277771 +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6453536311815826 +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6585322970270294 +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7031312579363963 +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6560839843680776 +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6533041615614921 +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6675906583302199 +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6853518260095348 +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6954857766180668 +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7118126707367723 +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.647101570058691 +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6400096655289658 +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6655928480662547 +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7129748836103637 +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6862450338310792 +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.688019451020938 +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6334245513984468 +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6508931560695207 +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6569038631843845 +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6726168629037903 +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7269387173001932 +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7202004386129928 +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6664941912258467 +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7063745234780959 +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7146887296764199 +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7099971410923264 +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7088040586401362 +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7250072540095944 +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6766325376235848 +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6551934842094655 +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.6857779601757343 +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.6794199897189007 +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7232558898496414 +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.692243502932307 +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6749015010254391 +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6792127793144482 +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6856289492115378 +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7824598523030475 +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7892133006362685 +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7809512786239132 +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7832008185522735 +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7843754412110956 +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7750172842811387 +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.762032949776538 +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7584190497582535 +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7418287602238713 +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7685138034186823 +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7593394675778792 +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7239108346888502 +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7578349975748967 +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7700677223909406 +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7428565982615477 +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7658316587646871 +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.743387678368905 +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7578691972899874 +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6208000577301124 +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6452671350675422 +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6528032081795612 +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6293685768694773 +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6338540866680132 +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6203777900173107 +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6278263944431175 +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6652776392761521 +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.651975171623159 +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6251258959415721 +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6431572865420767 +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6230940443613571 +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6231937403064587 +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6268050592741558 +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6950228835929804 +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6360991005008699 +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6266215385278396 +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6398817517092666 +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7539880600603953 +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.761303668206787 +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7466475283371196 +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7163104448688382 +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7415657609936631 +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7397086766031263 +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7278564923387819 +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7355072941522335 +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7599781197618191 +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7354848905921125 +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7300247190912535 +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7447777809984507 +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7275901300089327 +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7445277173183239 +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7587549869628992 +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7300144536957486 +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7358682618275635 +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7433209423473791 +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.622357482247499 +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6167602252668973 +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.595287588416264 +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6172953646429112 +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6109509148699307 +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.590210783067786 +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5945005813237186 +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5905126667681514 +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5761336558954512 +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6070706615360225 +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6080216456013341 +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6057466623967931 +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5987155963955466 +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6086642843091297 +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6164416978717507 +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6079976727357674 +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6163296340445953 +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.600955288942841 +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.663058624386878 +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6747215398721357 +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6904657191291376 +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6338888812332594 +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6664954285372452 +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6726323331573555 +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6767645044036535 +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7045904195038868 +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7130831259336948 +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6215883852175376 +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6663845201059374 +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6763382965529784 +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6874701574728532 +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7034326884802828 +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.682773456177666 +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6443306922927149 +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6447314693873789 +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6563110680534657 +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6989392444858757 +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7114378178609249 +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7399642001809742 +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6801500399688103 +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7192016259557015 +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.702151837189214 +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7065956411635468 +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7264798408455322 +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7424460555032869 +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6981241351803381 +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7202936096019185 +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7236437815386741 +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7255855127238195 +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7388665696388244 +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7433600709738782 +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6833816584724653 +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7407441102248885 +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.694876974297343 +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7638589434472703 +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7797464364385815 +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7672332896961538 +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7541623641884166 +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7727556842481612 +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7535124935553359 +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7508145484344403 +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7585653047569737 +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7783421718046254 +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7440651943237366 +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7528399220563764 +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7774830053190183 +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7474061776941925 +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7699271286785913 +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7692980547639611 +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7514637901809315 +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7494837473072432 +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7627781758163291 +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6152469399057409 +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6681600196067059 +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6546449161114548 +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6105500772401317 +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6305655406206084 +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6466743304148604 +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6575057859979497 +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6543220030441855 +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6977337002282789 +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6274627963636701 +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.675459923244881 +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6685088771978207 +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6606104285528067 +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6524361540692376 +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6795547261771876 +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.640134224026894 +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6420777912121639 +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6406322848684954 +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7705554179946201 +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7699575288567083 +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7697321694213456 +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7860191068792027 +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7734911245340218 +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7549765026682985 +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7653236076693316 +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7520969313261067 +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7575304339642907 +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7731756200607739 +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7646680028805131 +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7735439694609282 +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7654387325726617 +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7652204905903034 +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7489646814549963 +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7610852540818008 +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7489159113947665 +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7666026688943921 +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.611136501439689 +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6317915599189958 +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6080737492248065 +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5755738751124019 +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6252522146580638 +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6153909366675886 +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6092390411254147 +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6405412555049333 +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6317734300342926 +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6097374790221998 +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.625473746664901 +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6214480216623672 +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6237397985308882 +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6251820459745995 +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6036436235921497 +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6024839552901343 +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6141276056269264 +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6165135533522544 +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6833377935347212 +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7042488780933575 +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7007044882945506 +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6451108597505072 +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6751116085256027 +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6752433418903602 +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6739642584408349 +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7028532631060691 +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7194738013697344 +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6360729841121381 +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.671531568294116 +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7019532805588383 +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6865848153180979 +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7034617778475921 +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7047031465127809 +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6541128926397259 +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6978994069034662 +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6760979614550839 +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6889825165236464 +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7276373193802782 +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7304517843639955 +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6659428885601905 +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6943399622062992 +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.6994323118600496 +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7090930138124684 +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7196696619675166 +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7325139856014703 +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7031657567165798 +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7140253391939942 +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.692446133116739 +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7045591730847206 +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7251742483981928 +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7302255825396594 +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.702573077454355 +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7026943130538966 +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7021354886541844 +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7771461277529988 +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7732281572395413 +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7766233803390413 +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7670252325477244 +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7653588688167394 +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7711149787602737 +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7767508701633336 +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7919576571790162 +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7900522476609058 +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7650844904506608 +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7551121611140824 +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7704189399816732 +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.781613352294387 +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.770746708098729 +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7821048241118819 +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7826915038702659 +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7700793718312303 +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.766376415360733 +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6230985549105131 +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6631306776773781 +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6727209137131074 +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6012249661382305 +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6241188496548956 +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6229062114741204 +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.628163629289887 +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6671231663988005 +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6806265554201986 +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6157650137045115 +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6475345245508768 +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6664580070473324 +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6501266785391672 +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.666490512218409 +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6767203205949698 +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6395765337155305 +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6369714108387481 +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.655210287215309 +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7837145772394601 +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7908885427414377 +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7742193519457619 +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.765380597612412 +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7801503307653178 +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7696243004008024 +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7738445413581556 +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7656344339900184 +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7629113440737125 +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7734787287341088 +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7859099985566566 +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7753734661286256 +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7425502985912912 +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.751299261866138 +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7594082261896192 +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7585122595098822 +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7564960856706372 +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7557743794967681 +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6021543204780669 +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6129621165241054 +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6026706801506915 +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5780914649914792 +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5878861798143616 +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6119985256059941 +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5885078813012133 +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5937945538093897 +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6064194880609164 +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6124196630556722 +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5809115627373574 +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6388232539268471 +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6152934931074614 +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6007913074751602 +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.580138951589643 +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5621168102757288 +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6386553326230912 +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6188160782952971 +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.709402004225096 +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7041772363609985 +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7201708519849044 +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6418624681262202 +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6564477867986551 +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6707579971452163 +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6805331502267613 +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6969335411878657 +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7254520807839602 +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6617706824794158 +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6883984374878805 +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6561280496548613 +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7087285662187474 +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6944781373932857 +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6987543888248626 +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6956571571738054 +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6610043462585674 +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6684232860516331 +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7087306598776427 +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7187818007279961 +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7368210093540876 +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.670663909894893 +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6672002501809832 +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7125630359886995 +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.6848216000209186 +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7285198621417903 +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7114427978991905 +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6701419538642277 +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6980277808681837 +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.6831857160915562 +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7057847441145854 +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.703768702045438 +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.720887314953432 +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6835906070294001 +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6882038653856116 +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6899958138877776 +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8005517340684901 +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7828009722308332 +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.777744312200018 +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7564489657755339 +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7825244759314044 +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7734471189926496 +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7659890369520834 +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7662538988480491 +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7560930006279426 +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7765611854987329 +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.767995730618067 +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7713985421820606 +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7796760344940922 +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7531556140299817 +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7659121254513245 +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7652375158874983 +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7665641280139806 +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7557553286276185 +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6191821105744296 +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.64175623762525 +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6465916130806427 +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6157149684288811 +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6100354863503598 +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6492269369234279 +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6322740199710243 +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6662715302500286 +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6682220487390578 +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6123629378855638 +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6300246951402806 +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6376222473717581 +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6305750666066671 +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6546768327285358 +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.656761435686018 +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6282708713111655 +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6478274657283151 +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6219532413900822 +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7459347031560618 +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.777803397533262 +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7716117150246982 +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7687089073027001 +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7477581309418238 +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.766283493073173 +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7517569434291707 +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7843514444005177 +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7839033612189504 +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7459009575525922 +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7336755986546359 +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7459339345645041 +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7646245551622476 +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7597205615488017 +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.774994163557527 +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7173227575223539 +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7250767649755424 +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7504682210140542 +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.596490332237134 +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6111729739158015 +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6045143603808628 +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6330952128837386 +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5837493849673268 +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5948693505839235 +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6037749737877843 +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.645200652465172 +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6080855385706464 +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5778315508618856 +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6052498426545445 +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5826580820322591 +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.594955470759711 +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6222231002546545 +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.605302549716682 +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6142340607754707 +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6021923684796936 +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6184414191841404 +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6591824984113274 +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.706010944343396 +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6917038866563713 +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6013182985185579 +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.65212889929398 +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6601198154479038 +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6953706997751273 +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6953604944691851 +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6946713252782925 +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6573488298003891 +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6799652192429845 +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6798617447504678 +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6726686864390149 +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6561872718863349 +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6892479394935159 +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6459947390623334 +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6810167493646558 +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6463971786650515 diff --git a/gridsearch/gridsearch_score_rhythm.csv b/gridsearch/gridsearch_score_rhythm.csv new file mode 100644 index 0000000..ab9566d --- /dev/null +++ b/gridsearch/gridsearch_score_rhythm.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8266728401334588 +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8539871598117351 +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8704825466035099 +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7663183739957345 +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8503065381880203 +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8637991313810315 +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8345407299160946 +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8554800638138529 +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8890243214994102 +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7926455277561589 +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8789147031813259 +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8894655353870277 +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8485005702161897 +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8743572057477396 +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8774772927724843 +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8414478263662364 +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8729208700809017 +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8950384587484885 +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.881192886651784 +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8648103266529374 +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8730502760336726 +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8403958479852215 +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.873627824705018 +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8847454411513191 +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8754054201785103 +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.887429631741241 +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8769903645206342 +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8816089370030474 +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8905082089144395 +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8975545482860241 +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.874380169514745 +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.9066267956925876 +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.873568855162373 +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8773689156851697 +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.885535610353588 +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8777212287934937 +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6704134720893576 +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7125223896168823 +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7583064671024909 +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6419942743866476 +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7258000778841232 +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7596346563242956 +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7078933697934082 +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7680808394266548 +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7784954891148071 +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6730908877208129 +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7382730157041987 +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7565360588995862 +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7272546045550049 +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7773356250705635 +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8001725604081757 +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7102925150043441 +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7639752614017649 +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7408655581829943 +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.821918074012088 +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8675601514470869 +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8706476171840162 +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8333517184788981 +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8430680349070663 +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8751543008770019 +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8615141429612226 +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8667997901080797 +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.858925837986256 +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8672177772284709 +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8871018799220897 +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.873143324193633 +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8453000823665905 +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.828939574671903 +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8929420978555885 +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8511136643983163 +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8565245294479497 +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8792392261613168 +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6730918140780799 +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6497582924308718 +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6841394375733447 +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.650533149771106 +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6806060091309375 +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6933064147005293 +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.658440381664271 +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6414879577595931 +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.7162040001890212 +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6598180103332373 +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6764351811981091 +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6358740040620927 +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6228405210146195 +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6314136570215991 +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6974838469332997 +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6540387728340195 +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6905445175032896 +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6678250017718473 +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6941549285170755 +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8119221513210936 +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8058446872197068 +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6836564836810598 +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7426270438700352 +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8000506031815492 +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.724601334788777 +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.810637506523863 +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.863951035895086 +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7053847532012849 +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7877573968614172 +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8228684290859345 +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7539060432407033 +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8322067445889044 +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8689482102882174 +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.740618071085713 +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8479862527844234 +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8490469323540227 +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7803629088523794 +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.834674210430113 +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8719943782554246 +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7394525486832969 +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8498518129049982 +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8502708017141706 +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8128365223516522 +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8762175656291807 +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.899636960843853 +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7359695737875659 +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8663245161346418 +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.843030223170082 +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8130494636951392 +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8484066358283386 +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8549085969367534 +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7916605137931146 +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8693037117222934 +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8544366368065336 +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8770190096946059 +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8582598133220686 +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8693521542960997 +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8747621567042555 +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8565709738056907 +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8500528089506386 +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8717867031130343 +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8845813412112458 +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8815188559927041 +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8438824088831797 +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8725233095543571 +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8626164438355817 +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8388156546210418 +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8710856155233978 +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8617355987012195 +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8617313415463329 +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8674953097945158 +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8371985467443416 +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7065695046448132 +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.742575217612656 +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7646651401397601 +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6501062105719884 +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6964370211497424 +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7465180030091386 +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7336025608791642 +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7318642379051394 +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7772939188987839 +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6958935707996199 +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6910376119649501 +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7487454750832535 +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7029104043096869 +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7677231163229434 +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.765363607903725 +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6587530538615392 +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7169493227541287 +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7556101826645397 +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8041626887602621 +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8760409385172946 +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8781858990473409 +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7976519650087935 +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8417950636478685 +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8590866198030325 +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8611608809355963 +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8584978413567771 +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8537246849472698 +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8493290968499001 +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.868972478091 +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8527631798038874 +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8574615322020609 +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8714000003834698 +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8596627268415166 +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8407461100953784 +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8742901899215555 +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8466797419154499 +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6730282607540663 +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6527772719666376 +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6833986494055746 +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6484350228904973 +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.7025122701024723 +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6165897038997831 +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6508971208087618 +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6881577915974817 +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6581244239202976 +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6475510615234014 +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6749102936843504 +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6796762027028752 +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6335305795180921 +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.674297044200365 +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6836000728157926 +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6649758480839724 +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6911744880414835 +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6695366221099569 +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7014373436292641 +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7617201578648191 +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7902362610042398 +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6637347672283352 +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7330214349116205 +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7611677845025634 +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7284320955403958 +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.78936766826493 +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8380861213637787 +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6862464986574359 +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7301043702122666 +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8333354519559228 +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7336316099155176 +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8007951048336092 +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8100514249633194 +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7226884337793144 +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7790155834600204 +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7850950466890486 +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7495758556397871 +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8315753862271041 +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8710055127271756 +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7364576670481578 +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.787672598923249 +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8217612721350912 +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8078801098622016 +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8530087063487457 +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8732578183137761 +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7315452720399928 +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7932894656816929 +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.867402887859106 +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7994359764145967 +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8452146827877197 +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8559008446423562 +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7760259045040621 +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8277374452654213 +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8539592000179564 +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8769205029052003 +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8809930544784161 +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8604459342254404 +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8381307737817356 +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8489315426117653 +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8868635518220214 +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8895091162891887 +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8776826410523578 +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8683784074381743 +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8873249911098829 +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8809382174002659 +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8291130969313669 +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8857606105544996 +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8561188827110603 +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8610793041595873 +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8640878843425885 +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.883161719247803 +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8548038763789768 +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7092343562363858 +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7304042248841339 +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7286558973649949 +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6663103206444968 +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.697617849300233 +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6983599795527718 +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6835177246500965 +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7484720911245689 +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7701504957712126 +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7044240267619813 +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7012506222466697 +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7413704961879942 +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7091668781053918 +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7370649546346968 +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7575233706539258 +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6711943291487925 +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7192008846846197 +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7262523497850387 +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7918577448374879 +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8785857108690371 +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.84945918552559 +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7871401288280993 +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8711614714892214 +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8756107100524755 +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8295667141496298 +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8698579646889945 +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8711080264750057 +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8154081438586381 +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8888228382527837 +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8242159885808079 +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8218261427235 +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8732793846724117 +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.859804837238419 +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8445538719494959 +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8820428168136165 +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8697736263418103 +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6382276781755061 +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.701856619508638 +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.72827843648473 +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6197896262849681 +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6896782494754947 +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6331992465523415 +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.722028485823388 +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6562084036278721 +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6677275048437529 +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6993083122219796 +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6846687955759689 +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6536963043014793 +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6449451357006475 +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6802202001399089 +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6713357410709997 +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6973441029681512 +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6616828284740918 +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6772565729898008 +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7048766722607295 +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7682615428652713 +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7935412373756033 +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6362366921437329 +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7262728158859416 +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7895667089530374 +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7126633846914329 +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7735764704125768 +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7812861013241958 +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6873966590096853 +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7507692552109096 +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7730818775363698 +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7671583073027769 +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8122203080863525 +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.792901592059242 +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7353745624299989 +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7444094582398573 +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.782857378856515 +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7634373589058195 +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.874871191460138 +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8607870618228417 +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7842764616701897 +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7921938490362873 +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8616930696777972 +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8308453685304076 +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8691570365309839 +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8709173870135897 +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7920687515424034 +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8522811626614389 +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8855480677170949 +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.826437387701623 +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8737282324572914 +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8469615666337577 +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8302225630675414 +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8696909882231091 +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8809570324269274 +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8704692898080991 +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8787158715679007 +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.9019086599517372 +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8461797127666614 +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8836570165451422 +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8861467143190631 +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8818734499099149 +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8760372095847232 +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8772910620647488 +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8531983767624202 +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8649050911487327 +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8682634887311268 +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8658246929290255 +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8790765365347665 +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8759197933806991 +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8837715210972649 +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8876975803262209 +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.874765959801302 +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6949970330765121 +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7000901590553882 +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7769795867876326 +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6605842569653313 +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7006538799961274 +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6991591663726843 +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6885996434702578 +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7899192667009437 +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7907329527841784 +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6606154191769916 +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7504500012155696 +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7616345462557295 +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6970522813160648 +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7886989630676138 +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8109184430445276 +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7132962744118124 +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7497806861421403 +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7766066221289679 +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8506573323396891 +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8522237654805661 +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8656210504192758 +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8318372591911571 +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8695931403478494 +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8568193472030655 +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8210614911572095 +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8501900307212419 +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8728487996048883 +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8575590042096559 +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8763390419082452 +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8877908944377623 +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.832676401194221 +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8576414067238235 +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8757160051393873 +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8651336041855694 +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8738497787797965 +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.907573470031358 +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6851633757775032 +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6875933248380416 +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.7010224547373268 +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6654449049388829 +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6489796908960134 +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.683018010280057 +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6753542365324082 +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6703915824138589 +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.7103811089960287 +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6471732368000885 +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6494832775946341 +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.685704776736295 +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6881995812011552 +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6711793954911763 +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6890320651761178 +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6883699913531753 +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6238329350078083 +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6833578416403733 +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7231455511462198 +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8017327571266882 +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8422690555541145 +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6653556178123029 +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7612582906289195 +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8499711470469782 +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7904567364937884 +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8445358708072538 +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8638411339665493 +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7326254326414025 +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7987906047132602 +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8384666780548781 +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8044234663450927 +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8484010262079856 +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8604404090940679 +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7334323345247822 +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7908386051405768 +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8614383995330842 +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7717964365209316 +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8529296210019387 +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8832485554678029 +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7600575450035173 +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8217500137836081 +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8523739224847167 +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7855540153124205 +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8666404077981866 +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8946326003224713 +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7872540427042738 +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8364155015438652 +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8756946435032806 +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8044195071539947 +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8225541740071313 +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8361367645598143 +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.811710020247964 +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8681793323922734 +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8623949640476428 +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8596922528379819 +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8779244978092721 +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8853390676602008 +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8153907563570001 +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.836262540308821 +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8359731178839572 +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8668121189015672 +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8873227615031923 +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8878836678890645 +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8566182771902394 +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8541839455729524 +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8696330029482232 +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8637562320155352 +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.864424764607453 +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8702030339646912 +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8704035156920026 +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8861012377014542 +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8624578019893749 +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6877841733723153 +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.72619685865901 +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7426886948990766 +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6685164648945041 +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6758142470124032 +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.717020949983799 +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6938418793630228 +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7332146869183079 +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7663743056138851 +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6752413618281238 +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7108589659517063 +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.751965455315676 +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7343655448921368 +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7716391335852119 +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8063332812843163 +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6891794568611523 +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7499852518916873 +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7188626088377902 +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8308926263198012 +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8452213340875786 +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8789290230026038 +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8153383490581388 +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8684107053881407 +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8771605986787346 +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8348120190485292 +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8369153469927829 +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.857238556886495 +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8407951015192506 +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.889226287856035 +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8619748305309015 +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8435536403562033 +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8546485454940687 +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8608527820751165 +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8464769866690717 +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8520136374297803 +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8379446614484327 +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6766281367859229 +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6442028310089319 +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6469934348459844 +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.7176744109941967 +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6574140654925343 +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6401571648040592 +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6669178649549785 +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6524980912635968 +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6796390463982425 +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6859627712913254 +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6764399035973666 +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6841659318643704 +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.7021507279096882 +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6647774838012612 +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6731549642832139 +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6706003019323186 +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6548299042391253 +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6841506057941742 +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7269517495432565 +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7805064562353999 +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8235671176482399 +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6882498353016514 +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7422778863268703 +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8150502897187449 +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7412450009067477 +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8070476251367565 +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8570789273807223 +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7172206925483585 +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7672145998938781 +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7704804162085733 +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7529008707059875 +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8412284762273279 +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8313608905852082 +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7383052676347178 +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8556238644258171 +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7797152721795556 +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7786521135907581 +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8394557304606778 +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8491489507244386 +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7404958477509415 +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8153835205481056 +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8335809234696319 +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7694638672284974 +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8521929792888091 +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8557823207309906 +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7598121116176665 +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8374316208041491 +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8224289749223619 +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.822560433451379 +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.874899267851637 +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8245034618799915 +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7804071741518722 +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8094142353462993 +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8193451846882246 +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8655243958338273 +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8685273755418567 +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.851393865580791 +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8571937250192153 +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8649207740373531 +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8779249661811529 +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8740491878940743 +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8874547540701397 +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8656455778326052 +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8581007106326904 +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8777884690809356 +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8758791566885841 +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8607213583646532 +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8657438986999823 +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8775619586738931 +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.860314873454083 +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8592809235161109 +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8596817345748645 +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6505095934613113 +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.724704748176745 +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7611028352943902 +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6567843471526157 +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6888772136637362 +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.696417118104455 +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6424728441568024 +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7686101073468491 +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.737324567454762 +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6820289836602642 +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.702664049280855 +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6816729423145637 +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6708016446938467 +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7474731782513554 +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7417413669715555 +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6652164665640933 +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7089274267082054 +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7101594176577956 +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8290080189670556 +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8615025407046737 +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8712328915989581 +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8270322612854861 +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8409997587551096 +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8899619681953251 +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8398061533829839 +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8781750816322264 +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8886115801073154 +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8456106239460451 +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8759656502025609 +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8728770578327297 +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8600550638638428 +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8670003707168416 +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8609180267204346 +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.872045606268603 +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8770104648325168 +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8663862412663542 +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6302437248481007 +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6544150693704119 +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6975794831072863 +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6825022744534591 +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6686771668277153 +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6331156144448961 +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6995950815875053 +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6344769248854122 +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6673618196611714 +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6173900343874585 +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6790325092539726 +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6284780242214021 +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6939759642238146 +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.667328164638901 +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.670825060357921 +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6872859334536635 +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6826727987954024 +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6651646873244692 +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7272614533957699 +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7752914191616371 +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8338883475562205 +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6931168278817283 +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7543950641307097 +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7503506021021839 +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7677546390404798 +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7930714448136619 +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8473097399628654 +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7268759106315247 +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.733417876945527 +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7587976264263485 +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7431438413940176 +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8110270701159058 +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8222599451450856 +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7532287276763557 +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8014539445786717 +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7637923021127749 +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8007055107712636 +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8111401599655931 +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8597424720962404 +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7854718254998171 +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.841298160283973 +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8569062125289238 +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8444463499829498 +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8985908220262266 +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8906803024185869 +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7923255256422563 +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8840164772363587 +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8831632808455501 +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8557519072375833 +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8625377757673646 +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8662416952966182 +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8351990130131114 +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8583289669518526 +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8650823747566654 +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8787861647384538 +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8674765741380281 +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.897217200731229 +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8493300749024613 +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8823291864225623 +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8777203482276624 +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8639670343864226 +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8900825698910758 +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8925883728249936 +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8646087917988963 +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.9149398333298526 +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8965267524781245 +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8746831784813768 +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8945902052054003 +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.9092855925935228 +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.868590824120158 +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8932163510231644 +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8836782618251551 +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.664486969190714 +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7023876350220378 +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7697879620997284 +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6434109651594578 +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6967503057470735 +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7757552180232888 +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6895166073141715 +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7719674535997548 +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8097421539589115 +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6453439426376325 +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7228676777850845 +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7182140190615319 +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.710758505573526 +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7592896872609559 +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7731948502738915 +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7103908878778974 +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7269971907379631 +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7651542045350886 +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8372217870410982 +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8400676627689716 +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8608631005781984 +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8331263958869136 +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8978382980758693 +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.872673438257732 +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8416484747475729 +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8752562609604758 +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8527940894919911 +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.854893910789882 +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8966862059151781 +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8585905205607863 +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8562677140525671 +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8832181013087436 +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8893650575699491 +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.850997291333361 +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8926256506112907 +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8795116110710278 +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6822841560530887 +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.676363392433883 +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6842833347264129 +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6511014762284463 +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6645874060582871 +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6676649891815117 +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.650970649757562 +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6889934448277687 +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.658647373675532 +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6616161969294524 +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.652259778067566 +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6752723241623036 +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.668506438799774 +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6863957285392326 +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.7080359427387389 +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6561245280457473 +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6881094195435812 +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6688108062579254 +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7265511944652491 +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8093563469252514 +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8286366768558135 +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.702287436413742 +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.825505655629115 +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8221346742681486 +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7833876509520402 +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8744418763461469 +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8558845062469013 +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7488575902947613 +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8181731268182156 +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8600061330684333 +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7944799017873599 +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8629281098723668 +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8832870868728762 +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7618664969399952 +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8545462950393775 +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8282674969783025 +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7722901849779714 +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.830706163047167 +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8610376740193507 +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7384183563724213 +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8060371927246807 +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8535915441643217 +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8448954256905857 +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8609792466491446 +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8533169985648689 +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.793869697360042 +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8470878763356989 +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8668449239718882 +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8298641228258856 +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8710962632721463 +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8796233328879431 +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8220414416238482 +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8441335891852894 +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8657850216363915 +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8335056473609792 +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.875697329827659 +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8848684416684138 +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.841633216849684 +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8606737717521736 +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8552290875856579 +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8477065360109016 +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8501955349103844 +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8655722956924924 +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8632801140069842 +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8696768824079553 +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8554730632116377 +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8681355914894672 +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8725773455246678 +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8706001702804088 +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8669292377576734 +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8516059302651452 +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8401136651973448 +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6653253590201039 +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7084177485559066 +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7530453093147202 +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6503093646537615 +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6517599899088483 +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7076052575710658 +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7130154118774946 +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7092219842604078 +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7914548612194255 +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6666365199981601 +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.741547068062047 +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7329425084538288 +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7233710766830334 +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.794247050993422 +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8144680018129465 +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6827242777123078 +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7446465630163019 +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7640478310863162 +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8239020139463887 +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.833619821901821 +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8385453165331013 +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8153582534436318 +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8622558399445784 +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8292803552350044 +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.818344523962951 +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.842614170978608 +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8464663961040596 +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.838555782931162 +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8789934580826645 +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8317881420705634 +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8329904132396041 +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.861024994828354 +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8881072135486109 +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8468707010333719 +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8777144536555784 +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8412822633976003 +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6522423743624256 +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6804179907624408 +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6914528099629328 +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6572398273839625 +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6740682303033093 +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6830056509975502 +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6881683984212033 +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6522926859160109 +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.675124646133774 +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6639583660098837 +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6801989123674693 +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6465195374952937 +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6228458782651703 +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6851850489809582 +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.7064532740834283 +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6913435859323488 +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.653059175237721 +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6863385344352597 +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7235331477868554 +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8001643641459902 +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8531407006553321 +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6988662398070252 +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7684683852787879 +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8667321300409107 +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8491311762471595 +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8782826946995783 +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.881402823548281 +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8205174071551223 +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8496250271591119 +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8658380410649543 +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8650910186302406 +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8802016825701425 +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8714652473663532 +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8489617213265016 +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8669316289482651 +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8479963549461643 +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8512849521340634 +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8840000648519092 +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8863098826724766 +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8541620935304399 +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8649063428853943 +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8652465663600796 +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.867422370023406 +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8847697441435193 +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8944396244488004 +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.864920358702648 +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8730585927170919 +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8687541929811061 +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8824281896551233 +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8896552725995935 +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8868693672058622 +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8812635140045364 +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8862012190648233 +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8723601171746639 +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8749756571388415 +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8659526684073876 +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8611508454588236 +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8694072682769605 +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8506458453021515 +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8585341711793633 +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.868475275260684 +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8763822978001237 +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8648387347769958 +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8693424593925498 +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8770503652130149 +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8515659490410908 +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8746048512885825 +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8706678410301371 +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.84267819639796 +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8657892458071138 +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8716246037993205 +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8596337123943997 +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7205194374194583 +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7756294640482585 +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7928793259390664 +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.615639848801533 +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6909757516106204 +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7505621569623234 +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.746077333799375 +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7908567407965957 +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8134813415836764 +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6851686315669926 +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7479672671744305 +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7722691344476136 +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7793448734243421 +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8063971212366695 +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8140976187612493 +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7509653217007214 +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7557991054173278 +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.805232361831628 +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8898872996320395 +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8854160580480291 +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8801011762468276 +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8847426200907952 +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.883121789474472 +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8730684994926476 +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8740467897901333 +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8650242748556295 +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8584014401126119 +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8766577934457974 +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8726551056821354 +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8662955940082512 +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8334142977841275 +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8571222401971701 +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8749997680371676 +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8560250508804326 +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8287497164286348 +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8575565529526248 +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6871033950674293 +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6600854239356059 +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6347933200458628 +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6600976304232719 +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6847331124074031 +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6204278582341622 +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6864067305105612 +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6848880204578304 +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6528612453597834 +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6457615777530995 +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6312192414180592 +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6757628998342057 +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6520006623962669 +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6998564346531085 +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6736209530744569 +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6718484554051894 +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6608898003251579 +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.664665882644688 +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7004816607043006 +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7960721976760453 +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.84341668127814 +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6876301527893499 +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.760504448718021 +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8346388560597316 +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7387031050479931 +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8030303091778203 +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8329734208821958 +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7367955142215531 +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7767884350360746 +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7570581105598676 +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7750688011369106 +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8332764211725016 +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8204372486030659 +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7301139098181518 +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7538368283614756 +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7812894492635043 diff --git a/gridsearch/gridsearch_score_subdiagnostic.csv b/gridsearch/gridsearch_score_subdiagnostic.csv new file mode 100644 index 0000000..a572488 --- /dev/null +++ b/gridsearch/gridsearch_score_subdiagnostic.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7807615847292481 +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8273952199909033 +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.816541219601261 +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7874201089571099 +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.80491790634053 +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.79446558418359 +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8024633186571609 +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8131053894212582 +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8281741192788802 +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7918973619414748 +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8125810424718188 +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8168480526853527 +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8117336707241325 +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8260458391099362 +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8352476726847465 +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7959396282459656 +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8181648074779426 +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8071386637304306 +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8598723932821173 +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8657245657808886 +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8606214797638106 +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8526375997876302 +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8593280384341743 +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8560152603047843 +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8523981067618447 +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8549795638014307 +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8606635181861345 +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8441291657421318 +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8376733689352083 +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8390691374221341 +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8390784191065433 +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8611338854822966 +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8533065490609472 +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8374706322877019 +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8400341070075231 +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.831473379012796 +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5793598661801691 +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6436127354420278 +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7037732608666553 +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5579997356949605 +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.5888678896856064 +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6219933433243594 +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6189323335853237 +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6777140814663801 +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7100222307822494 +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5968250701882761 +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6295038140350557 +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6263172590657694 +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6516977999062417 +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6866884175203523 +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6926483556008375 +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5885607412825307 +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6319401431861237 +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6486045017129186 +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8214592081074837 +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8404617651211844 +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8619680203660393 +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8413205391237689 +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8618286558332011 +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8612145619809836 +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.824439584381394 +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8604240715267147 +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8414242084300488 +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8475583082319353 +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8616367321384244 +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8548681858750588 +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8456429963557043 +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8470266371147193 +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8392796754499966 +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8361825149865837 +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8405448452426433 +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8461362160700862 +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5524363483743371 +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5469750099020755 +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5794427741684406 +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5590583793496537 +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.554269604967374 +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5641351604799479 +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5822744332250328 +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5925917875671735 +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5894573827020865 +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5648424427370101 +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5699094727726988 +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6030675412320762 +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5770587859174233 +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6183171607550709 +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6005490366134332 +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5773984113932286 +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5648651939183158 +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5771858483843473 +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6520480997270486 +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.729150451568023 +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7615223667261425 +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6146100802532813 +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6799540794278988 +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6857641724705538 +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7003470662477992 +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.757811391082908 +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7443929644605402 +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6545720592199546 +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7323167560749227 +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7319451225664788 +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7194377643167412 +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7402690454267985 +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7742557186061778 +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6795878808803589 +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6963516575190729 +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7200648414233993 +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7644182816357681 +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8082300837490305 +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8118689824960686 +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.70842692226199 +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7804287212791837 +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.778008573833812 +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.786212819705352 +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8320260684657322 +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8001840795322405 +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7542512095186744 +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7755790613878064 +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7892825832205747 +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7998429116017952 +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7899674555354531 +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8180066940013914 +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.765429533083655 +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7895385484069211 +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7547080097260476 +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.871906710179764 +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.862811273005121 +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8686688771787909 +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.86835782572691 +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8528335372482855 +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8424245424850584 +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8565873654573554 +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8393234996013433 +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8358846068050342 +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8430294037887288 +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8543278315457496 +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8312659456750647 +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8483907454368153 +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8340548203043644 +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8282639822547774 +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8412916118043979 +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.844681002833035 +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8368952899108647 +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.613553523936743 +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6806153369218576 +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6849583989020737 +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5955299375593763 +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6204548102941806 +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6537679322231845 +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6133530503419247 +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6930930795912863 +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7098146959780692 +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5996845880451497 +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6101080351310417 +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6408856464919733 +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6437011066671524 +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6945588702499839 +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7104043575484714 +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6079116615635868 +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6167509769705654 +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.653058263792088 +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8434313997523496 +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.849239592733609 +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8443361967666746 +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8238308817123504 +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8484952947548265 +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8560745405724509 +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8294750198210794 +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.841700722661345 +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8514268589907162 +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8465079014914384 +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8723314786852088 +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8577323770276554 +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8278834907027499 +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8423968967366524 +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8446636932787301 +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8256056011952362 +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8545002664714548 +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8309669781544428 +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5575560991484205 +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5692992202085477 +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5825603334685345 +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5666354354274156 +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5501367463099327 +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5644967802799276 +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5459553499021301 +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5903577743213032 +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.610135969190151 +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5774073532559462 +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5484628282243033 +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5726143993930021 +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5623048933509728 +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5747156033001612 +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.575624794368773 +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.559829775503138 +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5841227048564407 +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5793632226523883 +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6674018627640491 +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7029214642375315 +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7547416393684062 +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6014696446639243 +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6820200183263845 +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6885127690247556 +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6941458545369047 +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7245381672708792 +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.742185068991911 +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6133594585446309 +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6877474423336754 +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7175189378775761 +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7268455384858271 +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7398895494495362 +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7713003470766354 +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.658946117726908 +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6698487013363402 +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7101512346154101 +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7227585964527458 +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7791241794883913 +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7906991558923462 +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6773615115878101 +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7054695057248446 +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7762794443481119 +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7723066937154868 +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7985492434125594 +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7785030844858118 +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.736230288945125 +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7722103437938831 +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7511329642725205 +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7757877198275421 +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7622249943398384 +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7989290031548472 +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7141057769837493 +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7567773794926076 +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7527663930525543 +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8608623041186182 +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8700635522563279 +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8636903711230574 +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8776509739249669 +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8728923216108976 +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.851983490241468 +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8553652782737884 +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8413681414950601 +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.843099137424812 +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8563888151187058 +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8366816425007689 +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8560090653608725 +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8420332587258104 +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.850064266989516 +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8238749466558937 +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8706673327368634 +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8680745672320915 +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8471967473661924 +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.592748511453077 +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6603572623993715 +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6673797570165223 +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5722609346948656 +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.5970269336493744 +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.622228695805879 +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6265829956669838 +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6523381993866294 +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6885214162133654 +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5968860320337743 +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.5963967151511571 +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6231158230887489 +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6391116870946928 +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6811508400109029 +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6717884017075155 +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5953983683430742 +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6308376297480127 +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6227393302417955 +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8152049675692301 +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8355069622097712 +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8405197867652189 +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7888964841661936 +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8223808730532225 +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8483980447435974 +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8135334635088979 +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8423915128656811 +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8474169174484517 +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.809242290614709 +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8317763143795328 +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8293774912418307 +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.827995389034294 +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8105922841471697 +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8307207728585851 +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7847098546111934 +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8346753290681234 +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8210544950354413 +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5658208932187813 +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5807321740366146 +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6014833525677522 +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5679959354032148 +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5487808449810435 +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5642759321676243 +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5659274023279539 +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5589082221017168 +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5693422069438321 +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5413737593390845 +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5722452065940034 +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5772512220827918 +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5696094816695666 +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5666125666204898 +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5697913950398755 +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5867568503763511 +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.56488733023698 +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5571889325353144 +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6462564602147699 +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6984448455009483 +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7259345508895372 +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6055823777398887 +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6568380315072554 +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6591861063775132 +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6608741159443118 +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7366091248392111 +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7390901905173163 +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6363809122811754 +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6789142040375711 +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6999073748308858 +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6843185955435396 +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7111152330513163 +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7119707137265084 +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6145747273707568 +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6648772376365341 +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6341196737916814 +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8012601253358916 +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.806824974558059 +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8223548211999904 +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7585075971084084 +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8181535105312802 +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8145348552426342 +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7980541590476817 +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8162932397946475 +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.829246963681547 +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7908829871093378 +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8224570796499364 +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8092746263137086 +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8121352304806662 +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8150779939279511 +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8276691054119848 +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7824921617917276 +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.811520577947062 +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8256182833656968 +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8528926078257357 +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.867343862039519 +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8615528002311397 +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8503303965707004 +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.852832623691821 +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8530207305847236 +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8420307362283316 +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8620730760349918 +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.85003987648309 +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8492242774654931 +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8514640716272971 +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8562960623740072 +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8476226220737407 +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8544742834881203 +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8587753808855635 +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8330724460756005 +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.860402863688161 +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8494724240987482 +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5897534416684068 +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6340899717776195 +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6492702908951197 +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5694875410303426 +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6094635084353407 +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6644945871483625 +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6338436630902863 +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6638374345546433 +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.699850413274192 +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5814950070258688 +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6190318904503294 +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6251988652120873 +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6424154006478325 +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.69691627593905 +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6872586068635131 +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5817773798164146 +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6412679584534937 +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6429827711033974 +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.835352353840721 +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8688790163559258 +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8411638017071575 +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8267071046165556 +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8583828755312873 +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.845224216257149 +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8437657966114068 +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8484755995894216 +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8594171649955468 +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8453214997846326 +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8572771076216306 +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8408252395830679 +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8358087897369724 +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8186416423593471 +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8310606404905783 +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8305348808636365 +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8508909088523122 +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8377255604448791 +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5732894668538423 +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.582556001061074 +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5872903526999326 +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.54915616104225 +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5814238629509513 +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5929722140502037 +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5700421859020666 +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.604544677736434 +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5932717734145031 +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5842956073035998 +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5701318561903005 +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5797570194720901 +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5813359794672879 +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5727054629889211 +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6144151946142021 +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5833722185787638 +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5659146726684421 +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6123922682910868 +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6958529641365826 +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7423335063286025 +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7952145906523514 +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6758350930191241 +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7266475029635435 +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7231048918622806 +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7206129590732789 +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.767126835604818 +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7957535639711294 +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.674050868176165 +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.722669855599955 +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7289605332772705 +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7106760140554512 +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.759306187518504 +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7862437846475174 +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7097038924079709 +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.71898882711722 +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7277459262253242 +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7651766193968695 +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7785928502665117 +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8185939377446253 +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7321659362585459 +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7762989521373896 +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7678581786866796 +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8020768223983644 +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7897413357352638 +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8336774822191746 +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7384370523392333 +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.787567158803102 +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7986536586479271 +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7910926649813786 +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8011913901647508 +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8113363819594502 +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7783934480957271 +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7992452049290165 +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7824379097963022 +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8677136227297856 +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8613864844286286 +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8703992596214372 +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8593858721979458 +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8642463333363378 +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8747837660829378 +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8418593505483395 +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8474351967418164 +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8459002327469506 +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.852107168025292 +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8458568239845287 +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8439062600118404 +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8418061925423816 +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8423659989073166 +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8493569840280434 +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8402309564173577 +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8401484225486996 +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8541185446068488 +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6198899573880374 +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6727587732462984 +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6814822685756021 +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5791874130942049 +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6363875301763376 +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6485723040947519 +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6418282256649618 +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6877092187700836 +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7219933520818409 +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5927570487158923 +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6422296775977167 +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6652765952033698 +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6207815168392771 +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7041087843165795 +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6941885615594998 +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5807143620756333 +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.633798854664285 +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6517900817889606 +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8411948268255361 +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8702210401563254 +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8506899878281127 +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8330671828425129 +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8537265358219729 +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8670467829295149 +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8547007147477742 +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8528756595768403 +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8056448482642885 +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8590960225976532 +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8616188365198965 +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8570530808299028 +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8237216398019593 +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8242779335763272 +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.809610531251141 +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8343889652226558 +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8503591334603545 +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8557961594072356 +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5725813046509874 +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5605548028349282 +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5672058973460543 +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5896242083645005 +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5822124251762533 +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5662748252603889 +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.566478533923616 +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5883861842675855 +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5748201293509047 +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5760920485170883 +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5699642994874559 +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5590338986085913 +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5859477878738697 +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5762113599292725 +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5878533424602564 +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5806214421114433 +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5451151899328895 +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.562614246920703 +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6554523062363583 +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7416918811324155 +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7670641447466083 +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6361475821254089 +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6568246545564174 +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7162049279538257 +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7106338575771237 +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7183715953389447 +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.783952865740709 +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6402545701774421 +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7154274900102845 +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.731018556985802 +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7212077910697152 +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7475808744300236 +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7738625869659325 +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6782108436996847 +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7225626316011425 +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6981313083537248 +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7395123681440738 +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7780351454831257 +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7958990830009648 +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6929861564652636 +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7272100201726258 +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.739116528216054 +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7428157095572862 +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7714874693403894 +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7541021128284185 +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7177719447639171 +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7399499462447908 +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.738966191843203 +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7485682645673286 +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7811877742073089 +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7626110520961107 +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7128952645012085 +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7306476544323065 +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7304826614036509 +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8586261824335337 +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8576109573830778 +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8582477460792832 +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8607863926735754 +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8505031687238348 +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8570355255271421 +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8524109531462661 +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.842211052731891 +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8355786005868538 +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8554667537787436 +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8652376774006312 +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8494918651589942 +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8690479057251843 +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8429027070167194 +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8406985606217202 +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8626185789903555 +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8357713423592047 +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8173065196919117 +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6001645418890544 +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6730051017016864 +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6583558543543444 +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5590440078761879 +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6052029938066602 +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6015211303882305 +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6112523986963891 +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6455492484192669 +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7085808043637064 +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6024053828178696 +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6123571876118225 +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6327212833107947 +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6385958633521712 +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6780683976113532 +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6804075169318389 +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5960114684088472 +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6118482419656184 +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6240020395317788 +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8114792337930687 +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8495367376558303 +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.832790630553578 +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.802659475352025 +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8270713376380504 +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8380338035155774 +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8351930975506408 +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8411981633843196 +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8421813276689843 +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8199442791837143 +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8433687908897856 +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8577630405357963 +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8359859251743845 +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8273824011812492 +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8361599817353146 +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8329557820796927 +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8466949664588294 +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.824150242484451 +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5621320627370554 +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5563168955421093 +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.545081830079103 +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5339905270448071 +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5856231373709095 +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5453941636561469 +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5521729546849204 +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6068921557204114 +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5791789803315307 +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5614577284575996 +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.551570364846471 +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5646073537045094 +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5758318115701773 +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5442578432864673 +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5522136405577976 +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5338975490962096 +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5555189733430811 +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5699785459527696 +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6589760997181475 +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7308541905413176 +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7488504332363232 +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6296752474937598 +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6552183582920056 +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7177342682864226 +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.715332321072923 +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.738684178007088 +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7251538908051126 +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6513564335468566 +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7135614183314417 +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6828426838407555 +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7090206088399379 +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7221467721347657 +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7616674414479969 +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6539799737751874 +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6735535738512789 +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6756070790495629 +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7832398705853283 +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8234582164408749 +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8310647472505127 +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7576382533558074 +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8128836377346372 +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8300367062283843 +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8074468351298245 +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8143774081979203 +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8362535013549638 +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7734156132478877 +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8069627869945308 +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8331835845975079 +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8090068202996061 +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8052211198837215 +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.842251790003257 +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7771813619365143 +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8364979816123536 +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8302825309464721 +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8455974259165839 +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.85811801260274 +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8572774062171112 +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8284541034066537 +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.862430666394106 +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8623918024047801 +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8353745632709991 +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8680855733797186 +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8555263259956267 +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8336301749611358 +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8704020193063409 +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8531792261894312 +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.83011340690706 +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8747276522539028 +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8715373607872495 +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8333958058889706 +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8655905895532042 +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8761596919043434 +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6373996198402004 +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6441974981530211 +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6697182296141558 +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5924216162618928 +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6059560578347051 +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6344053031223705 +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6239126917575942 +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6361298854549549 +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6823745013628559 +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5900014221072256 +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6306056097632524 +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6222080561569346 +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6442163247222609 +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6766287779138264 +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6977252992216343 +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6036557035347001 +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6312490928146522 +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6445867658620412 +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.838106655436882 +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8682758662386001 +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8458884107444926 +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8553501702533802 +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8655351121703855 +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8440974942060268 +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8629477638181328 +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8396073891198438 +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8412979985387944 +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8378986503756645 +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8524378640405884 +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8477592551648824 +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8260162244067342 +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8322549365322409 +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8463156478156978 +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8330537902299652 +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8390387411341664 +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8337158650865905 +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5591128313272938 +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5334900392913972 +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5898916864205149 +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5360646550711018 +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.546609175094851 +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5764417076232662 +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5818013938347155 +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5659253809239505 +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.61557528513525 +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.57995041488938 +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5698006124051679 +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5717393626314234 +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5591948966293951 +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5858984827135902 +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6036418344458864 +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5358805618325806 +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5610619641017912 +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5529499617051673 +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7171192221182965 +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7557693957925121 +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7754883136272528 +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.662752679209631 +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7174267269686257 +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7388051726886146 +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.758313484542072 +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7753281788907218 +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7982847023050471 +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.707293076100297 +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7583527188472426 +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7847293600229962 +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.752001970160452 +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8111640916052508 +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7837562610514687 +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7154965225703177 +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7743997188741405 +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7531796843249289 +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7671972181906234 +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8106707759434459 +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8075447817968485 +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7350668743014804 +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7538554599055446 +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.778350521863667 +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7877654647553168 +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7859726031179401 +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8212348119527687 +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7581958748775989 +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7667655101536769 +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7887718995414793 +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7985901137931658 +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8137762805528745 +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8027257852882065 +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.739722612390988 +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.80281505526514 +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7691165472231326 +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8522911599147053 +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8776465008326796 +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8683689576640141 +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8465593910193574 +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8557996602729898 +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8570972019786183 +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8513402864727974 +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8586628234861154 +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8406618575510877 +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8621747853536231 +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.861794978948946 +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8600929756464315 +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8504418111921058 +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8469336466700662 +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.844996973837106 +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8652586900135097 +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8546580518087924 +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8555924646928214 +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5950311018711365 +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6531234008995005 +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6680221975270814 +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5874242365815406 +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6209589965969771 +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.644606440352427 +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6249200830404741 +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6890049956124108 +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7073929221372856 +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5945762499578847 +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6422573878912582 +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6330675818532431 +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6378386968204909 +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6677687891619982 +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6938764733828576 +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6256164412547931 +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6009138767352619 +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6585209011489012 +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8403929900300838 +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8590389117260141 +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8423298904149829 +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8421765001459365 +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8721205913389212 +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8420229991003124 +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8546881596167631 +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8331373341244223 +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.835182160563492 +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8457774687785204 +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8478478184819802 +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8474223128195809 +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8125213870089286 +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8387178141902846 +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8162217220199838 +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8529226000551389 +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.842526325314302 +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8347068485932976 +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5810432513326697 +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5727786235971828 +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5885314622364128 +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5583729515058885 +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5457395697657493 +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5774819266416836 +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5957877833305008 +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6167916246072758 +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6045733921552093 +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5357251181662347 +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5885418523476487 +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5825876239378851 +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5814884195484928 +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5926396752980879 +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5938917111583984 +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5649443056974834 +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5596126693569157 +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5549161855700947 +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7014846112811487 +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7331127142455832 +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7583898183495482 +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6636947664112886 +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7023239567555155 +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7211538015727227 +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7309047656307065 +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7678922446933857 +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7869522393653319 +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6581481730932565 +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7471623172251437 +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.742551205265687 +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7414214792935581 +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7653009194887398 +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7728622608624617 +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7000127339791883 +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7242941270985416 +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7113141302212943 +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7233597487957857 +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7619692719294395 +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7787207407159182 +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6969543177118321 +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.724495281068955 +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7472664857520307 +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7393837234754153 +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7783849207174489 +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7707680020641062 +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7199460504950065 +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7583697948124956 +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7744849081157762 +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7565652120475063 +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7891836763229342 +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7930296848758037 +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7161553040497166 +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7042120607817847 +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7945062449395318 +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8478977662855477 +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8559902714335271 +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8486502842950556 +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8549858191889538 +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.855401323632904 +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8398174450739493 +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8418345136163791 +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8654959331869866 +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8434816440734005 +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8429654164230581 +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8434297153490918 +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8333145434017957 +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8578354325379299 +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8454612901127515 +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8480906617922771 +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.842071267914128 +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8547954391050863 +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8426815226632026 +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5898490849045693 +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6416209680910205 +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6569735816760003 +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5706720027138628 +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.5919357506234306 +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.590940994033472 +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.5911138396193722 +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6746963664503548 +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6983244438547785 +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5986649793796605 +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6098436442944902 +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6074612627380411 +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.5999844584716164 +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6586438243588825 +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6801966142341639 +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5892984056771313 +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6080927174152099 +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.630545907516866 +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8443095193168914 +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8524456533174223 +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8560765678239791 +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8283598417495335 +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8613541914737587 +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8559980508592245 +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8284594279465328 +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8441353867607985 +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8394146055014176 +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8329123445249925 +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8501923621943991 +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.833858806905171 +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8299647529689985 +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8175124096041358 +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8169811456956699 +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8375974984520133 +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8242673663862887 +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8292300700363153 +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.564972614079232 +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5553555409883263 +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5972921527507876 +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5596629238341896 +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5602956506912936 +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5720865049386453 +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.583774904366308 +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5734661152163635 +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5653306236209694 +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5394860258386148 +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5756300945413382 +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5696598719423195 +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5995169875328019 +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6121975687213909 +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5935843655019252 +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5688430107825356 +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5676939106418968 +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.580848316154564 +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6842945329335691 +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.722977748373112 +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7516413993862553 +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6211898441196773 +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6722812796574367 +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6991480982979793 +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7274782330595125 +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7397232209362364 +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7502568413543883 +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6219066341076476 +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7118183170815784 +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7174754373738156 +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7144897043409094 +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7373045485784617 +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7808075001195302 +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6493145006766172 +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6909914658486659 +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7048347885571795 diff --git a/gridsearch/gridsearch_score_superdiagnostic.csv b/gridsearch/gridsearch_score_superdiagnostic.csv new file mode 100644 index 0000000..516a35c --- /dev/null +++ b/gridsearch/gridsearch_score_superdiagnostic.csv @@ -0,0 +1,973 @@ +epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc +15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8635507453453629 +15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8822205602426204 +15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8830497028394327 +15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8580690599710122 +15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8777740062526068 +15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8759406446041019 +15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8773875315914273 +15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8890570347018402 +15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8847244326337185 +15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.872621836169249 +15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8825745206218821 +15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.88433734131227 +15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8833659282006776 +15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8883648862352462 +15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8855242408365355 +15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8712253822225713 +15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8821730609255996 +15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8833827655486409 +15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8532545651491518 +15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8501066113516434 +15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.842981872125122 +15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8427946031618133 +15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8462891828077375 +15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8306827951389352 +15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8445513882781107 +15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8417550455164053 +15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8523287822483977 +15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8474248955860227 +15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8475281237180039 +15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8542359578418242 +15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8600713602397146 +15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8478317392194276 +15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8472825335687381 +15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8441565270710994 +15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8433880533927534 +15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8382085022175004 +15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7614187339748035 +15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.8030171690344918 +15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8208190048442624 +15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.7150674896422121 +15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7752628038046613 +15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.8044359488961023 +15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7735721323860937 +15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8103430442567946 +15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8342874023951947 +15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7379950216624459 +15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7930345364905494 +15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.8225446741731748 +15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7647416798209475 +15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8141257930314941 +15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8322835992932743 +15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7429136823344095 +15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7628708475737738 +15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7939554026497317 +15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.883218243628272 +15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8790352136279876 +15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.867052817500442 +15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.869739173635808 +15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8773540989760308 +15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.857907960484226 +15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8759796688964298 +15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8645895618366053 +15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8600878573586078 +15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8734119270559494 +15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8570880637462465 +15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8523470019827868 +15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8510559150379463 +15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8753859599134367 +15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8666610944712847 +15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8391795631562332 +15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8560207623796963 +15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8618978782939054 +15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.516674549626693 +15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6217725829446129 +15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6639465609967791 +15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5427336926436351 +15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5571048644855805 +15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5919208143513317 +15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5358281704048925 +15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6265641841323444 +15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6813177873753063 +15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5386541913450515 +15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5967077850960022 +15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6187480358804407 +15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5484892827455368 +15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5977705629044351 +15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6209309402470965 +15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5278871619992659 +15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6211823516182161 +15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5872587195671896 +15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8218515277912785 +15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8451554816269318 +15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8616213139422019 +15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8003699309259531 +15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8283531731678205 +15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8463662655178504 +15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8260208954298683 +15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8607189744678466 +15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.869306734053357 +15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8251920948481679 +15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8449073117612299 +15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8555137121691208 +15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8449614732658682 +15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.868621279024036 +15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8718883047949885 +15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8249448946258312 +15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8496216974799146 +15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8540044390657296 +15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8721997501143951 +15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8875044157324555 +15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8905391530208657 +15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8508549703263425 +15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8843157312175984 +15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8827435814182598 +15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8785590639854268 +15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8896458878478727 +15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8933648078269852 +15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8814217079421511 +15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8857985830609847 +15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8812652096375793 +15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8883962904174192 +15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8929986488354572 +15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8866708325316816 +15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8786198724853388 +15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8867765608634421 +15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8847369892056473 +15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8681369895585588 +15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8684641014452098 +15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8687299546393433 +15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.866401357417898 +15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8502979019561491 +15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8532634914804319 +15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8616042787364423 +15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.85905604213674 +15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8598795628973003 +15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8493777184875467 +15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.843957288797383 +15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8491003444221533 +15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8677218834843518 +15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.873416721536543 +15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8588610995477381 +15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8473682649573003 +15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8620305755404472 +15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8591760041728346 +15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7360442701089247 +15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7965255100780434 +15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8181727387310973 +15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6623736651031805 +15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7553870008955258 +15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7913077432016603 +15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7734342627550879 +15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8161531638120012 +15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8199253513970199 +15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7543512190211098 +15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.8080358473659071 +15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7821976862901948 +15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7771349346785831 +15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8089873721707274 +15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8210698928314799 +15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6786979972599824 +15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7608773055120657 +15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7914832022942903 +15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8837564555394963 +15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8879909364126467 +15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8611557506135665 +15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8847635428892682 +15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8823401769214131 +15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8711451282624276 +15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8804895974847241 +15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8710094514387919 +15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8808096998294727 +15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8721177354760327 +15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8730130529555921 +15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.869396229379246 +15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8657263864717221 +15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8660572110028334 +15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8731359709900479 +15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8683244922098962 +15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8580153750517164 +15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8671492465287999 +15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5239685097055199 +15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5909390527241682 +15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5753787119470891 +15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5425488830830031 +15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5738301798105298 +15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.4890679650189568 +15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5756458516467188 +15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5913946875631081 +15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5651174914035435 +15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5253564055602679 +15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5521947148992575 +15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6269554963577425 +15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6162743189974952 +15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6298757984043589 +15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6278358681885488 +15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5461515922120329 +15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5572403074187009 +15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.571978287067164 +15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8015887708314119 +15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.835716594586765 +15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.861536322938652 +15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8064820737841623 +15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8147541989758963 +15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8316385431213863 +15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8297660978336904 +15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8639547524830183 +15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8706109006413038 +15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8137247461516907 +15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8403361996508764 +15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8595436902309229 +15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8399398223007388 +15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8626025102531392 +15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8587376080187051 +15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8391850809403021 +15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8557932950655798 +15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8480242523073805 +15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8489273369487322 +15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8786668877959142 +15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8847698256834212 +15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8263071576280009 +15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8564733071379461 +15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8689545334650631 +15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8642728521809099 +15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8861590476279982 +15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8906009512571482 +15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8594771649059462 +15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8595319472590628 +15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8708294636009623 +15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8780186839421399 +15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8874003021194561 +15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8893539136875791 +15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8749028318546316 +15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8694510548645195 +15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8812659811002442 +15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8744803420039678 +15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8753181937973055 +15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8483329922503288 +15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8632348971165195 +15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8730532050422776 +15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8466525226191018 +15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8525779065074343 +15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8398727763303726 +15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8343028974192777 +15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8666397465006174 +15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8430772657381156 +15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8449230035580557 +15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8525445459474087 +15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8275962196047351 +15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8208690759137302 +15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8509603353223257 +15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8336307329952181 +15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8332833258575477 +15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6637211576530545 +15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.776348504134202 +15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7968748430453734 +15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6520798853555139 +15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7506737973921026 +15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7579067884235867 +15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7374091103669996 +15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7810200559064926 +15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8022774128211309 +15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6905454505681554 +15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7441197838213132 +15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7881739804382925 +15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7516108283760236 +15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8074896205139824 +15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.818332599405185 +15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6822956273084956 +15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7981946129123592 +15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.732772419658643 +15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8842322950628567 +15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8884776586835356 +15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8796687465360368 +15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.880483338427528 +15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.884879211812892 +15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8648185070802792 +15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8887292712475533 +15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8774176298509856 +15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8592101260153561 +15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8879686945776258 +15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8777065619900363 +15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8706215146881983 +15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8843540060742988 +15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8713986696917003 +15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8357380655090743 +15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.875681537954376 +15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8778967035472262 +15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8667717558229374 +15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.530382058286479 +15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5849637551318967 +15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5989284665626066 +15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5855948148412321 +15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5265904329654676 +15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.587851972971349 +15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5465757067301951 +15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.548251486898229 +15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.541613543903151 +15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5024787068443165 +15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.537536475601708 +15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5784159739964272 +15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5580977367597698 +15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5668969865208346 +15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6230681652069091 +15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5141277467009419 +15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5397983140983077 +15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5726356247792952 +15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7931552066125724 +15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8322403727979352 +15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8514898168202811 +15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.7664210972735184 +15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8202605832203567 +15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8276818446879736 +15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8173180718697709 +15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8342719841203777 +15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.856322147156296 +15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7916215697202055 +15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7909390013615315 +15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.812403841586116 +15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8224769509089397 +15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8514823242274542 +15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8612483451545733 +15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8148189781014147 +15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8062126304047471 +15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.782353477403516 +20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8654911213760851 +20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8825115925049265 +20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8861780173954655 +20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8520992811134144 +20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8744414246831363 +20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8786558606281266 +20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8770649717157933 +20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8894404478601873 +20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.889569942377233 +20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8715065621944529 +20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8793998299150109 +20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8891001519503963 +20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8784929293713857 +20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8858108995481379 +20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8856727257761795 +20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8764150125688625 +20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8831603973786507 +20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8714821059288077 +20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8535619994638376 +20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8517365134013821 +20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8586093033594921 +20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8463900933984014 +20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8577196022208143 +20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8538382731212257 +20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8511982267092167 +20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8511215928499118 +20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8651609565270236 +20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8450370318493077 +20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.858450433073395 +20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8524030426246753 +20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8294316712963923 +20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8430887398180914 +20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8477613863676323 +20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8470017764087262 +20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8680881579390838 +20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8564693027438227 +20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7678051730080008 +20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7774449479492517 +20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8035401500289453 +20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6988765743350118 +20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7126808220446051 +20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7651477037675543 +20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7863795242030157 +20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7953405782892821 +20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8352111768417917 +20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7480483330130844 +20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7482445307695539 +20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.8065296379863272 +20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7815631444861372 +20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8262683154127752 +20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8388800035574681 +20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7360764411376962 +20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.8041153310461023 +20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7936149697239964 +20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8789086986752485 +20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8746866135908561 +20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8667991408120158 +20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.872387074865887 +20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8502108368508919 +20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8401191368536042 +20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.87569290678225 +20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8642636444553625 +20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8667848066840653 +20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8539682323367321 +20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8641263877382769 +20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8682882684026957 +20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8710380522891182 +20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8597158170312763 +20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8630165916618973 +20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8519370572867967 +20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8626505837361638 +20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8731463477908319 +20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.4806919045598271 +20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5624166518607286 +20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6415217476508008 +20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4654723733164812 +20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5418794935503718 +20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5881563093180459 +20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5285801925665846 +20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6153778860484113 +20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6148907987988106 +20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5930098263919373 +20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5738136039907662 +20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5976615689328185 +20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.536838727633924 +20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5960618109585014 +20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6865127461248433 +20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5626387761115069 +20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5917564451324532 +20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6192947676975297 +20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8405884685777613 +20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8645850708785988 +20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8712394763518471 +20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.7929404598529194 +20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8312283444616974 +20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8662289259107663 +20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8389849229221574 +20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8702894576481618 +20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.87318611647524 +20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8302392517991111 +20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8607695269028927 +20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8660079647914376 +20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.854183247303718 +20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8713742939120133 +20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8718807172840685 +20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8513911193429898 +20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8685050602981201 +20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8680055325473802 +20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8737556840572553 +20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8841526755214332 +20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8888065379535872 +20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.852701259917897 +20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8837830878032994 +20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.885816567037968 +20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8787283623149201 +20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8917284636240392 +20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8906356560516376 +20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8779985423897004 +20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8880542842704391 +20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8823444076115033 +20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8861267071362202 +20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8903365601137553 +20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8890990821469466 +20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8796973560335398 +20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8883858064760392 +20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8780707714732131 +20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8584318755497753 +20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8547200776893197 +20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8689391528476788 +20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8657492876887302 +20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8665984896775468 +20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8670716568334941 +20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8669849502009046 +20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8669213504146495 +20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8513987284951616 +20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8613553081599469 +20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8643802822696024 +20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.850061110459477 +20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8649890060805004 +20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.864664536558461 +20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.87499061468443 +20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8617987991694275 +20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8556029113974181 +20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.836253087370685 +20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7301582578523442 +20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7966664001250571 +20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8192383650946446 +20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6843812631328858 +20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.765024790877448 +20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.795656001887858 +20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7701854165373856 +20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8096673884540383 +20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8188169283504791 +20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7105467505684645 +20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.783353078439375 +20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7782772263224064 +20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7852474706411633 +20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8160217019471087 +20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8155007938311992 +20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7490345626204942 +20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.739864605966215 +20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7697459810627348 +20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8899160878145259 +20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8805935037962547 +20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8742165051107476 +20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8785453081120776 +20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.868034843649661 +20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8689655344236765 +20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.871577822543261 +20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8633066667882496 +20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8772899928453862 +20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8665374293994789 +20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8621465983511758 +20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8615707808672314 +20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8666142298062537 +20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8715622792709952 +20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8572585704008985 +20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8662918114203869 +20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8674643121881878 +20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8598524076895272 +20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5498489814390383 +20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5157704198675442 +20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6294814803439372 +20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4735899868020016 +20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5251547622346807 +20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5966354746395138 +20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5483085080274038 +20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6114451283105824 +20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6402537104327802 +20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5184627537159879 +20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5613578289453632 +20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5950424719077719 +20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5817387422853509 +20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5670131371630888 +20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6493057570347315 +20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5695065788095982 +20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5813936965210703 +20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5899249706772173 +20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8259970752893565 +20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.858381715245641 +20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8675019645173832 +20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8054797253834948 +20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8607613018453389 +20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8516548287850534 +20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8540060030398751 +20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.867341187379584 +20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8792765470740959 +20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8465553071268127 +20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8609189594062755 +20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8617065988599807 +20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8594804989480028 +20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8784823618643904 +20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8634406609171211 +20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8446007474927965 +20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.861299990126875 +20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8589400435390498 +20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8561992508197512 +20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.87555993869972 +20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8836365893996513 +20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.860822786271946 +20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8715385469639246 +20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8775399130859786 +20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8742921664333824 +20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8836365288146316 +20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8892733220736804 +20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8664811797256972 +20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8695930474945411 +20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8754384908613974 +20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8775468563414336 +20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.892761735779104 +20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8884170688120799 +20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.87116405521003 +20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8787148401311126 +20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8791686439075189 +20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8655304846337724 +20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8553539472952941 +20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8391481268905387 +20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8735082106110585 +20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.870548783381682 +20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.856994105135844 +20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8667091825862968 +20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.855329073421993 +20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8492945962400754 +20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8697147511450535 +20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8403955742315375 +20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8432261588306927 +20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8522076275102717 +20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8494295515700746 +20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8540298191892463 +20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8582243251649517 +20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.825422465203849 +20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8416939697246559 +20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6952495606397182 +20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7530702024037019 +20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7652535796492083 +20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6496391028283236 +20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.734216854760021 +20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7172834175043877 +20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7562330878121553 +20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.791776803653914 +20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8127985840760522 +20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6644139771526311 +20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7517192236077518 +20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.768330386244136 +20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7694404315292803 +20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7991416287974137 +20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7913976215892403 +20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7185004798537138 +20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7831725929696628 +20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7240620850331512 +20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8915164842623713 +20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8897755569654725 +20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8680205618555169 +20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8834992075005544 +20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8846894358285672 +20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8499986757067887 +20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8818561098123627 +20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8518823800774147 +20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.859754242274243 +20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8839244686481734 +20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8668025246325449 +20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8683446535115865 +20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.873207807864186 +20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8654723250715738 +20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8668390545977522 +20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8759948093063977 +20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8630941525241899 +20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8463581634906184 +20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5215819994251621 +20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5440332196269413 +20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5125337879887183 +20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4510956044056313 +20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5172391251722862 +20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5048816763264378 +20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5399463256521333 +20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5276851164890177 +20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5877430026666363 +20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5484673072007328 +20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.4938254579361662 +20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.580972016705556 +20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5452910095752914 +20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6122407505352867 +20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5902117369731129 +20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5062903971339048 +20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.535559416226597 +20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6077003369589623 +20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8039704987787148 +20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8342584945514114 +20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8623349412482656 +20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.7628438365266939 +20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.795774510742837 +20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.840098307901715 +20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8254729519527725 +20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8627311407955313 +20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8677142002875881 +20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8116614075087506 +20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8396535516035891 +20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8419995568632858 +20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8412225550438558 +20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8656865127742878 +20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8601881752353103 +20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8043802059036173 +20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8568457187758008 +20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8348143373973232 +25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8705600777962981 +25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8807276210731628 +25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8867087118861829 +25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8616437980719732 +25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8788467599486823 +25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8817164444381467 +25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8748379164827251 +25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8885359702695691 +25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.88812870604022 +25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.868681736654787 +25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8832920509054066 +25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8800618724612149 +25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8785960197506735 +25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.888531363686703 +25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8883397116683488 +25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8750338019364152 +25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8852031411070493 +25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.882025275301395 +25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8528207186935243 +25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8644853332886487 +25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8576433683053778 +25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8493919254378963 +25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8593238306554506 +25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.874938841949397 +25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8771251705527602 +25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8635270396627007 +25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8569853843133278 +25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8500328013032604 +25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8657036368385326 +25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8690299827399027 +25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8638455266361572 +25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8584953506324703 +25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8635322669476045 +25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8349581741367297 +25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8747721354606682 +25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8769821911504555 +25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6873512594178631 +25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.8008945808618124 +25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8211317462944018 +25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6712825860790131 +25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7392226232576062 +25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.742144324192061 +25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.790932562256092 +25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.809785308389196 +25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8314455157201949 +25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7177304403560215 +25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7739268460591545 +25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7955266417632291 +25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.802152692268148 +25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8200496742803861 +25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8275062810102067 +25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7438397641959898 +25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7567684172262442 +25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.71667929331858 +25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8812222847723244 +25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8703454019661772 +25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8741599419882596 +25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8681256474229778 +25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8585557128646006 +25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8636672229431989 +25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8670758988725371 +25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8592008249443523 +25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8690135194639423 +25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8551413711476142 +25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8554555704107721 +25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8810709586705495 +25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8658574320777409 +25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8739763100550557 +25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8755441154874551 +25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8652487227630475 +25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8750612431399194 +25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8780097330750865 +25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5007829828914216 +25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6026027860607975 +25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5941344305322006 +25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.541540162245731 +25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5637660827332058 +25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5422177528960505 +25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5019051722058944 +25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6379386619195689 +25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6511389775680027 +25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5666860137091804 +25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.615066575051899 +25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6280707264308051 +25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5720961674711474 +25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.583290014125741 +25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6909651250982275 +25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5979899059442434 +25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6019522157140068 +25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5797216146908508 +25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.833834468644891 +25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8642090491695525 +25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8737332780873465 +25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8319471451065586 +25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8545014681369899 +25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8679930801953487 +25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8558880391210991 +25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8778510139784169 +25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8761969509165706 +25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8433758261001003 +25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8775257109200432 +25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8723464220608151 +25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.863025895520293 +25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8806869695798873 +25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8678422670128363 +25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8570766312071999 +25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8676569943032956 +25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8696970103299956 +25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8678837425787126 +25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8870004776013332 +25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8913261946968145 +25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8514816545784658 +25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8788184697911358 +25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8857877354480755 +25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8844846691730894 +25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.891487626757025 +25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8934349984979141 +25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8754471098831663 +25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8897101469455476 +25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8856854211808504 +25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.889490758035831 +25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8938053882664171 +25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8936142842882481 +25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8774543467922933 +25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.888797693727604 +25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8828539277487168 +25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8643893819963956 +25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.882731877232549 +25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8610347205843256 +25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8795558881248285 +25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8741111605234702 +25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8755490328851717 +25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.868798809748363 +25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8644994356555401 +25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8688991459251758 +25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8686487912782038 +25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8702112063898838 +25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8733064364634829 +25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8704849516438706 +25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8790218625625634 +25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8768751313981668 +25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8760331200341978 +25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8720768396589368 +25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8702354978678825 +25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7204237510299971 +25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7930189734712157 +25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8157789596615473 +25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6589006177744096 +25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.763023641376524 +25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7742505345918268 +25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7632698860264536 +25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8090750892793728 +25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8184980792949675 +25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.670301023253662 +25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7670156400353124 +25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7613051074189757 +25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7857691897714142 +25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8158575814766422 +25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8470144472636024 +25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7598429219683611 +25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7657885123422119 +25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7766812032640394 +25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8846370511321663 +25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8694754913339326 +25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8699190104050661 +25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8782957279150433 +25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8668863191163156 +25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8601808626551173 +25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8726920164792241 +25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8802340795459426 +25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8553271091368796 +25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8677019984029317 +25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8664939060513829 +25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8725441654926763 +25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8658931830917488 +25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8719229413976294 +25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8659472913253136 +25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.86061863304328 +25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8591557843374327 +25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8693964480497683 +25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5481870748591208 +25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5721380490883424 +25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6401662685795467 +25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5571145708138173 +25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.546973437815082 +25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5511368212184262 +25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5034226955049844 +25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6024735028636816 +25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6104750796771374 +25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5527321316961837 +25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5824103427140811 +25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5885045067847653 +25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5540976705463233 +25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6034667834923698 +25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6027943882076117 +25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.48395170352425493 +25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5551197952120444 +25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6153152519484267 +25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.840673825148437 +25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8696342544189327 +25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8783661978892265 +25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8297332788964699 +25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8400470349335425 +25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8635157378168087 +25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8618288414640647 +25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.874989502746209 +25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8788793589760964 +25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.851014255487862 +25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.859155207532503 +25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.876975548884099 +25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8691954578809722 +25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8780484625005647 +25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8758404775462904 +25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8464514609605879 +25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8641106669728952 +25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8670416780830195 +25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8554461890047024 +25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8775723591820287 +25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8840691270680137 +25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8505314076467584 +25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8661911698596062 +25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8755690344316337 +25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8727361945406894 +25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8865321106352665 +25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8841424126440849 +25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8613520725914605 +25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8766609007532987 +25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8753927595595629 +25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8863907985804863 +25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.895236025505298 +25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8827233459976874 +25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.878864894655373 +25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8752439000201221 +25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8594502083227641 +25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8774732419006562 +25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8644025747630684 +25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8759919349570184 +25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8561048784246036 +25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8787967309586587 +25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.858335936492774 +25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8778772587027249 +25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8728556641976205 +25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8576039747774183 +25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8641024611507243 +25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8576521743408385 +25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8606407934200151 +25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8600030555178776 +25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.876813632367312 +25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8703362391002442 +25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8597133019198226 +25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8705856030721163 +25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8512571730079056 +25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6961502191042457 +25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7567479628895347 +25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7882625123334739 +25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6719149889228911 +25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7275172932752817 +25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7408399616040205 +25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7247184966006724 +25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7850949399655698 +25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8007075248537502 +25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6671701595647188 +25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.755222454989021 +25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7478477482478438 +25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7758222356445058 +25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.808277418395959 +25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7903743318736757 +25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7332209191107433 +25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7749929995236924 +25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7685238429402848 +25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8871024098706393 +25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.88039869351744 +25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.878170771671415 +25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8889747629197796 +25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8694068468875976 +25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8771433919224041 +25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8795928126921203 +25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8791474456430522 +25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8737093989304144 +25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8620441469632883 +25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8586183791535179 +25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.864173045734069 +25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8747766379459477 +25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8641467395831066 +25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8629609602962226 +25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8745756162211968 +25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8676856675131203 +25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8517314698326777 +25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.481878383195655 +25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5015053381029205 +25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.595397168630999 +25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4934465332127778 +25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.45409516335542194 +25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5288352697706356 +25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5347059348582631 +25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5994188885452673 +25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6210030424177285 +25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5814690159056558 +25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5271694384278849 +25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5422599706165315 +25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5832189231065013 +25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5545881651792254 +25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6147815721116969 +25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5308178929771052 +25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5824050483161242 +25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5632200171786267 +25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.830688030462528 +25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8456143986499801 +25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8648928730411439 +25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.816206128803409 +25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8345539151616946 +25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8419568212891749 +25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8327057658123405 +25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8702939713278633 +25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8693881704672347 +25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8330297653103395 +25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8434740275221663 +25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8617234262560896 +25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8544036818545003 +25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8733016775881398 +25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8716798922089254 +25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8320684144597892 +25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.859393226877159 +25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8663156344336939 From 5c36a0bbaa8e2c70dfe30291e37293885da53939 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sun, 16 Apr 2023 12:46:25 +0200 Subject: [PATCH 34/51] add tf addons --- PTB_XL_experiments.ipynb | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb index 760271c..2126e47 100644 --- a/PTB_XL_experiments.ipynb +++ b/PTB_XL_experiments.ipynb @@ -52,7 +52,7 @@ } ], "source": [ - "!pip install wget wfdb" + "!pip install wget wfdb tensorflow-addons" ] }, { @@ -85,7 +85,8 @@ "from sklearn.utils.class_weight import compute_class_weight\n", "import pandas as pd\n", "import seaborn as sns\n", - "from sklearn.metrics import confusion_matrix" + "from sklearn.metrics import confusion_matrix\n", + "import tensorflow_addons as tfa" ] }, { From 8018e8b0c5133d630aaff33fe9b56e36ccb8fc07 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sun, 16 Apr 2023 20:44:11 +0200 Subject: [PATCH 35/51] add results from optimized Inception model --- final_results.txt | 107 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 107 insertions(+) create mode 100644 final_results.txt diff --git a/final_results.txt b/final_results.txt new file mode 100644 index 0000000..26b3826 --- /dev/null +++ b/final_results.txt @@ -0,0 +1,107 @@ + ### 1. PTB-XL: all statements + +| Model | AUC ↓ | paper/source | code | +|---:|:---|:---|:---| +| xresnet1d101 | 0.927(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| inception1d | 0.924(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_all | 0.923(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| resnet1d_wang | 0.920(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| fcn_wang | 0.915(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm_bidir | 0.912(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm | 0.909(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| Wavelet+NN | 0.826(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| + + ### 2. PTB-XL: diagnostic statements + +| Model | AUC ↓ | paper/source | code | +|---:|:---|:---|:---| +| xresnet1d101 | 0.934(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm_bidir | 0.931(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| inception1d | 0.931(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| resnet1d_wang | 0.929(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm | 0.928(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| fcn_wang | 0.924(09) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_diagnostic | 0.915(09) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| Wavelet+NN | 0.837(19) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| + + ### 3. PTB-XL: Diagnostic subclasses + +| Model | AUC ↓ | paper/source | code | +|---:|:---|:---|:---| +| resnet1d_wang | 0.934(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_subdiagnostic | 0.931(10) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| inception1d | 0.930(09) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| xresnet1d101 | 0.929(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| fcn_wang | 0.928(11) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm_bidir | 0.927(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm | 0.927(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| Wavelet+NN | 0.849(14) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| + + ### 4. PTB-XL: Diagnostic superclasses + +| Model | AUC ↓ | paper/source | code | +|---:|:---|:---|:---| +| xresnet1d101 | 0.929(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| resnet1d_wang | 0.929(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm | 0.928(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| fcn_wang | 0.925(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm_bidir | 0.922(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_superdiagnostic | 0.922(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| inception1d | 0.917(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| Wavelet+NN | 0.872(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| + + ### 5. PTB-XL: Form statements + +| Model | AUC ↓ | paper/source | code | +|---:|:---|:---|:---| +| xresnet1d101 | 0.891(13) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| resnet1d_wang | 0.875(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| inception1d | 0.870(24) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm_bidir | 0.864(20) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| fcn_wang | 0.863(19) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm | 0.849(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_form | 0.839(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| Wavelet+NN | 0.779(26) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| + + ### 6. PTB-XL: Rhythm statements + +| Model | AUC ↓ | paper/source | code | +|---:|:---|:---|:---| +| inception1d | 0.953(13) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| xresnet1d101 | 0.950(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm | 0.949(10) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| lstm_bidir | 0.945(13) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| resnet1d_wang | 0.942(10) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| fcn_wang | 0.924(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_rhythm | 0.915(20) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| Wavelet+NN | 0.874(34) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| +| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| From cbb43b2355c292ad098cd39547a6cc7ce0d670c8 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:14:08 +0200 Subject: [PATCH 36/51] update models to run --- code/reproduce_results.py | 1 - 1 file changed, 1 deletion(-) diff --git a/code/reproduce_results.py b/code/reproduce_results.py index 9539fa8..0030d31 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_results.py @@ -24,7 +24,6 @@ def main(datafolder, datafolder_icbeb, outputfolder): conf_tf_inception_rhythm, conf_tf_inception_subdiagnostic, conf_tf_inception_superdiagnostic - ] ########################################## From 54587b5c21ba5477a8d578bc6ce0686b20076802 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:15:21 +0200 Subject: [PATCH 37/51] Delete make_gridsearch_file.ipynb --- make_gridsearch_file.ipynb | 236 ------------------------------------- 1 file changed, 236 deletions(-) delete mode 100644 make_gridsearch_file.ipynb diff --git a/make_gridsearch_file.ipynb b/make_gridsearch_file.ipynb deleted file mode 100644 index a03f3dd..0000000 --- a/make_gridsearch_file.ipynb +++ /dev/null @@ -1,236 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "_e4S68CJtRn4" - }, - "outputs": [], - "source": [ - "epochs = [15,20,25]\n", - "batch_size = [16, 32, 64]\n", - "init_lr = [0.001, 0.0001, 0.00001]\n", - "lr_red = [\"yes\", \"no\"]\n", - "model_depth = [6, 9, 12]\n", - "loss = [\"bce\", \"wbce\"]\n", - "kernel_size = [(20,10,5), (40,20,10), (60,30,15)]" - ] - }, - { - "cell_type": "code", - "source": [ - "import pandas as pd" - ], - "metadata": { - "id": "BM3En7Scuji-" - }, - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "df = pd.DataFrame({\"epochs\": [], \"batch_size\":[], \"init_lr\": [], \"lr_red\": [], \"model_depth\": [],\"loss\": [], \"kernel_size\": []})" - ], - "metadata": { - "id": "q8ihRunfuWx5" - }, - "execution_count": 11, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "df" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 49 - }, - "id": "t7cA7I-Yuit3", - "outputId": "89acf5d5-9551-410c-8231-7c670053ed29" - }, - "execution_count": 12, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Empty DataFrame\n", - "Columns: [epochs, batch_size, init_lr, lr_red, model_depth, loss, kernel_size]\n", - "Index: []" - ], - "text/html": [ - "\n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
epochsbatch_sizeinit_lrlr_redmodel_depthlosskernel_size
\n", - "
\n", - " \n", - " \n", - " \n", - "\n", - " \n", - "
\n", - "
\n", - " " - ] - }, - "metadata": {}, - "execution_count": 12 - } - ] - }, - { - "cell_type": "code", - "source": [ - "for epoch in epochs:\n", - " for batch in batch_size:\n", - " for lr_val in init_lr:\n", - " for lr_onoff in lr_red:\n", - " for depth in model_depth:\n", - " for l in loss:\n", - " for ks in kernel_size:\n", - " df = df.append({\"epochs\": epoch, \"batch_size\":batch, \"init_lr\": lr_val, \"lr_red\": lr_onoff, \"model_depth\": depth,\"loss\": l, \"kernel_size\": ks}, ignore_index=True)" - ], - "metadata": { - "id": "piCQhBa8uqGL" - }, - "execution_count": 14, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "df.to_csv(\"gridsearch_params.csv\", index=False)" - ], - "metadata": { - "id": "qmS2-3hMv0kp" - }, - "execution_count": 18, - "outputs": [] - }, - { - "cell_type": "code", - "source": [], - "metadata": { - "id": "0UpdTQaVwgKz" - }, - "execution_count": null, - "outputs": [] - } - ] -} \ No newline at end of file From 070d066fb4d4fd14f3d06a540dfcd707e48eeec4 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:15:37 +0200 Subject: [PATCH 38/51] Delete gridsearch_params.csv --- gridsearch_params.csv | 973 ------------------------------------------ 1 file changed, 973 deletions(-) delete mode 100644 gridsearch_params.csv diff --git a/gridsearch_params.csv b/gridsearch_params.csv deleted file mode 100644 index 65c80d8..0000000 --- a/gridsearch_params.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)" -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)" -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)" -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)" -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)" -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)" -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)" -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)" -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)" -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)" -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)" -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)" -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)" -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)" -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)" -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)" -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)" -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)" -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)" -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)" -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)" -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)" -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)" -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)" -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)" -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)" -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)" -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)" -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)" -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)" -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)" -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)" -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)" -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)" -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)" -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)" -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)" -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)" -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)" -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)" -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)" -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)" -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)" -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)" -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)" -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)" -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)" -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)" -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)" -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)" -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)" -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)" -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)" -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)" -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)" -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)" -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)" -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)" -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)" -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)" -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)" -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)" -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)" -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)" -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)" -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)" -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)" -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)" -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)" -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)" -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)" -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)" -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)" -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)" -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)" -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)" -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)" -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)" -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)" -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)" -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)" -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)" -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)" -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)" -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)" -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)" -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)" -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)" -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)" -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)" -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)" -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)" -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)" -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)" -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)" -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)" -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)" -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)" -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)" -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)" -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)" -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)" -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)" -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)" -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)" -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)" -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)" -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)" -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)" -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)" -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)" -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)" -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)" -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)" -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)" -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)" -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)" -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)" -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)" -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)" -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)" -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)" -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)" -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)" -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)" -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)" -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)" -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)" -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)" -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)" -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)" -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)" -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)" -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)" -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)" -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)" -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)" -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)" -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)" -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)" -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)" -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)" -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)" -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)" -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)" -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)" -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)" -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)" -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)" -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)" -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)" -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)" -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)" -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)" -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)" -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)" -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)" -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)" -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)" -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)" -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)" -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)" -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)" -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)" -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)" -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)" -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)" -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)" -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)" -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)" -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)" -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)" -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)" -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)" -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)" -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)" -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)" -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)" -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)" -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)" -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)" -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)" -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)" -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)" -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)" -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)" -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)" -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)" -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)" -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)" -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)" -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)" -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)" -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)" -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)" -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)" -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)" -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)" -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)" -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)" -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)" -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)" -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)" -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)" -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)" -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)" -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)" -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)" -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)" -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)" -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)" -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)" -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)" -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)" -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)" -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)" -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)" -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)" -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)" -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)" -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)" -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)" -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)" -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)" -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)" -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)" -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)" -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)" -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)" -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)" -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)" -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)" -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)" -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)" -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)" -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)" -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)" -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)" -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)" -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)" -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)" -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)" -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)" -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)" -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)" -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)" -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)" -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)" -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)" -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)" -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)" -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)" -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)" -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)" -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)" -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)" -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)" -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)" -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)" -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)" -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)" -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)" -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)" -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)" -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)" -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)" -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)" -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)" -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)" -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)" -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)" -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)" -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)" -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)" -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)" -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)" -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)" -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)" -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)" -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)" -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)" -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)" -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)" -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)" -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)" -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)" -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)" -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)" -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)" -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)" -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)" -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)" -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)" -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)" -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)" -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)" -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)" -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)" -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)" -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)" -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)" -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)" -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)" -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)" -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)" -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)" -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)" -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)" -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)" -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)" -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)" -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)" -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)" -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)" -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)" -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)" -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)" -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)" -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)" -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)" -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)" -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)" -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)" -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)" -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)" -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)" -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)" -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)" -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)" -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)" -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)" -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)" -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)" -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)" -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)" -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)" -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)" -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)" -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)" -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)" -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)" -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)" -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)" -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)" -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)" -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)" -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)" -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)" -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)" -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)" -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)" -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)" -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)" -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)" -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)" -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)" -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)" -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)" -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)" -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)" -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)" -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)" -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)" -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)" -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)" -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)" -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)" -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)" -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)" -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)" -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)" -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)" -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)" -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)" -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)" -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)" -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)" -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)" -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)" -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)" -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)" -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)" -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)" -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)" -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)" -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)" -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)" -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)" -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)" -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)" -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)" -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)" -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)" -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)" -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)" -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)" -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)" -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)" -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)" -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)" -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)" -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)" -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)" -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)" -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)" -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)" -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)" -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)" -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)" -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)" -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)" -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)" -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)" -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)" -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)" -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)" -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)" -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)" -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)" -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)" -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)" -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)" -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)" -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)" -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)" -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)" -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)" -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)" -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)" -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)" -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)" -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)" -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)" -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)" -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)" -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)" -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)" -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)" -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)" -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)" -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)" -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)" -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)" -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)" -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)" -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)" -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)" -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)" -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)" -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)" -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)" -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)" -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)" -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)" -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)" -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)" -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)" -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)" -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)" -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)" -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)" -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)" -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)" -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)" -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)" -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)" -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)" -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)" -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)" From 3cd9cdbf8de43322cf2acacfb615d9c5b3863238 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:15:48 +0200 Subject: [PATCH 39/51] Delete final_results.txt --- final_results.txt | 107 ---------------------------------------------- 1 file changed, 107 deletions(-) delete mode 100644 final_results.txt diff --git a/final_results.txt b/final_results.txt deleted file mode 100644 index 26b3826..0000000 --- a/final_results.txt +++ /dev/null @@ -1,107 +0,0 @@ - ### 1. PTB-XL: all statements - -| Model | AUC ↓ | paper/source | code | -|---:|:---|:---|:---| -| xresnet1d101 | 0.927(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| inception1d | 0.924(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_all | 0.923(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| resnet1d_wang | 0.920(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| fcn_wang | 0.915(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm_bidir | 0.912(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm | 0.909(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| Wavelet+NN | 0.826(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| - - ### 2. PTB-XL: diagnostic statements - -| Model | AUC ↓ | paper/source | code | -|---:|:---|:---|:---| -| xresnet1d101 | 0.934(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm_bidir | 0.931(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| inception1d | 0.931(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| resnet1d_wang | 0.929(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm | 0.928(07) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| fcn_wang | 0.924(09) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_diagnostic | 0.915(09) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| Wavelet+NN | 0.837(19) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| - - ### 3. PTB-XL: Diagnostic subclasses - -| Model | AUC ↓ | paper/source | code | -|---:|:---|:---|:---| -| resnet1d_wang | 0.934(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_subdiagnostic | 0.931(10) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| inception1d | 0.930(09) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| xresnet1d101 | 0.929(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| fcn_wang | 0.928(11) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm_bidir | 0.927(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm | 0.927(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| Wavelet+NN | 0.849(14) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| - - ### 4. PTB-XL: Diagnostic superclasses - -| Model | AUC ↓ | paper/source | code | -|---:|:---|:---|:---| -| xresnet1d101 | 0.929(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| resnet1d_wang | 0.929(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm | 0.928(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| fcn_wang | 0.925(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm_bidir | 0.922(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_superdiagnostic | 0.922(05) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| inception1d | 0.917(06) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| Wavelet+NN | 0.872(08) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| - - ### 5. PTB-XL: Form statements - -| Model | AUC ↓ | paper/source | code | -|---:|:---|:---|:---| -| xresnet1d101 | 0.891(13) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| resnet1d_wang | 0.875(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| inception1d | 0.870(24) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm_bidir | 0.864(20) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| fcn_wang | 0.863(19) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm | 0.849(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_form | 0.839(12) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| Wavelet+NN | 0.779(26) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_rhythm | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| - - ### 6. PTB-XL: Rhythm statements - -| Model | AUC ↓ | paper/source | code | -|---:|:---|:---|:---| -| inception1d | 0.953(13) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| xresnet1d101 | 0.950(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm | 0.949(10) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| lstm_bidir | 0.945(13) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| resnet1d_wang | 0.942(10) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| fcn_wang | 0.924(16) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_rhythm | 0.915(20) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| Wavelet+NN | 0.874(34) | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_subdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_superdiagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_all | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_form | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| -| tf_inception_diagnostic | -- | [our work](https://arxiv.org/abs/2004.13701) | [this repo](https://github.com/helme/ecg_ptbxl_benchmarking/)| From b605049948a32eb0eb04a5fad8137ea37582bfd9 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:16:09 +0200 Subject: [PATCH 40/51] Delete PTB_XL_experiments.ipynb --- PTB_XL_experiments.ipynb | 6747 -------------------------------------- 1 file changed, 6747 deletions(-) delete mode 100644 PTB_XL_experiments.ipynb diff --git a/PTB_XL_experiments.ipynb b/PTB_XL_experiments.ipynb deleted file mode 100644 index 2126e47..0000000 --- a/PTB_XL_experiments.ipynb +++ /dev/null @@ -1,6747 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "12a7e1a6-3e27-41b8-b16f-da7475e69935", - "outputId": "e7ea69a2-70fb-444a-9d9b-2b962c56ef12" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting wget\n", - " Downloading wget-3.2.zip (10 kB)\n", - "Collecting wfdb\n", - " Downloading wfdb-4.0.0-py3-none-any.whl (161 kB)\n", - "\u001b[K |████████████████████████████████| 161 kB 13.5 MB/s \n", - "\u001b[?25hRequirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Building wheels for collected packages: wget\n", - " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9675 sha256=0218240348ccec295705f719dfa125819a26052dbb9d86110fa8b1fdc244dc19\n", - " Stored in directory: /root/.cache/pip/wheels/a1/b6/7c/0e63e34eb06634181c63adacca38b79ff8f35c37e3c13e3c02\n", - "Successfully built wget\n", - "Installing collected packages: wget, wfdb\n", - "Successfully installed wfdb-4.0.0 wget-3.2\n" - ] - } - ], - "source": [ - "!pip install wget wfdb tensorflow-addons" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "JXL0zlq8Wdpl", - "metadata": { - "id": "JXL0zlq8Wdpl" - }, - "outputs": [], - "source": [ - "from google.colab import drive\n", - "drive.mount('/content/drive')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319", - "metadata": { - "id": "3d6d4835-aec8-4e68-aba8-7b71a1e3f319" - }, - "outputs": [], - "source": [ - "import wget\n", - "import numpy as np\n", - "import os\n", - "import zipfile\n", - "import tensorflow as tf\n", - "from sklearn.utils.class_weight import compute_class_weight\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "from sklearn.metrics import confusion_matrix\n", - "import tensorflow_addons as tfa" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "181ee1f6-3777-4aba-be5d-db810af7b5bc", - "metadata": { - "id": "181ee1f6-3777-4aba-be5d-db810af7b5bc" - }, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "T0cGBrFsdJFb", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "T0cGBrFsdJFb", - "outputId": "21ff2faf-7c26-45d3-f422-302521d7d752" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--2022-09-28 06:27:07-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "Resolving physionet.org (physionet.org)... 18.18.42.54\n", - "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 1842722380 (1.7G) [application/zip]\n", - "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", - "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 6.21MB/s in 3m 40s \n", - "\n", - "2022-09-28 06:30:47 (8.00 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", - "\n" - ] - } - ], - "source": [ - "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "\n", - "os.mkdir(\"./data/\")\n", - "\n", - "\n", - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ICe12Y7yxFKg", - "metadata": { - "id": "ICe12Y7yxFKg" - }, - "outputs": [], - "source": [ - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "V-j1oLL4Li10", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "V-j1oLL4Li10", - "outputId": "e3432168-e2f3-422e-a5c0-e5c9b5f6c3e1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting GitPython\n", - " Downloading GitPython-3.1.27-py3-none-any.whl (181 kB)\n", - "\u001b[K |████████████████████████████████| 181 kB 14.9 MB/s \n", - "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.9-py3-none-any.whl (63 kB)\n", - "\u001b[K |████████████████████████████████| 63 kB 2.0 MB/s \n", - "\u001b[?25hRequirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.7/dist-packages (from GitPython) (4.1.1)\n", - "Collecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Installing collected packages: smmap, gitdb, GitPython\n", - "Successfully installed GitPython-3.1.27 gitdb-4.0.9 smmap-5.0.0\n" - ] - } - ], - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "aLEwloYTLpue", - "metadata": { - "id": "aLEwloYTLpue" - }, - "outputs": [], - "source": [ - "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", - "DEST_NAME = 'github_repo'" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "wrApvEoJLPYq", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "wrApvEoJLPYq", - "outputId": "b9336107-9b65-4860-e7b0-8a7ba5559685" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "5bf67a99-cd41-4f22-aba1-fd73ec880689", - "outputId": "00f6632b-41af-46ad-bd53-7a246374639f" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "['example_physionet.py',\n", - " 'scp_statements.csv',\n", - " 'records100',\n", - " 'RECORDS',\n", - " 'LICENSE.txt',\n", - " 'ptbxl_database.csv',\n", - " 'records500',\n", - " 'SHA256SUMS.txt']" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "os.listdir(\"./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "fRteqX8GY5Nw", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "fRteqX8GY5Nw", - "outputId": "1725f25e-f9b3-48c5-ca99-ce226db5fc3f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting git+https://github.com/Bsingstad/fastai.git\n", - " Cloning https://github.com/Bsingstad/fastai.git to /tmp/pip-req-build-j7eyrvwm\n", - " Running command git clone -q https://github.com/Bsingstad/fastai.git /tmp/pip-req-build-j7eyrvwm\n", - "Collecting bottleneck\n", - " Downloading Bottleneck-1.3.5-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (355 kB)\n", - "\u001b[K |████████████████████████████████| 355 kB 16.1 MB/s \n", - "\u001b[?25hRequirement already satisfied: fastprogress>=0.2.1 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.0.3)\n", - "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (4.6.3)\n", - "Requirement already satisfied: matplotlib in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.2.2)\n", - "Requirement already satisfied: numexpr in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.8.3)\n", - "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.21.6)\n", - "Collecting nvidia-ml-py3\n", - " Downloading nvidia-ml-py3-7.352.0.tar.gz (19 kB)\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.3.5)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (21.3)\n", - "Requirement already satisfied: Pillow in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (7.1.2)\n", - "Requirement already satisfied: pyyaml in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (6.0)\n", - "Requirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (2.23.0)\n", - "Requirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.7.3)\n", - "Requirement already satisfied: torch>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (1.12.1+cu113)\n", - "Requirement already satisfied: torchvision in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (0.13.1+cu113)\n", - "Requirement already satisfied: spacy>=2.0.18 in /usr/local/lib/python3.7/dist-packages (from fastai==1.0.61) (3.4.1)\n", - "Requirement already satisfied: setuptools in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (57.4.0)\n", - "Requirement already satisfied: pathy>=0.3.5 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.6.2)\n", - "Requirement already satisfied: tqdm<5.0.0,>=4.38.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.64.1)\n", - "Requirement already satisfied: thinc<8.2.0,>=8.1.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (8.1.0)\n", - "Requirement already satisfied: cymem<2.1.0,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.6)\n", - "Requirement already satisfied: srsly<3.0.0,>=2.4.3 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.4.4)\n", - "Requirement already satisfied: preshed<3.1.0,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.7)\n", - "Requirement already satisfied: typing-extensions<4.2.0,>=3.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (4.1.1)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.11.3)\n", - "Requirement already satisfied: spacy-loggers<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.3)\n", - "Requirement already satisfied: spacy-legacy<3.1.0,>=3.0.9 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.0.10)\n", - "Requirement already satisfied: pydantic!=1.8,!=1.8.1,<1.10.0,>=1.7.4 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.9.2)\n", - "Requirement already satisfied: langcodes<4.0.0,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (3.3.0)\n", - "Requirement already satisfied: typer<0.5.0,>=0.3.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.4.2)\n", - "Requirement already satisfied: wasabi<1.1.0,>=0.9.1 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (0.10.1)\n", - "Requirement already satisfied: murmurhash<1.1.0,>=0.28.0 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (1.0.8)\n", - "Requirement already satisfied: catalogue<2.1.0,>=2.0.6 in /usr/local/lib/python3.7/dist-packages (from spacy>=2.0.18->fastai==1.0.61) (2.0.8)\n", - "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.7/dist-packages (from catalogue<2.1.0,>=2.0.6->spacy>=2.0.18->fastai==1.0.61) (3.8.1)\n", - "Requirement already satisfied: pyparsing!=3.0.5,>=2.0.2 in /usr/local/lib/python3.7/dist-packages (from packaging->fastai==1.0.61) (3.0.9)\n", - "Requirement already satisfied: smart-open<6.0.0,>=5.2.1 in /usr/local/lib/python3.7/dist-packages (from pathy>=0.3.5->spacy>=2.0.18->fastai==1.0.61) (5.2.1)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2022.6.15)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (3.0.4)\n", - "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (1.24.3)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->fastai==1.0.61) (2.10)\n", - "Requirement already satisfied: blis<0.8.0,>=0.7.8 in /usr/local/lib/python3.7/dist-packages (from thinc<8.2.0,>=8.1.0->spacy>=2.0.18->fastai==1.0.61) (0.7.8)\n", - "Requirement already satisfied: click<9.0.0,>=7.1.1 in /usr/local/lib/python3.7/dist-packages (from typer<0.5.0,>=0.3.0->spacy>=2.0.18->fastai==1.0.61) (7.1.2)\n", - "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.7/dist-packages (from jinja2->spacy>=2.0.18->fastai==1.0.61) (2.0.1)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (2.8.2)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib->fastai==1.0.61) (0.11.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib->fastai==1.0.61) (1.15.0)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas->fastai==1.0.61) (2022.2.1)\n", - "Building wheels for collected packages: fastai, nvidia-ml-py3\n", - " Building wheel for fastai (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for fastai: filename=fastai-1.0.61-py3-none-any.whl size=239248 sha256=e42f2470cde0579ffac1f4706677ddd364f449a9b9a295f589acfac5608dbaaa\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-64udcezx/wheels/52/1e/77/2c94d45e1e2b8c802fbe90de3282e719283c1941fa945f3c95\n", - " Building wheel for nvidia-ml-py3 (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for nvidia-ml-py3: filename=nvidia_ml_py3-7.352.0-py3-none-any.whl size=19190 sha256=c00b69db274e57522a7b6f1257eff0c260ea2b5c4b2d62fcb8bb372aef391030\n", - " Stored in directory: /root/.cache/pip/wheels/df/99/da/c34f202dc8fd1dffd35e0ecf1a7d7f8374ca05fbcbaf974b83\n", - "Successfully built fastai nvidia-ml-py3\n", - "Installing collected packages: nvidia-ml-py3, bottleneck, fastai\n", - " Attempting uninstall: fastai\n", - " Found existing installation: fastai 2.7.9\n", - " Uninstalling fastai-2.7.9:\n", - " Successfully uninstalled fastai-2.7.9\n", - "Successfully installed bottleneck-1.3.5 fastai-1.0.61 nvidia-ml-py3-7.352.0\n" - ] - } - ], - "source": [ - "!pip install git+https://github.com/Bsingstad/fastai.git" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "EpL88UONKFJz", - "metadata": { - "id": "EpL88UONKFJz" - }, - "outputs": [], - "source": [ - "import fastai" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "IpjW6eVLMGJQ", - "metadata": { - "id": "IpjW6eVLMGJQ" - }, - "outputs": [], - "source": [ - "from github_repo.code import *\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "xDIdqSZiIdZr", - "metadata": { - "id": "xDIdqSZiIdZr" - }, - "outputs": [], - "source": [ - "from IPython.display import clear_output, display, HTML" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "Q8fTH7i-v8SY", - "metadata": { - "id": "Q8fTH7i-v8SY" - }, - "outputs": [], - "source": [ - "os.mkdir('../../content/drive/MyDrive/PTB-xl-output/')" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "48KVqw_QMq2H", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "48KVqw_QMq2H", - "outputId": "121ff7f7-4466-4b20-a65b-d94ea67dd04f" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "100% 21837/21837 [01:01<00:00, 357.00it/s]\n", - "tcmalloc: large alloc 2096357376 bytes == 0x84250000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a791d715 0x7f16a791dd1b 0x7f16a79be333 0x58eb9c 0x51b4e6 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", - "tcmalloc: large alloc 2096357376 bytes == 0x10118e000 @ 0x7f16aa0701e7 0x4b2150 0x5ac2ec 0x7f16a79b1b8d 0x58ef1c 0x5901a3 0x7f16a79b2a69 0x58ef1c 0x590c9f 0x591039 0x50310c 0x5efbad 0x58eb9c 0x51babb 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de\n", - "tcmalloc: large alloc 2096357376 bytes == 0x10118e000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a7917cf5 0x7f16a7917e08 0x7f16a79aa0b9 0x7f16a79aca25 0x4e6e19 0x517c77 0x5b4a3e 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", - "tcmalloc: large alloc 1674338304 bytes == 0x84250000 @ 0x7f16aa0701e7 0x7f16a78c10ce 0x7f16a7917cf5 0x7f16a7917e08 0x7f16a79aa0b9 0x7f16a79aca25 0x4e6e19 0x517c77 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", - "Training from scratch...\n", - "model: fastai_xresnet1d101\n", - " 71% 96/136 [00:17<00:07, 5.48it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:12<00:00, 11.14it/s]\n", - "100% 120/120 [00:03<00:00, 32.50it/s]\n", - "100% 136/136 [00:11<00:00, 11.38it/s]\n", - "100% 120/120 [00:03<00:00, 31.59it/s]\n", - "100% 136/136 [00:12<00:00, 10.85it/s]\n", - "100% 120/120 [00:03<00:00, 32.81it/s]\n", - "100% 136/136 [00:12<00:00, 11.27it/s]\n", - "100% 120/120 [00:03<00:00, 33.32it/s]\n", - "100% 136/136 [00:12<00:00, 11.30it/s]\n", - "100% 120/120 [00:03<00:00, 32.64it/s]\n", - "100% 136/136 [00:12<00:00, 11.24it/s]\n", - "100% 120/120 [00:03<00:00, 32.84it/s]\n", - "100% 136/136 [00:12<00:00, 11.27it/s]\n", - "100% 120/120 [00:03<00:00, 32.87it/s]\n", - "100% 136/136 [00:12<00:00, 10.92it/s]\n", - "100% 120/120 [00:03<00:00, 32.57it/s]\n", - "100% 136/136 [00:12<00:00, 11.00it/s]\n", - "100% 120/120 [00:03<00:00, 32.63it/s]\n", - "100% 136/136 [00:12<00:00, 11.03it/s]\n", - "100% 120/120 [00:03<00:00, 30.98it/s]\n", - "100% 136/136 [00:12<00:00, 11.02it/s]\n", - "100% 120/120 [00:03<00:00, 32.16it/s]\n", - "100% 136/136 [00:12<00:00, 11.11it/s]\n", - "100% 120/120 [00:03<00:00, 31.54it/s]\n", - "100% 136/136 [00:12<00:00, 11.25it/s]\n", - "100% 120/120 [00:03<00:00, 31.64it/s]\n", - "100% 136/136 [00:12<00:00, 11.14it/s]\n", - "100% 120/120 [00:03<00:00, 32.65it/s]\n", - "100% 136/136 [00:12<00:00, 10.85it/s]\n", - "100% 120/120 [00:03<00:00, 30.97it/s]\n", - "100% 136/136 [00:12<00:00, 10.84it/s]\n", - "100% 120/120 [00:03<00:00, 33.12it/s]\n", - "100% 136/136 [00:12<00:00, 11.31it/s]\n", - "100% 120/120 [00:03<00:00, 33.04it/s]\n", - "100% 136/136 [00:12<00:00, 11.00it/s]\n", - "100% 120/120 [00:03<00:00, 31.11it/s]\n", - "100% 136/136 [00:12<00:00, 11.07it/s]\n", - "100% 120/120 [00:04<00:00, 29.54it/s]\n", - "100% 136/136 [00:12<00:00, 11.12it/s]\n", - "100% 120/120 [00:03<00:00, 33.24it/s]\n", - "100% 136/136 [00:12<00:00, 11.03it/s]\n", - "100% 120/120 [00:03<00:00, 32.71it/s]\n", - "100% 136/136 [00:12<00:00, 11.04it/s]\n", - "100% 120/120 [00:03<00:00, 33.22it/s]\n", - "100% 136/136 [00:12<00:00, 11.03it/s]\n", - "100% 120/120 [00:03<00:00, 32.08it/s]\n", - "100% 136/136 [00:12<00:00, 11.01it/s]\n", - "100% 120/120 [00:03<00:00, 32.82it/s]\n", - "100% 136/136 [00:12<00:00, 11.14it/s]\n", - "100% 120/120 [00:03<00:00, 33.26it/s]\n", - "100% 136/136 [00:12<00:00, 11.30it/s]\n", - "100% 120/120 [00:03<00:00, 33.13it/s]\n", - "100% 136/136 [00:12<00:00, 11.08it/s]\n", - "100% 120/120 [00:03<00:00, 31.86it/s]\n", - "100% 136/136 [00:12<00:00, 11.07it/s]\n", - "100% 120/120 [00:03<00:00, 32.96it/s]\n", - "100% 136/136 [00:12<00:00, 11.06it/s]\n", - "100% 120/120 [00:03<00:00, 32.10it/s]\n", - "100% 136/136 [00:12<00:00, 11.27it/s]\n", - "100% 120/120 [00:03<00:00, 31.37it/s]\n", - "100% 136/136 [00:12<00:00, 11.24it/s]\n", - "100% 120/120 [00:03<00:00, 31.34it/s]\n", - "100% 136/136 [00:12<00:00, 11.25it/s]\n", - "100% 120/120 [00:03<00:00, 33.35it/s]\n", - "100% 136/136 [00:12<00:00, 10.84it/s]\n", - "100% 120/120 [00:03<00:00, 33.03it/s]\n", - "100% 136/136 [00:12<00:00, 11.07it/s]\n", - "100% 120/120 [00:03<00:00, 31.80it/s]\n", - "100% 136/136 [00:12<00:00, 10.61it/s]\n", - "100% 120/120 [00:03<00:00, 32.00it/s]\n", - "100% 136/136 [00:11<00:00, 11.41it/s]\n", - "100% 120/120 [00:03<00:00, 32.14it/s]\n", - "100% 136/136 [00:12<00:00, 11.11it/s]\n", - "100% 120/120 [00:03<00:00, 32.09it/s]\n", - "100% 136/136 [00:12<00:00, 11.22it/s]\n", - "100% 120/120 [00:03<00:00, 31.52it/s]\n", - "100% 136/136 [00:12<00:00, 10.98it/s]\n", - "100% 120/120 [00:03<00:00, 32.45it/s]\n", - "100% 136/136 [00:12<00:00, 10.93it/s]\n", - "100% 120/120 [00:03<00:00, 31.74it/s]\n", - "100% 136/136 [00:12<00:00, 11.08it/s]\n", - "100% 120/120 [00:03<00:00, 32.84it/s]\n", - "100% 136/136 [00:12<00:00, 11.14it/s]\n", - "100% 120/120 [00:03<00:00, 32.75it/s]\n", - "100% 136/136 [00:12<00:00, 10.83it/s]\n", - "100% 120/120 [00:03<00:00, 32.96it/s]\n", - "100% 136/136 [00:12<00:00, 11.15it/s]\n", - "100% 120/120 [00:03<00:00, 32.48it/s]\n", - "100% 136/136 [00:12<00:00, 11.02it/s]\n", - "100% 120/120 [00:03<00:00, 32.92it/s]\n", - "100% 136/136 [00:12<00:00, 10.99it/s]\n", - "100% 120/120 [00:03<00:00, 31.80it/s]\n", - "100% 136/136 [00:12<00:00, 11.02it/s]\n", - "100% 120/120 [00:03<00:00, 32.32it/s]\n", - "100% 136/136 [00:12<00:00, 11.15it/s]\n", - "100% 120/120 [00:03<00:00, 32.48it/s]\n", - "100% 136/136 [00:12<00:00, 10.81it/s]\n", - "100% 120/120 [00:03<00:00, 31.91it/s]\n", - "100% 136/136 [00:12<00:00, 11.07it/s]\n", - "100% 120/120 [00:03<00:00, 33.34it/s]\n", - "model: fastai_xresnet1d101\n", - "100% 954/954 [00:26<00:00, 35.90it/s]\n", - "aggregating predictions...\n", - "model: fastai_xresnet1d101\n", - "100% 120/120 [00:03<00:00, 31.33it/s]\n", - "aggregating predictions...\n", - "model: fastai_xresnet1d101\n", - "100% 121/121 [00:03<00:00, 32.11it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_resnet1d_wang\n", - " 71% 96/136 [00:21<00:09, 4.37it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 52.45it/s]\n", - "100% 136/136 [00:29<00:00, 4.59it/s]\n", - "100% 120/120 [00:02<00:00, 52.08it/s]\n", - "100% 136/136 [00:29<00:00, 4.55it/s]\n", - "100% 120/120 [00:02<00:00, 51.70it/s]\n", - "100% 136/136 [00:29<00:00, 4.58it/s]\n", - "100% 120/120 [00:02<00:00, 51.36it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.49it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.01it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 49.62it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 49.72it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.60it/s]\n", - "100% 136/136 [00:29<00:00, 4.55it/s]\n", - "100% 120/120 [00:02<00:00, 51.68it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 50.97it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.30it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.71it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.04it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 53.11it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 52.68it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 51.63it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.85it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.64it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.01it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.05it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 52.89it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.51it/s]\n", - "100% 136/136 [00:29<00:00, 4.58it/s]\n", - "100% 120/120 [00:02<00:00, 52.88it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 52.01it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 51.52it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 48.83it/s]\n", - "100% 136/136 [00:29<00:00, 4.55it/s]\n", - "100% 120/120 [00:02<00:00, 50.32it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.81it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 51.06it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 51.98it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 51.28it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 51.75it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.21it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 51.33it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 52.08it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.74it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 53.01it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.44it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 53.08it/s]\n", - "100% 136/136 [00:29<00:00, 4.58it/s]\n", - "100% 120/120 [00:02<00:00, 53.16it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 53.97it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 54.23it/s]\n", - "100% 136/136 [00:29<00:00, 4.58it/s]\n", - "100% 120/120 [00:02<00:00, 51.71it/s]\n", - "100% 136/136 [00:29<00:00, 4.56it/s]\n", - "100% 120/120 [00:02<00:00, 52.56it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 53.88it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 53.58it/s]\n", - "100% 136/136 [00:29<00:00, 4.58it/s]\n", - "100% 120/120 [00:02<00:00, 52.72it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 53.81it/s]\n", - "100% 136/136 [00:29<00:00, 4.57it/s]\n", - "100% 120/120 [00:02<00:00, 52.84it/s]\n", - "model: fastai_resnet1d_wang\n", - "100% 954/954 [00:15<00:00, 61.59it/s]\n", - "aggregating predictions...\n", - "model: fastai_resnet1d_wang\n", - "100% 120/120 [00:02<00:00, 51.85it/s]\n", - "aggregating predictions...\n", - "model: fastai_resnet1d_wang\n", - "100% 121/121 [00:02<00:00, 52.59it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_lstm\n", - " 70% 95/136 [00:09<00:03, 10.40it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:11<00:00, 12.10it/s]\n", - "100% 120/120 [00:03<00:00, 31.84it/s]\n", - "100% 136/136 [00:10<00:00, 12.48it/s]\n", - "100% 120/120 [00:03<00:00, 32.50it/s]\n", - "100% 136/136 [00:10<00:00, 12.68it/s]\n", - "100% 120/120 [00:03<00:00, 32.93it/s]\n", - "100% 136/136 [00:10<00:00, 12.73it/s]\n", - "100% 120/120 [00:03<00:00, 32.81it/s]\n", - "100% 136/136 [00:10<00:00, 12.68it/s]\n", - "100% 120/120 [00:03<00:00, 32.64it/s]\n", - "100% 136/136 [00:10<00:00, 12.56it/s]\n", - "100% 120/120 [00:03<00:00, 32.52it/s]\n", - "100% 136/136 [00:10<00:00, 12.52it/s]\n", - "100% 120/120 [00:03<00:00, 32.61it/s]\n", - "100% 136/136 [00:10<00:00, 12.58it/s]\n", - "100% 120/120 [00:03<00:00, 32.75it/s]\n", - "100% 136/136 [00:10<00:00, 12.57it/s]\n", - "100% 120/120 [00:03<00:00, 32.83it/s]\n", - "100% 136/136 [00:10<00:00, 12.61it/s]\n", - "100% 120/120 [00:03<00:00, 32.72it/s]\n", - "100% 136/136 [00:10<00:00, 12.64it/s]\n", - "100% 120/120 [00:03<00:00, 32.82it/s]\n", - "100% 136/136 [00:10<00:00, 12.63it/s]\n", - "100% 120/120 [00:03<00:00, 32.92it/s]\n", - "100% 136/136 [00:10<00:00, 12.59it/s]\n", - "100% 120/120 [00:03<00:00, 32.71it/s]\n", - "100% 136/136 [00:10<00:00, 12.57it/s]\n", - "100% 120/120 [00:03<00:00, 32.68it/s]\n", - "100% 136/136 [00:10<00:00, 12.58it/s]\n", - "100% 120/120 [00:03<00:00, 32.82it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.55it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.52it/s]\n", - "100% 136/136 [00:10<00:00, 12.54it/s]\n", - "100% 120/120 [00:03<00:00, 32.71it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.57it/s]\n", - "100% 136/136 [00:10<00:00, 12.59it/s]\n", - "100% 120/120 [00:03<00:00, 32.32it/s]\n", - "100% 136/136 [00:10<00:00, 12.55it/s]\n", - "100% 120/120 [00:03<00:00, 32.63it/s]\n", - "100% 136/136 [00:10<00:00, 12.52it/s]\n", - "100% 120/120 [00:03<00:00, 32.19it/s]\n", - "100% 136/136 [00:10<00:00, 12.50it/s]\n", - "100% 120/120 [00:03<00:00, 32.53it/s]\n", - "100% 136/136 [00:10<00:00, 12.54it/s]\n", - "100% 120/120 [00:03<00:00, 32.67it/s]\n", - "100% 136/136 [00:10<00:00, 12.49it/s]\n", - "100% 120/120 [00:03<00:00, 32.53it/s]\n", - "100% 136/136 [00:10<00:00, 12.50it/s]\n", - "100% 120/120 [00:03<00:00, 32.59it/s]\n", - "100% 136/136 [00:10<00:00, 12.51it/s]\n", - "100% 120/120 [00:03<00:00, 32.78it/s]\n", - "100% 136/136 [00:10<00:00, 12.56it/s]\n", - "100% 120/120 [00:03<00:00, 32.55it/s]\n", - "100% 136/136 [00:10<00:00, 12.57it/s]\n", - "100% 120/120 [00:03<00:00, 32.45it/s]\n", - "100% 136/136 [00:10<00:00, 12.54it/s]\n", - "100% 120/120 [00:03<00:00, 32.13it/s]\n", - "100% 136/136 [00:10<00:00, 12.48it/s]\n", - "100% 120/120 [00:03<00:00, 32.22it/s]\n", - "100% 136/136 [00:10<00:00, 12.51it/s]\n", - "100% 120/120 [00:03<00:00, 32.48it/s]\n", - "100% 136/136 [00:10<00:00, 12.51it/s]\n", - "100% 120/120 [00:03<00:00, 32.35it/s]\n", - "100% 136/136 [00:10<00:00, 12.52it/s]\n", - "100% 120/120 [00:03<00:00, 32.45it/s]\n", - "100% 136/136 [00:10<00:00, 12.54it/s]\n", - "100% 120/120 [00:03<00:00, 32.36it/s]\n", - "100% 136/136 [00:10<00:00, 12.56it/s]\n", - "100% 120/120 [00:03<00:00, 32.46it/s]\n", - "100% 136/136 [00:10<00:00, 12.52it/s]\n", - "100% 120/120 [00:03<00:00, 32.36it/s]\n", - "100% 136/136 [00:10<00:00, 12.55it/s]\n", - "100% 120/120 [00:03<00:00, 32.44it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.49it/s]\n", - "100% 136/136 [00:10<00:00, 12.55it/s]\n", - "100% 120/120 [00:03<00:00, 32.31it/s]\n", - "100% 136/136 [00:10<00:00, 12.55it/s]\n", - "100% 120/120 [00:03<00:00, 32.51it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.25it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.58it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.69it/s]\n", - "100% 136/136 [00:10<00:00, 12.55it/s]\n", - "100% 120/120 [00:03<00:00, 32.51it/s]\n", - "100% 136/136 [00:10<00:00, 12.57it/s]\n", - "100% 120/120 [00:03<00:00, 32.49it/s]\n", - "100% 136/136 [00:10<00:00, 12.57it/s]\n", - "100% 120/120 [00:03<00:00, 32.65it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.50it/s]\n", - "100% 136/136 [00:10<00:00, 12.53it/s]\n", - "100% 120/120 [00:03<00:00, 32.66it/s]\n", - "100% 136/136 [00:10<00:00, 12.52it/s]\n", - "100% 120/120 [00:03<00:00, 32.46it/s]\n", - "model: fastai_lstm\n", - "100% 954/954 [00:26<00:00, 36.67it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm\n", - "100% 120/120 [00:03<00:00, 31.71it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm\n", - "100% 121/121 [00:03<00:00, 31.49it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_lstm_bidir\n", - " 72% 98/136 [00:18<00:07, 5.23it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.82it/s]\n", - "100% 136/136 [00:24<00:00, 5.45it/s]\n", - "100% 120/120 [00:07<00:00, 15.68it/s]\n", - "100% 136/136 [00:25<00:00, 5.39it/s]\n", - "100% 120/120 [00:07<00:00, 15.69it/s]\n", - "100% 136/136 [00:25<00:00, 5.41it/s]\n", - "100% 120/120 [00:07<00:00, 15.81it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.78it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.81it/s]\n", - "100% 136/136 [00:25<00:00, 5.39it/s]\n", - "100% 120/120 [00:07<00:00, 15.83it/s]\n", - "100% 136/136 [00:25<00:00, 5.43it/s]\n", - "100% 120/120 [00:07<00:00, 15.88it/s]\n", - "100% 136/136 [00:24<00:00, 5.45it/s]\n", - "100% 120/120 [00:07<00:00, 15.85it/s]\n", - "100% 136/136 [00:25<00:00, 5.41it/s]\n", - "100% 120/120 [00:07<00:00, 15.81it/s]\n", - "100% 136/136 [00:25<00:00, 5.42it/s]\n", - "100% 120/120 [00:07<00:00, 15.81it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.77it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.82it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.82it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.81it/s]\n", - "100% 136/136 [00:25<00:00, 5.39it/s]\n", - "100% 120/120 [00:07<00:00, 15.81it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.72it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.73it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.75it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.69it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.74it/s]\n", - "100% 136/136 [00:25<00:00, 5.39it/s]\n", - "100% 120/120 [00:07<00:00, 15.71it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.64it/s]\n", - "100% 136/136 [00:25<00:00, 5.36it/s]\n", - "100% 120/120 [00:07<00:00, 15.61it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.69it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.64it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.66it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.69it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.65it/s]\n", - "100% 136/136 [00:25<00:00, 5.41it/s]\n", - "100% 120/120 [00:07<00:00, 15.74it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.64it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.70it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.75it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.70it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.70it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.64it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.73it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.71it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.72it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.71it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.71it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.71it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.71it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.70it/s]\n", - "100% 136/136 [00:25<00:00, 5.39it/s]\n", - "100% 120/120 [00:07<00:00, 15.75it/s]\n", - "100% 136/136 [00:25<00:00, 5.40it/s]\n", - "100% 120/120 [00:07<00:00, 15.74it/s]\n", - "100% 136/136 [00:25<00:00, 5.36it/s]\n", - "100% 120/120 [00:07<00:00, 15.58it/s]\n", - "100% 136/136 [00:25<00:00, 5.38it/s]\n", - "100% 120/120 [00:07<00:00, 15.68it/s]\n", - "100% 136/136 [00:25<00:00, 5.37it/s]\n", - "100% 120/120 [00:07<00:00, 15.62it/s]\n", - "100% 136/136 [00:25<00:00, 5.35it/s]\n", - "100% 120/120 [00:07<00:00, 15.63it/s]\n", - "model: fastai_lstm_bidir\n", - "100% 954/954 [00:57<00:00, 16.55it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm_bidir\n", - "100% 120/120 [00:07<00:00, 15.40it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm_bidir\n", - "100% 121/121 [00:07<00:00, 15.16it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_fcn_wang\n", - " 71% 96/136 [00:21<00:08, 4.55it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 52.21it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 52.79it/s]\n", - "100% 136/136 [00:28<00:00, 4.70it/s]\n", - "100% 120/120 [00:02<00:00, 53.22it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.72it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.03it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.58it/s]\n", - "100% 136/136 [00:28<00:00, 4.70it/s]\n", - "100% 120/120 [00:02<00:00, 53.65it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.14it/s]\n", - "100% 136/136 [00:28<00:00, 4.70it/s]\n", - "100% 120/120 [00:02<00:00, 53.79it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.83it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.50it/s]\n", - "100% 136/136 [00:28<00:00, 4.70it/s]\n", - "100% 120/120 [00:02<00:00, 52.88it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 52.65it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 54.29it/s]\n", - "100% 136/136 [00:28<00:00, 4.70it/s]\n", - "100% 120/120 [00:02<00:00, 53.90it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 54.69it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.59it/s]\n", - "100% 136/136 [00:28<00:00, 4.70it/s]\n", - "100% 120/120 [00:02<00:00, 53.65it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 54.62it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.31it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.72it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.68it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 54.14it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.14it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 52.76it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.48it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 54.36it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.23it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.69it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.97it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 49.46it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 52.70it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.37it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 54.31it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 54.18it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 54.69it/s]\n", - "100% 136/136 [00:28<00:00, 4.71it/s]\n", - "100% 120/120 [00:02<00:00, 53.19it/s]\n", - "100% 136/136 [00:28<00:00, 4.73it/s]\n", - "100% 120/120 [00:02<00:00, 52.75it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 51.64it/s]\n", - "100% 136/136 [00:28<00:00, 4.73it/s]\n", - "100% 120/120 [00:02<00:00, 51.83it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.04it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 52.51it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 52.66it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 51.80it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 54.49it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.52it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.99it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 54.35it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.17it/s]\n", - "100% 136/136 [00:28<00:00, 4.72it/s]\n", - "100% 120/120 [00:02<00:00, 53.37it/s]\n", - "model: fastai_fcn_wang\n", - "100% 954/954 [00:14<00:00, 64.46it/s]\n", - "aggregating predictions...\n", - "model: fastai_fcn_wang\n", - "100% 120/120 [00:02<00:00, 52.97it/s]\n", - "aggregating predictions...\n", - "model: fastai_fcn_wang\n", - "100% 121/121 [00:02<00:00, 52.77it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_inception1d\n", - " 71% 97/136 [00:07<00:02, 13.37it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 136/136 [00:09<00:00, 13.77it/s]\n", - "100% 120/120 [00:04<00:00, 29.29it/s]\n", - "100% 136/136 [00:09<00:00, 13.98it/s]\n", - "100% 120/120 [00:04<00:00, 29.87it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:03<00:00, 30.08it/s]\n", - "100% 136/136 [00:09<00:00, 14.31it/s]\n", - "100% 120/120 [00:03<00:00, 30.14it/s]\n", - "100% 136/136 [00:09<00:00, 14.32it/s]\n", - "100% 120/120 [00:03<00:00, 30.04it/s]\n", - "100% 136/136 [00:09<00:00, 14.25it/s]\n", - "100% 120/120 [00:03<00:00, 30.04it/s]\n", - "100% 136/136 [00:09<00:00, 14.15it/s]\n", - "100% 120/120 [00:04<00:00, 29.79it/s]\n", - "100% 136/136 [00:09<00:00, 14.13it/s]\n", - "100% 120/120 [00:04<00:00, 29.87it/s]\n", - "100% 136/136 [00:09<00:00, 14.17it/s]\n", - "100% 120/120 [00:03<00:00, 30.18it/s]\n", - "100% 136/136 [00:09<00:00, 14.20it/s]\n", - "100% 120/120 [00:03<00:00, 30.01it/s]\n", - "100% 136/136 [00:09<00:00, 14.20it/s]\n", - "100% 120/120 [00:03<00:00, 30.05it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:04<00:00, 29.96it/s]\n", - "100% 136/136 [00:09<00:00, 14.26it/s]\n", - "100% 120/120 [00:04<00:00, 29.99it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:04<00:00, 29.97it/s]\n", - "100% 136/136 [00:09<00:00, 14.21it/s]\n", - "100% 120/120 [00:04<00:00, 29.98it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:03<00:00, 30.04it/s]\n", - "100% 136/136 [00:09<00:00, 14.20it/s]\n", - "100% 120/120 [00:03<00:00, 30.04it/s]\n", - "100% 136/136 [00:09<00:00, 14.19it/s]\n", - "100% 120/120 [00:03<00:00, 30.10it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:03<00:00, 30.25it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:03<00:00, 30.16it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:03<00:00, 30.10it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:03<00:00, 30.12it/s]\n", - "100% 136/136 [00:09<00:00, 14.27it/s]\n", - "100% 120/120 [00:03<00:00, 30.06it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:03<00:00, 30.05it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:04<00:00, 29.97it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:03<00:00, 30.07it/s]\n", - "100% 136/136 [00:09<00:00, 14.20it/s]\n", - "100% 120/120 [00:03<00:00, 30.00it/s]\n", - "100% 136/136 [00:09<00:00, 14.19it/s]\n", - "100% 120/120 [00:04<00:00, 29.96it/s]\n", - "100% 136/136 [00:09<00:00, 14.18it/s]\n", - "100% 120/120 [00:03<00:00, 30.12it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:04<00:00, 29.92it/s]\n", - "100% 136/136 [00:09<00:00, 14.21it/s]\n", - "100% 120/120 [00:03<00:00, 30.11it/s]\n", - "100% 136/136 [00:09<00:00, 14.21it/s]\n", - "100% 120/120 [00:04<00:00, 29.90it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:03<00:00, 30.24it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:04<00:00, 29.98it/s]\n", - "100% 136/136 [00:09<00:00, 14.23it/s]\n", - "100% 120/120 [00:03<00:00, 30.13it/s]\n", - "100% 136/136 [00:09<00:00, 14.20it/s]\n", - "100% 120/120 [00:04<00:00, 29.93it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:03<00:00, 30.07it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:03<00:00, 30.28it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:03<00:00, 30.22it/s]\n", - "100% 136/136 [00:09<00:00, 14.22it/s]\n", - "100% 120/120 [00:03<00:00, 30.24it/s]\n", - "100% 136/136 [00:09<00:00, 14.26it/s]\n", - "100% 120/120 [00:03<00:00, 30.09it/s]\n", - "100% 136/136 [00:09<00:00, 14.20it/s]\n", - "100% 120/120 [00:03<00:00, 30.06it/s]\n", - "100% 136/136 [00:09<00:00, 14.21it/s]\n", - "100% 120/120 [00:04<00:00, 29.99it/s]\n", - "100% 136/136 [00:09<00:00, 14.21it/s]\n", - "100% 120/120 [00:03<00:00, 30.04it/s]\n", - "100% 136/136 [00:09<00:00, 14.21it/s]\n", - "100% 120/120 [00:04<00:00, 29.99it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:03<00:00, 30.19it/s]\n", - "100% 136/136 [00:09<00:00, 14.19it/s]\n", - "100% 120/120 [00:03<00:00, 30.04it/s]\n", - "100% 136/136 [00:09<00:00, 14.26it/s]\n", - "100% 120/120 [00:03<00:00, 30.27it/s]\n", - "100% 136/136 [00:09<00:00, 14.28it/s]\n", - "100% 120/120 [00:03<00:00, 30.12it/s]\n", - "100% 136/136 [00:09<00:00, 14.24it/s]\n", - "100% 120/120 [00:03<00:00, 30.26it/s]\n", - "model: fastai_inception1d\n", - "100% 954/954 [00:28<00:00, 33.74it/s]\n", - "aggregating predictions...\n", - "model: fastai_inception1d\n", - "100% 120/120 [00:04<00:00, 29.34it/s]\n", - "aggregating predictions...\n", - "model: fastai_inception1d\n", - "100% 121/121 [00:04<00:00, 29.37it/s]\n", - "aggregating predictions...\n", - "2022-09-28 08:59:01.369909: W tensorflow/core/common_runtime/gpu/gpu_bfc_allocator.cc:39] Overriding allow_growth setting because the TF_FORCE_GPU_ALLOW_GROWTH environment variable is set. Original config value was 0.\n", - "2022-09-28 08:59:01.863160: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 60276096 exceeds 10% of free system memory.\n", - "Epoch 1/30\n", - "122/137 [=========================>....] - ETA: 0s - loss: 0.2488\n", - "Epoch 1: val_loss improved from inf to 0.11387, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 2s 4ms/step - loss: 0.2367 - val_loss: 0.1139\n", - "Epoch 2/30\n", - "125/137 [==========================>...] - ETA: 0s - loss: 0.1139\n", - "Epoch 2: val_loss improved from 0.11387 to 0.09819, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.1133 - val_loss: 0.0982\n", - "Epoch 3/30\n", - "123/137 [=========================>....] - ETA: 0s - loss: 0.1000\n", - "Epoch 3: val_loss improved from 0.09819 to 0.09250, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0997 - val_loss: 0.0925\n", - "Epoch 4/30\n", - "122/137 [=========================>....] - ETA: 0s - loss: 0.0934\n", - "Epoch 4: val_loss improved from 0.09250 to 0.08926, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0931 - val_loss: 0.0893\n", - "Epoch 5/30\n", - "125/137 [==========================>...] - ETA: 0s - loss: 0.0888\n", - "Epoch 5: val_loss improved from 0.08926 to 0.08704, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0886 - val_loss: 0.0870\n", - "Epoch 6/30\n", - "120/137 [=========================>....] - ETA: 0s - loss: 0.0855\n", - "Epoch 6: val_loss improved from 0.08704 to 0.08529, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0854 - val_loss: 0.0853\n", - "Epoch 7/30\n", - "126/137 [==========================>...] - ETA: 0s - loss: 0.0830\n", - "Epoch 7: val_loss improved from 0.08529 to 0.08392, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0829 - val_loss: 0.0839\n", - "Epoch 8/30\n", - "127/137 [==========================>...] - ETA: 0s - loss: 0.0805\n", - "Epoch 8: val_loss improved from 0.08392 to 0.08311, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0805 - val_loss: 0.0831\n", - "Epoch 9/30\n", - "123/137 [=========================>....] - ETA: 0s - loss: 0.0791\n", - "Epoch 9: val_loss improved from 0.08311 to 0.08229, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0788 - val_loss: 0.0823\n", - "Epoch 10/30\n", - "128/137 [===========================>..] - ETA: 0s - loss: 0.0772\n", - "Epoch 10: val_loss improved from 0.08229 to 0.08169, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0772 - val_loss: 0.0817\n", - "Epoch 11/30\n", - "120/137 [=========================>....] - ETA: 0s - loss: 0.0758\n", - "Epoch 11: val_loss improved from 0.08169 to 0.08102, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0759 - val_loss: 0.0810\n", - "Epoch 12/30\n", - "122/137 [=========================>....] - ETA: 0s - loss: 0.0743\n", - "Epoch 12: val_loss improved from 0.08102 to 0.08049, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0744 - val_loss: 0.0805\n", - "Epoch 13/30\n", - "125/137 [==========================>...] - ETA: 0s - loss: 0.0737\n", - "Epoch 13: val_loss improved from 0.08049 to 0.07983, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0736 - val_loss: 0.0798\n", - "Epoch 14/30\n", - "121/137 [=========================>....] - ETA: 0s - loss: 0.0726\n", - "Epoch 14: val_loss improved from 0.07983 to 0.07966, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0725 - val_loss: 0.0797\n", - "Epoch 15/30\n", - "128/137 [===========================>..] - ETA: 0s - loss: 0.0717\n", - "Epoch 15: val_loss improved from 0.07966 to 0.07937, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0717 - val_loss: 0.0794\n", - "Epoch 16/30\n", - "127/137 [==========================>...] - ETA: 0s - loss: 0.0708\n", - "Epoch 16: val_loss improved from 0.07937 to 0.07896, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0708 - val_loss: 0.0790\n", - "Epoch 17/30\n", - "123/137 [=========================>....] - ETA: 0s - loss: 0.0705\n", - "Epoch 17: val_loss did not improve from 0.07896\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0702 - val_loss: 0.0790\n", - "Epoch 18/30\n", - "123/137 [=========================>....] - ETA: 0s - loss: 0.0694\n", - "Epoch 18: val_loss improved from 0.07896 to 0.07853, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0695 - val_loss: 0.0785\n", - "Epoch 19/30\n", - "124/137 [==========================>...] - ETA: 0s - loss: 0.0688\n", - "Epoch 19: val_loss improved from 0.07853 to 0.07849, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0690 - val_loss: 0.0785\n", - "Epoch 20/30\n", - "126/137 [==========================>...] - ETA: 0s - loss: 0.0684\n", - "Epoch 20: val_loss improved from 0.07849 to 0.07834, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0683 - val_loss: 0.0783\n", - "Epoch 21/30\n", - "126/137 [==========================>...] - ETA: 0s - loss: 0.0676\n", - "Epoch 21: val_loss improved from 0.07834 to 0.07815, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0678 - val_loss: 0.0781\n", - "Epoch 22/30\n", - "125/137 [==========================>...] - ETA: 0s - loss: 0.0671\n", - "Epoch 22: val_loss improved from 0.07815 to 0.07785, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0672 - val_loss: 0.0778\n", - "Epoch 23/30\n", - "124/137 [==========================>...] - ETA: 0s - loss: 0.0666\n", - "Epoch 23: val_loss improved from 0.07785 to 0.07782, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0668 - val_loss: 0.0778\n", - "Epoch 24/30\n", - "123/137 [=========================>....] - ETA: 0s - loss: 0.0662\n", - "Epoch 24: val_loss improved from 0.07782 to 0.07780, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0662 - val_loss: 0.0778\n", - "Epoch 25/30\n", - "125/137 [==========================>...] - ETA: 0s - loss: 0.0661\n", - "Epoch 25: val_loss did not improve from 0.07780\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0659 - val_loss: 0.0780\n", - "Epoch 26/30\n", - "125/137 [==========================>...] - ETA: 0s - loss: 0.0654\n", - "Epoch 26: val_loss did not improve from 0.07780\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0655 - val_loss: 0.0778\n", - "Epoch 27/30\n", - "124/137 [==========================>...] - ETA: 0s - loss: 0.0653\n", - "Epoch 27: val_loss improved from 0.07780 to 0.07775, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0650 - val_loss: 0.0777\n", - "Epoch 28/30\n", - "126/137 [==========================>...] - ETA: 0s - loss: 0.0647\n", - "Epoch 28: val_loss improved from 0.07775 to 0.07753, saving model to ../../content/output/exp0/models/Wavelet+NN/best_loss_model.h5\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0647 - val_loss: 0.0775\n", - "Epoch 29/30\n", - "122/137 [=========================>....] - ETA: 0s - loss: 0.0646\n", - "Epoch 29: val_loss did not improve from 0.07753\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0643 - val_loss: 0.0780\n", - "Epoch 30/30\n", - "123/137 [=========================>....] - ETA: 0s - loss: 0.0639\n", - "Epoch 30: val_loss did not improve from 0.07753\n", - "137/137 [==============================] - 0s 3ms/step - loss: 0.0641 - val_loss: 0.0776\n", - "2022-09-28 09:08:24.564168: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 60276096 exceeds 10% of free system memory.\n", - "Wavelet+NN\n", - "ensemble\n", - "fastai_fcn_wang\n", - "fastai_inception1d\n", - "fastai_lstm\n", - "fastai_lstm_bidir\n", - "fastai_resnet1d_wang\n", - "fastai_xresnet1d101\n", - "naive\n", - "tcmalloc: large alloc 2096357376 bytes == 0x10118e000 @ 0x7f16aa0701e7 0x4b2150 0x5ac2ec 0x5e3d6d 0x58ee7f 0x590c9f 0x591039 0x4fb96a 0x4fc108 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6\n", - "tcmalloc: large alloc 2096357376 bytes == 0x17e952000 @ 0x7f16aa0701e7 0x4b2150 0x5ac2ec 0x4fc11a 0x4fe054 0x5ef9b8 0x58ef62 0x51c455 0x5b41c5 0x58f49e 0x51837f 0x5b4a3e 0x58f49e 0x51740e 0x5b41c5 0x58f49e 0x51b221 0x58f2a7 0x517947 0x58f2a7 0x51740e 0x5b41c5 0x604133 0x606e06 0x606ecc 0x609aa6 0x64d332 0x64d4de 0x7f16a9c6dc87 0x5b561a\n", - "Training from scratch...\n", - "model: fastai_xresnet1d101\n", - " 71% 95/133 [00:09<00:03, 9.51it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 133/133 [00:12<00:00, 10.26it/s]\n", - "100% 118/118 [00:04<00:00, 28.56it/s]\n", - "100% 133/133 [00:12<00:00, 10.31it/s]\n", - "100% 118/118 [00:04<00:00, 28.81it/s]\n", - "100% 133/133 [00:12<00:00, 10.26it/s]\n", - "100% 118/118 [00:04<00:00, 28.36it/s]\n", - "100% 133/133 [00:12<00:00, 10.35it/s]\n", - "100% 118/118 [00:03<00:00, 29.63it/s]\n", - "100% 133/133 [00:12<00:00, 10.54it/s]\n", - "100% 118/118 [00:04<00:00, 27.96it/s]\n", - "100% 133/133 [00:12<00:00, 10.36it/s]\n", - "100% 118/118 [00:04<00:00, 28.60it/s]\n", - "100% 133/133 [00:12<00:00, 10.49it/s]\n", - "100% 118/118 [00:04<00:00, 28.92it/s]\n", - "100% 133/133 [00:12<00:00, 10.34it/s]\n", - "100% 118/118 [00:04<00:00, 28.53it/s]\n", - "100% 133/133 [00:13<00:00, 10.12it/s]\n", - "100% 118/118 [00:04<00:00, 28.64it/s]\n", - "100% 133/133 [00:13<00:00, 9.99it/s]\n", - "100% 118/118 [00:04<00:00, 26.34it/s]\n", - "100% 133/133 [00:12<00:00, 10.41it/s]\n", - "100% 118/118 [00:04<00:00, 29.17it/s]\n", - "100% 133/133 [00:12<00:00, 10.36it/s]\n", - "100% 118/118 [00:04<00:00, 29.27it/s]\n", - "100% 133/133 [00:12<00:00, 10.33it/s]\n", - "100% 118/118 [00:04<00:00, 29.29it/s]\n", - "100% 133/133 [00:12<00:00, 10.41it/s]\n", - "100% 118/118 [00:04<00:00, 28.23it/s]\n", - "100% 133/133 [00:12<00:00, 10.54it/s]\n", - "100% 118/118 [00:04<00:00, 29.04it/s]\n", - "100% 133/133 [00:12<00:00, 10.32it/s]\n", - "100% 118/118 [00:04<00:00, 28.52it/s]\n", - "100% 133/133 [00:12<00:00, 10.37it/s]\n", - "100% 118/118 [00:04<00:00, 28.75it/s]\n", - "100% 133/133 [00:12<00:00, 10.48it/s]\n", - "100% 118/118 [00:04<00:00, 28.89it/s]\n", - "100% 133/133 [00:12<00:00, 10.46it/s]\n", - "100% 118/118 [00:04<00:00, 28.20it/s]\n", - "100% 133/133 [00:12<00:00, 10.48it/s]\n", - "100% 118/118 [00:04<00:00, 28.60it/s]\n", - "100% 133/133 [00:13<00:00, 10.23it/s]\n", - "100% 118/118 [00:04<00:00, 29.02it/s]\n", - "100% 133/133 [00:13<00:00, 9.67it/s]\n", - "100% 118/118 [00:04<00:00, 28.83it/s]\n", - "100% 133/133 [00:12<00:00, 10.49it/s]\n", - "100% 118/118 [00:04<00:00, 26.16it/s]\n", - "100% 133/133 [00:12<00:00, 10.37it/s]\n", - "100% 118/118 [00:04<00:00, 28.84it/s]\n", - "100% 133/133 [00:12<00:00, 10.35it/s]\n", - "100% 118/118 [00:04<00:00, 28.25it/s]\n", - "100% 133/133 [00:12<00:00, 10.30it/s]\n", - "100% 118/118 [00:04<00:00, 28.33it/s]\n", - "100% 133/133 [00:13<00:00, 10.22it/s]\n", - "100% 118/118 [00:04<00:00, 28.58it/s]\n", - "100% 133/133 [00:12<00:00, 10.31it/s]\n", - "100% 118/118 [00:04<00:00, 29.16it/s]\n", - "100% 133/133 [00:12<00:00, 10.44it/s]\n", - "100% 118/118 [00:04<00:00, 28.14it/s]\n", - "100% 133/133 [00:12<00:00, 10.37it/s]\n", - "100% 118/118 [00:04<00:00, 28.58it/s]\n", - "100% 133/133 [00:12<00:00, 10.50it/s]\n", - "100% 118/118 [00:03<00:00, 29.51it/s]\n", - "100% 133/133 [00:12<00:00, 10.50it/s]\n", - "100% 118/118 [00:04<00:00, 28.68it/s]\n", - "100% 133/133 [00:13<00:00, 9.72it/s]\n", - "100% 118/118 [00:04<00:00, 28.01it/s]\n", - "100% 133/133 [00:12<00:00, 10.40it/s]\n", - "100% 118/118 [00:04<00:00, 28.33it/s]\n", - "100% 133/133 [00:12<00:00, 10.27it/s]\n", - "100% 118/118 [00:04<00:00, 29.35it/s]\n", - "100% 133/133 [00:12<00:00, 10.49it/s]\n", - "100% 118/118 [00:04<00:00, 28.97it/s]\n", - "100% 133/133 [00:12<00:00, 10.28it/s]\n", - "100% 118/118 [00:04<00:00, 28.57it/s]\n", - "100% 133/133 [00:13<00:00, 10.14it/s]\n", - "100% 118/118 [00:04<00:00, 29.09it/s]\n", - "100% 133/133 [00:12<00:00, 10.58it/s]\n", - "100% 118/118 [00:04<00:00, 28.88it/s]\n", - "100% 133/133 [00:12<00:00, 10.41it/s]\n", - "100% 118/118 [00:04<00:00, 28.51it/s]\n", - "100% 133/133 [00:12<00:00, 10.39it/s]\n", - "100% 118/118 [00:04<00:00, 28.89it/s]\n", - "100% 133/133 [00:12<00:00, 10.37it/s]\n", - "100% 118/118 [00:04<00:00, 28.93it/s]\n", - "100% 133/133 [00:12<00:00, 10.59it/s]\n", - "100% 118/118 [00:04<00:00, 29.11it/s]\n", - "100% 133/133 [00:12<00:00, 10.36it/s]\n", - "100% 118/118 [00:04<00:00, 24.48it/s]\n", - "100% 133/133 [00:13<00:00, 10.09it/s]\n", - "100% 118/118 [00:04<00:00, 28.31it/s]\n", - "100% 133/133 [00:12<00:00, 10.46it/s]\n", - "100% 118/118 [00:04<00:00, 28.99it/s]\n", - "100% 133/133 [00:12<00:00, 10.27it/s]\n", - "100% 118/118 [00:04<00:00, 28.74it/s]\n", - "100% 133/133 [00:12<00:00, 10.39it/s]\n", - "100% 118/118 [00:04<00:00, 27.77it/s]\n", - "100% 133/133 [00:12<00:00, 10.33it/s]\n", - "100% 118/118 [00:04<00:00, 28.30it/s]\n", - "100% 133/133 [00:12<00:00, 10.39it/s]\n", - "100% 118/118 [00:04<00:00, 28.00it/s]\n", - "model: fastai_xresnet1d101\n", - "100% 936/936 [00:26<00:00, 35.21it/s]\n", - "aggregating predictions...\n", - "model: fastai_xresnet1d101\n", - "100% 118/118 [00:04<00:00, 28.47it/s]\n", - "aggregating predictions...\n", - "model: fastai_xresnet1d101\n", - "100% 119/119 [00:04<00:00, 29.14it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_resnet1d_wang\n", - " 73% 97/133 [00:22<00:08, 4.29it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.28it/s]\n", - "100% 133/133 [00:29<00:00, 4.52it/s]\n", - "100% 118/118 [00:02<00:00, 43.48it/s]\n", - "100% 133/133 [00:29<00:00, 4.48it/s]\n", - "100% 118/118 [00:02<00:00, 44.09it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.32it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.33it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.87it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 44.11it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.18it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.63it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.94it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.79it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.45it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.75it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.94it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.17it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.36it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.30it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.98it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.10it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.72it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.02it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.29it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.17it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.84it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.38it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.48it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.00it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.79it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.35it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 42.91it/s]\n", - "100% 133/133 [00:29<00:00, 4.48it/s]\n", - "100% 118/118 [00:02<00:00, 43.92it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.45it/s]\n", - "100% 133/133 [00:29<00:00, 4.48it/s]\n", - "100% 118/118 [00:02<00:00, 39.40it/s]\n", - "100% 133/133 [00:29<00:00, 4.48it/s]\n", - "100% 118/118 [00:02<00:00, 42.99it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.10it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.89it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.47it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.07it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:03<00:00, 36.03it/s]\n", - "100% 133/133 [00:29<00:00, 4.48it/s]\n", - "100% 118/118 [00:02<00:00, 42.70it/s]\n", - "100% 133/133 [00:29<00:00, 4.48it/s]\n", - "100% 118/118 [00:02<00:00, 43.27it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.90it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 42.58it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 43.57it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 40.17it/s]\n", - "100% 133/133 [00:29<00:00, 4.50it/s]\n", - "100% 118/118 [00:02<00:00, 43.80it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 44.02it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 40.00it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 42.47it/s]\n", - "100% 133/133 [00:29<00:00, 4.49it/s]\n", - "100% 118/118 [00:02<00:00, 40.60it/s]\n", - "model: fastai_resnet1d_wang\n", - "100% 936/936 [00:16<00:00, 58.03it/s]\n", - "aggregating predictions...\n", - "model: fastai_resnet1d_wang\n", - "100% 118/118 [00:03<00:00, 39.33it/s]\n", - "aggregating predictions...\n", - "model: fastai_resnet1d_wang\n", - "100% 119/119 [00:03<00:00, 39.20it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_lstm\n", - " 74% 99/133 [00:08<00:03, 11.25it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 133/133 [00:11<00:00, 11.49it/s]\n", - "100% 118/118 [00:04<00:00, 28.04it/s]\n", - "100% 133/133 [00:11<00:00, 11.85it/s]\n", - "100% 118/118 [00:04<00:00, 28.37it/s]\n", - "100% 133/133 [00:11<00:00, 12.06it/s]\n", - "100% 118/118 [00:04<00:00, 28.82it/s]\n", - "100% 133/133 [00:11<00:00, 12.05it/s]\n", - "100% 118/118 [00:04<00:00, 26.70it/s]\n", - "100% 133/133 [00:11<00:00, 11.95it/s]\n", - "100% 118/118 [00:04<00:00, 28.41it/s]\n", - "100% 133/133 [00:11<00:00, 11.88it/s]\n", - "100% 118/118 [00:04<00:00, 28.04it/s]\n", - "100% 133/133 [00:11<00:00, 11.89it/s]\n", - "100% 118/118 [00:04<00:00, 27.97it/s]\n", - "100% 133/133 [00:11<00:00, 11.90it/s]\n", - "100% 118/118 [00:04<00:00, 28.39it/s]\n", - "100% 133/133 [00:11<00:00, 12.00it/s]\n", - "100% 118/118 [00:04<00:00, 28.19it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.45it/s]\n", - "100% 133/133 [00:11<00:00, 12.00it/s]\n", - "100% 118/118 [00:04<00:00, 28.21it/s]\n", - "100% 133/133 [00:11<00:00, 11.90it/s]\n", - "100% 118/118 [00:04<00:00, 28.15it/s]\n", - "100% 133/133 [00:11<00:00, 11.93it/s]\n", - "100% 118/118 [00:04<00:00, 28.28it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.59it/s]\n", - "100% 133/133 [00:11<00:00, 11.97it/s]\n", - "100% 118/118 [00:04<00:00, 28.54it/s]\n", - "100% 133/133 [00:11<00:00, 11.95it/s]\n", - "100% 118/118 [00:04<00:00, 28.73it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.49it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.57it/s]\n", - "100% 133/133 [00:11<00:00, 11.99it/s]\n", - "100% 118/118 [00:04<00:00, 28.71it/s]\n", - "100% 133/133 [00:11<00:00, 11.97it/s]\n", - "100% 118/118 [00:04<00:00, 28.62it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.67it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.76it/s]\n", - "100% 133/133 [00:11<00:00, 11.97it/s]\n", - "100% 118/118 [00:04<00:00, 28.46it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.48it/s]\n", - "100% 133/133 [00:11<00:00, 12.00it/s]\n", - "100% 118/118 [00:04<00:00, 28.64it/s]\n", - "100% 133/133 [00:11<00:00, 11.95it/s]\n", - "100% 118/118 [00:04<00:00, 28.41it/s]\n", - "100% 133/133 [00:11<00:00, 11.99it/s]\n", - "100% 118/118 [00:04<00:00, 28.48it/s]\n", - "100% 133/133 [00:11<00:00, 11.99it/s]\n", - "100% 118/118 [00:04<00:00, 28.33it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.59it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.50it/s]\n", - "100% 133/133 [00:11<00:00, 11.99it/s]\n", - "100% 118/118 [00:04<00:00, 28.51it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.59it/s]\n", - "100% 133/133 [00:11<00:00, 11.95it/s]\n", - "100% 118/118 [00:04<00:00, 28.61it/s]\n", - "100% 133/133 [00:11<00:00, 11.97it/s]\n", - "100% 118/118 [00:04<00:00, 28.67it/s]\n", - "100% 133/133 [00:11<00:00, 11.97it/s]\n", - "100% 118/118 [00:04<00:00, 28.82it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.68it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.38it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.61it/s]\n", - "100% 133/133 [00:11<00:00, 12.06it/s]\n", - "100% 118/118 [00:04<00:00, 28.61it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.37it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.46it/s]\n", - "100% 133/133 [00:11<00:00, 11.93it/s]\n", - "100% 118/118 [00:04<00:00, 28.73it/s]\n", - "100% 133/133 [00:11<00:00, 11.96it/s]\n", - "100% 118/118 [00:04<00:00, 28.62it/s]\n", - "100% 133/133 [00:11<00:00, 12.00it/s]\n", - "100% 118/118 [00:04<00:00, 28.59it/s]\n", - "100% 133/133 [00:11<00:00, 11.98it/s]\n", - "100% 118/118 [00:04<00:00, 28.35it/s]\n", - "100% 133/133 [00:11<00:00, 12.03it/s]\n", - "100% 118/118 [00:04<00:00, 28.47it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.58it/s]\n", - "100% 133/133 [00:11<00:00, 12.00it/s]\n", - "100% 118/118 [00:04<00:00, 28.53it/s]\n", - "100% 133/133 [00:11<00:00, 12.01it/s]\n", - "100% 118/118 [00:04<00:00, 28.61it/s]\n", - "100% 133/133 [00:11<00:00, 12.00it/s]\n", - "100% 118/118 [00:04<00:00, 28.79it/s]\n", - "model: fastai_lstm\n", - "100% 936/936 [00:26<00:00, 35.88it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm\n", - "100% 118/118 [00:04<00:00, 28.35it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm\n", - "100% 119/119 [00:04<00:00, 28.30it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_lstm_bidir\n", - " 74% 99/133 [00:19<00:06, 5.13it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.87it/s]\n", - "100% 133/133 [00:24<00:00, 5.35it/s]\n", - "100% 118/118 [00:08<00:00, 14.73it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.65it/s]\n", - "100% 133/133 [00:25<00:00, 5.31it/s]\n", - "100% 118/118 [00:07<00:00, 14.89it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.78it/s]\n", - "100% 133/133 [00:25<00:00, 5.27it/s]\n", - "100% 118/118 [00:07<00:00, 14.79it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.79it/s]\n", - "100% 133/133 [00:25<00:00, 5.31it/s]\n", - "100% 118/118 [00:07<00:00, 14.81it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.88it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.80it/s]\n", - "100% 133/133 [00:25<00:00, 5.30it/s]\n", - "100% 118/118 [00:07<00:00, 14.76it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.78it/s]\n", - "100% 133/133 [00:25<00:00, 5.30it/s]\n", - "100% 118/118 [00:07<00:00, 14.83it/s]\n", - "100% 133/133 [00:25<00:00, 5.30it/s]\n", - "100% 118/118 [00:07<00:00, 14.76it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.74it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.82it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.80it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:08<00:00, 14.74it/s]\n", - "100% 133/133 [00:25<00:00, 5.30it/s]\n", - "100% 118/118 [00:08<00:00, 14.74it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.81it/s]\n", - "100% 133/133 [00:25<00:00, 5.30it/s]\n", - "100% 118/118 [00:07<00:00, 14.88it/s]\n", - "100% 133/133 [00:25<00:00, 5.27it/s]\n", - "100% 118/118 [00:07<00:00, 14.76it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.78it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.81it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.81it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.78it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.79it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.76it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.82it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.73it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.77it/s]\n", - "100% 133/133 [00:25<00:00, 5.27it/s]\n", - "100% 118/118 [00:07<00:00, 14.82it/s]\n", - "100% 133/133 [00:25<00:00, 5.26it/s]\n", - "100% 118/118 [00:07<00:00, 14.76it/s]\n", - "100% 133/133 [00:25<00:00, 5.27it/s]\n", - "100% 118/118 [00:08<00:00, 14.73it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.80it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.72it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.70it/s]\n", - "100% 133/133 [00:25<00:00, 5.29it/s]\n", - "100% 118/118 [00:07<00:00, 14.77it/s]\n", - "100% 133/133 [00:25<00:00, 5.30it/s]\n", - "100% 118/118 [00:07<00:00, 14.87it/s]\n", - "100% 133/133 [00:25<00:00, 5.27it/s]\n", - "100% 118/118 [00:07<00:00, 14.79it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.64it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.73it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.78it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.71it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.75it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.76it/s]\n", - "100% 133/133 [00:25<00:00, 5.27it/s]\n", - "100% 118/118 [00:07<00:00, 14.77it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:08<00:00, 14.73it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.80it/s]\n", - "100% 133/133 [00:25<00:00, 5.28it/s]\n", - "100% 118/118 [00:07<00:00, 14.77it/s]\n", - "model: fastai_lstm_bidir\n", - "100% 936/936 [00:56<00:00, 16.45it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm_bidir\n", - "100% 118/118 [00:08<00:00, 14.69it/s]\n", - "aggregating predictions...\n", - "model: fastai_lstm_bidir\n", - "100% 119/119 [00:08<00:00, 14.39it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_fcn_wang\n", - " 73% 97/133 [00:21<00:08, 4.47it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 133/133 [00:28<00:00, 4.65it/s]\n", - "100% 118/118 [00:02<00:00, 43.58it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.49it/s]\n", - "100% 133/133 [00:28<00:00, 4.62it/s]\n", - "100% 118/118 [00:02<00:00, 44.56it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.09it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.73it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.72it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.87it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.11it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.59it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.85it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.50it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 43.96it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.69it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.47it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 43.55it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.77it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.77it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.46it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.93it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.60it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 43.56it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.21it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.15it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.92it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.24it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.53it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.03it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.34it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.68it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.44it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.02it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.88it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.09it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.88it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.16it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.82it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.63it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.63it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 43.72it/s]\n", - "100% 133/133 [00:28<00:00, 4.65it/s]\n", - "100% 118/118 [00:02<00:00, 43.33it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 43.02it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 43.20it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.85it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 42.68it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 44.21it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 43.75it/s]\n", - "100% 133/133 [00:28<00:00, 4.64it/s]\n", - "100% 118/118 [00:02<00:00, 44.32it/s]\n", - "100% 133/133 [00:28<00:00, 4.63it/s]\n", - "100% 118/118 [00:02<00:00, 45.10it/s]\n", - "100% 133/133 [00:28<00:00, 4.65it/s]\n", - "100% 118/118 [00:02<00:00, 42.85it/s]\n", - "100% 133/133 [00:28<00:00, 4.65it/s]\n", - "100% 118/118 [00:02<00:00, 43.57it/s]\n", - "model: fastai_fcn_wang\n", - "100% 936/936 [00:15<00:00, 61.09it/s]\n", - "aggregating predictions...\n", - "model: fastai_fcn_wang\n", - "100% 118/118 [00:02<00:00, 43.08it/s]\n", - "aggregating predictions...\n", - "model: fastai_fcn_wang\n", - "100% 119/119 [00:02<00:00, 44.31it/s]\n", - "aggregating predictions...\n", - "Training from scratch...\n", - "model: fastai_inception1d\n", - " 74% 98/133 [00:07<00:02, 12.72it/s]\n", - "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n", - "100% 133/133 [00:10<00:00, 13.19it/s]\n", - "100% 118/118 [00:04<00:00, 26.66it/s]\n", - "100% 133/133 [00:09<00:00, 13.37it/s]\n", - "100% 118/118 [00:04<00:00, 26.97it/s]\n", - "100% 133/133 [00:09<00:00, 13.56it/s]\n", - "100% 118/118 [00:04<00:00, 27.31it/s]\n", - "100% 133/133 [00:09<00:00, 13.71it/s]\n", - "100% 118/118 [00:04<00:00, 27.15it/s]\n", - "100% 133/133 [00:09<00:00, 13.60it/s]\n", - "100% 118/118 [00:04<00:00, 26.99it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 26.89it/s]\n", - "100% 133/133 [00:09<00:00, 13.49it/s]\n", - "100% 118/118 [00:04<00:00, 26.86it/s]\n", - "100% 133/133 [00:09<00:00, 13.46it/s]\n", - "100% 118/118 [00:04<00:00, 26.95it/s]\n", - "100% 133/133 [00:09<00:00, 13.54it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.63it/s]\n", - "100% 118/118 [00:04<00:00, 26.95it/s]\n", - "100% 133/133 [00:09<00:00, 13.54it/s]\n", - "100% 118/118 [00:04<00:00, 26.89it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 27.12it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 27.03it/s]\n", - "100% 133/133 [00:09<00:00, 13.58it/s]\n", - "100% 118/118 [00:04<00:00, 27.18it/s]\n", - "100% 133/133 [00:09<00:00, 13.57it/s]\n", - "100% 118/118 [00:04<00:00, 26.90it/s]\n", - "100% 133/133 [00:09<00:00, 13.50it/s]\n", - "100% 118/118 [00:04<00:00, 26.91it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.08it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.52it/s]\n", - "100% 118/118 [00:04<00:00, 27.23it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.08it/s]\n", - "100% 133/133 [00:09<00:00, 13.54it/s]\n", - "100% 118/118 [00:04<00:00, 27.21it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 26.87it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 27.04it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 27.10it/s]\n", - "100% 133/133 [00:09<00:00, 13.56it/s]\n", - "100% 118/118 [00:04<00:00, 27.23it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.22it/s]\n", - "100% 133/133 [00:09<00:00, 13.57it/s]\n", - "100% 118/118 [00:04<00:00, 26.89it/s]\n", - "100% 133/133 [00:09<00:00, 13.54it/s]\n", - "100% 118/118 [00:04<00:00, 27.16it/s]\n", - "100% 133/133 [00:09<00:00, 13.57it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 26.94it/s]\n", - "100% 133/133 [00:09<00:00, 13.56it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.32it/s]\n", - "100% 133/133 [00:09<00:00, 13.57it/s]\n", - "100% 118/118 [00:04<00:00, 26.98it/s]\n", - "100% 133/133 [00:09<00:00, 13.57it/s]\n", - "100% 118/118 [00:04<00:00, 27.10it/s]\n", - "100% 133/133 [00:09<00:00, 13.58it/s]\n", - "100% 118/118 [00:04<00:00, 26.98it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 26.94it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.60it/s]\n", - "100% 118/118 [00:04<00:00, 27.24it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.56it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.52it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 26.93it/s]\n", - "100% 133/133 [00:09<00:00, 13.54it/s]\n", - "100% 118/118 [00:04<00:00, 27.15it/s]\n", - "100% 133/133 [00:09<00:00, 13.58it/s]\n", - "100% 118/118 [00:04<00:00, 27.09it/s]\n", - "100% 133/133 [00:09<00:00, 13.57it/s]\n", - "100% 118/118 [00:04<00:00, 27.29it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.07it/s]\n", - "100% 133/133 [00:09<00:00, 13.56it/s]\n", - "100% 118/118 [00:04<00:00, 27.04it/s]\n", - "100% 133/133 [00:09<00:00, 13.59it/s]\n", - "100% 118/118 [00:04<00:00, 27.05it/s]\n", - "100% 133/133 [00:09<00:00, 13.54it/s]\n", - "100% 118/118 [00:04<00:00, 27.11it/s]\n", - "100% 133/133 [00:09<00:00, 13.55it/s]\n", - "100% 118/118 [00:04<00:00, 27.09it/s]\n", - "model: fastai_inception1d\n", - "100% 936/936 [00:28<00:00, 33.14it/s]\n", - "aggregating predictions...\n", - "model: fastai_inception1d\n", - "100% 118/118 [00:04<00:00, 26.32it/s]\n", - "aggregating predictions...\n", - "model: fastai_inception1d\n", - "100% 119/119 [00:04<00:00, 26.28it/s]\n", - "aggregating predictions...\n", - "2022-09-28 11:38:28.361399: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 59135616 exceeds 10% of free system memory.\n", - "Epoch 1/30\n", - "134/134 [==============================] - ETA: 0s - loss: 0.2110\n", - "Epoch 1: val_loss improved from inf to 0.10371, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 1s 4ms/step - loss: 0.2110 - val_loss: 0.1037\n", - "Epoch 2/30\n", - "125/134 [==========================>...] - ETA: 0s - loss: 0.1069\n", - "Epoch 2: val_loss improved from 0.10371 to 0.09109, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.1065 - val_loss: 0.0911\n", - "Epoch 3/30\n", - "125/134 [==========================>...] - ETA: 0s - loss: 0.0943\n", - "Epoch 3: val_loss improved from 0.09109 to 0.08612, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0942 - val_loss: 0.0861\n", - "Epoch 4/30\n", - "126/134 [===========================>..] - ETA: 0s - loss: 0.0878\n", - "Epoch 4: val_loss improved from 0.08612 to 0.08316, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0875 - val_loss: 0.0832\n", - "Epoch 5/30\n", - "122/134 [==========================>...] - ETA: 0s - loss: 0.0836\n", - "Epoch 5: val_loss improved from 0.08316 to 0.08116, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0834 - val_loss: 0.0812\n", - "Epoch 6/30\n", - "123/134 [==========================>...] - ETA: 0s - loss: 0.0799\n", - "Epoch 6: val_loss improved from 0.08116 to 0.07985, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0800 - val_loss: 0.0798\n", - "Epoch 7/30\n", - "122/134 [==========================>...] - ETA: 0s - loss: 0.0778\n", - "Epoch 7: val_loss improved from 0.07985 to 0.07853, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0777 - val_loss: 0.0785\n", - "Epoch 8/30\n", - "124/134 [==========================>...] - ETA: 0s - loss: 0.0753\n", - "Epoch 8: val_loss improved from 0.07853 to 0.07768, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0754 - val_loss: 0.0777\n", - "Epoch 9/30\n", - "124/134 [==========================>...] - ETA: 0s - loss: 0.0734\n", - "Epoch 9: val_loss improved from 0.07768 to 0.07687, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0735 - val_loss: 0.0769\n", - "Epoch 10/30\n", - "117/134 [=========================>....] - ETA: 0s - loss: 0.0720\n", - "Epoch 10: val_loss improved from 0.07687 to 0.07677, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0718 - val_loss: 0.0768\n", - "Epoch 11/30\n", - "119/134 [=========================>....] - ETA: 0s - loss: 0.0704\n", - "Epoch 11: val_loss improved from 0.07677 to 0.07592, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0705 - val_loss: 0.0759\n", - "Epoch 12/30\n", - "126/134 [===========================>..] - ETA: 0s - loss: 0.0691\n", - "Epoch 12: val_loss improved from 0.07592 to 0.07529, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0691 - val_loss: 0.0753\n", - "Epoch 13/30\n", - "120/134 [=========================>....] - ETA: 0s - loss: 0.0681\n", - "Epoch 13: val_loss did not improve from 0.07529\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0681 - val_loss: 0.0755\n", - "Epoch 14/30\n", - "123/134 [==========================>...] - ETA: 0s - loss: 0.0671\n", - "Epoch 14: val_loss improved from 0.07529 to 0.07491, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0672 - val_loss: 0.0749\n", - "Epoch 15/30\n", - "119/134 [=========================>....] - ETA: 0s - loss: 0.0664\n", - "Epoch 15: val_loss improved from 0.07491 to 0.07460, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0662 - val_loss: 0.0746\n", - "Epoch 16/30\n", - "125/134 [==========================>...] - ETA: 0s - loss: 0.0652\n", - "Epoch 16: val_loss improved from 0.07460 to 0.07441, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0652 - val_loss: 0.0744\n", - "Epoch 17/30\n", - "119/134 [=========================>....] - ETA: 0s - loss: 0.0641\n", - "Epoch 17: val_loss improved from 0.07441 to 0.07425, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0644 - val_loss: 0.0742\n", - "Epoch 18/30\n", - "121/134 [==========================>...] - ETA: 0s - loss: 0.0636\n", - "Epoch 18: val_loss improved from 0.07425 to 0.07413, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0639 - val_loss: 0.0741\n", - "Epoch 19/30\n", - "123/134 [==========================>...] - ETA: 0s - loss: 0.0633\n", - "Epoch 19: val_loss did not improve from 0.07413\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0633 - val_loss: 0.0742\n", - "Epoch 20/30\n", - "121/134 [==========================>...] - ETA: 0s - loss: 0.0627\n", - "Epoch 20: val_loss improved from 0.07413 to 0.07383, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0628 - val_loss: 0.0738\n", - "Epoch 21/30\n", - "126/134 [===========================>..] - ETA: 0s - loss: 0.0620\n", - "Epoch 21: val_loss improved from 0.07383 to 0.07378, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0619 - val_loss: 0.0738\n", - "Epoch 22/30\n", - "123/134 [==========================>...] - ETA: 0s - loss: 0.0619\n", - "Epoch 22: val_loss did not improve from 0.07378\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0617 - val_loss: 0.0739\n", - "Epoch 23/30\n", - "121/134 [==========================>...] - ETA: 0s - loss: 0.0614\n", - "Epoch 23: val_loss did not improve from 0.07378\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0610 - val_loss: 0.0739\n", - "Epoch 24/30\n", - "114/134 [========================>.....] - ETA: 0s - loss: 0.0607\n", - "Epoch 24: val_loss did not improve from 0.07378\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0606 - val_loss: 0.0741\n", - "Epoch 25/30\n", - "123/134 [==========================>...] - ETA: 0s - loss: 0.0602\n", - "Epoch 25: val_loss did not improve from 0.07378\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0601 - val_loss: 0.0739\n", - "Epoch 26/30\n", - "124/134 [==========================>...] - ETA: 0s - loss: 0.0599\n", - "Epoch 26: val_loss improved from 0.07378 to 0.07366, saving model to ../../content/output/exp1/models/Wavelet+NN/best_loss_model.h5\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0598 - val_loss: 0.0737\n", - "Epoch 27/30\n", - "124/134 [==========================>...] - ETA: 0s - loss: 0.0594\n", - "Epoch 27: val_loss did not improve from 0.07366\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0593 - val_loss: 0.0737\n", - "Epoch 28/30\n", - "118/134 [=========================>....] - ETA: 0s - loss: 0.0588\n", - "Epoch 28: val_loss did not improve from 0.07366\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0590 - val_loss: 0.0737\n", - "Epoch 29/30\n", - "124/134 [==========================>...] - ETA: 0s - loss: 0.0580\n", - "Epoch 29: val_loss did not improve from 0.07366\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0582 - val_loss: 0.0739\n", - "Epoch 30/30\n", - "122/134 [==========================>...] - ETA: 0s - loss: 0.0578\n", - "Epoch 30: val_loss did not improve from 0.07366\n", - "134/134 [==============================] - 0s 3ms/step - loss: 0.0579 - val_loss: 0.0740\n", - "2022-09-28 11:47:43.228052: W tensorflow/core/framework/cpu_allocator_impl.cc:82] Allocation of 59135616 exceeds 10% of free system memory.\n", - "Wavelet+NN\n", - "ensemble\n", - "fastai_fcn_wang\n", - "fastai_inception1d\n", - "fastai_lstm\n", - "fastai_lstm_bidir\n", - "fastai_resnet1d_wang\n", - "fastai_xresnet1d101\n", - "naive\n", - "Process ForkPoolWorker-5351:\n", - "Process ForkPoolWorker-5539:\n", - "Process ForkPoolWorker-5537:\n", - "Process ForkPoolWorker-5536:\n", - "Process ForkPoolWorker-5345:\n", - "Process ForkPoolWorker-5307:\n", - "Process ForkPoolWorker-5533:\n", - "Process ForkPoolWorker-5535:\n", - "Process ForkPoolWorker-5344:\n", - "Process ForkPoolWorker-5303:\n", - "Process ForkPoolWorker-5352:\n", - "Process ForkPoolWorker-5534:\n", - "Process ForkPoolWorker-5335:\n", - "Process ForkPoolWorker-5342:\n", - "Process ForkPoolWorker-5330:\n", - "Process ForkPoolWorker-5302:\n", - "Process ForkPoolWorker-5350:\n", - "Process ForkPoolWorker-5340:\n", - "Process ForkPoolWorker-5328:\n", - "Process ForkPoolWorker-5349:\n", - "Process ForkPoolWorker-5331:\n", - "Process ForkPoolWorker-5301:\n", - "Process ForkPoolWorker-5319:\n", - "Process ForkPoolWorker-5322:\n", - "Process ForkPoolWorker-5348:\n", - "Process ForkPoolWorker-5313:\n", - "Process ForkPoolWorker-5318:\n", - "Process ForkPoolWorker-5310:\n", - "Process ForkPoolWorker-5347:\n", - "Process ForkPoolWorker-5297:\n", - "Process ForkPoolWorker-5314:\n", - "Process ForkPoolWorker-5291:\n", - "Process ForkPoolWorker-5287:\n", - "Process ForkPoolWorker-5346:\n", - "Process ForkPoolWorker-5308:\n", - "Process ForkPoolWorker-5294:\n", - "Process ForkPoolWorker-2581:\n", - "Process ForkPoolWorker-5343:\n", - "Process ForkPoolWorker-5306:\n", - "Process ForkPoolWorker-5290:\n", - "Process ForkPoolWorker-2565:\n", - "Process ForkPoolWorker-5341:\n", - "Process ForkPoolWorker-5285:\n", - "Process ForkPoolWorker-5304:\n", - "Process ForkPoolWorker-2551:\n", - "Process ForkPoolWorker-5339:\n", - "Process ForkPoolWorker-2528:\n", - "Process ForkPoolWorker-5276:\n", - "Process ForkPoolWorker-5300:\n", - "Process ForkPoolWorker-2521:\n", - "Process ForkPoolWorker-5338:\n", - "Process ForkPoolWorker-2584:\n", - "Process ForkPoolWorker-5295:\n", - "Process ForkPoolWorker-2499:\n", - "Process ForkPoolWorker-5337:\n", - "Process ForkPoolWorker-2579:\n", - "Process ForkPoolWorker-5292:\n", - "Process ForkPoolWorker-5280:\n", - "Process ForkPoolWorker-5336:\n", - "Process ForkPoolWorker-2585:\n", - "Process ForkPoolWorker-2577:\n", - "Process ForkPoolWorker-5289:\n", - "Process ForkPoolWorker-5541:\n", - "Process ForkPoolWorker-5334:\n", - "Process ForkPoolWorker-2552:\n", - "Process ForkPoolWorker-2573:\n", - "Process ForkPoolWorker-5288:\n", - "Process ForkPoolWorker-2527:\n", - "Process ForkPoolWorker-5333:\n", - "Process ForkPoolWorker-2519:\n", - "Process ForkPoolWorker-2569:\n", - "Process ForkPoolWorker-5286:\n", - "Process ForkPoolWorker-5540:\n", - "Process ForkPoolWorker-2529:\n", - "Process ForkPoolWorker-5321:\n", - "Process ForkPoolWorker-5299:\n", - "Process ForkPoolWorker-2502:\n", - "Process ForkPoolWorker-5296:\n", - "Process ForkPoolWorker-2578:\n", - "Process ForkPoolWorker-5309:\n", - "Process ForkPoolWorker-2511:\n", - "Process ForkPoolWorker-2559:\n", - "Process ForkPoolWorker-2570:\n", - "Process ForkPoolWorker-2498:\n", - "Process ForkPoolWorker-5327:\n", - "Process ForkPoolWorker-5332:\n", - "Process ForkPoolWorker-2556:\n", - "Process ForkPoolWorker-5542:\n", - "Process ForkPoolWorker-2518:\n", - "Process ForkPoolWorker-5281:\n", - "Process ForkPoolWorker-5311:\n", - "Process ForkPoolWorker-5329:\n", - "Process ForkPoolWorker-2516:\n", - "Process ForkPoolWorker-5279:\n", - "Process ForkPoolWorker-2558:\n", - "Process ForkPoolWorker-5326:\n", - "Process ForkPoolWorker-2571:\n", - "Process ForkPoolWorker-2515:\n", - "Process ForkPoolWorker-5274:\n", - "Process ForkPoolWorker-5325:\n", - "Process ForkPoolWorker-2503:\n", - "Process ForkPoolWorker-5323:\n", - "Process ForkPoolWorker-2583:\n", - "Process ForkPoolWorker-2582:\n", - "Process ForkPoolWorker-2501:\n", - "Process ForkPoolWorker-5320:\n", - "Process ForkPoolWorker-2560:\n", - "Process ForkPoolWorker-5538:\n", - "Process ForkPoolWorker-2553:\n", - "Process ForkPoolWorker-5317:\n", - "Process ForkPoolWorker-5543:\n", - "Process ForkPoolWorker-2509:\n", - "Process ForkPoolWorker-5316:\n", - "Process ForkPoolWorker-2505:\n", - "Process ForkPoolWorker-2566:\n", - "Process ForkPoolWorker-2500:\n", - "Process ForkPoolWorker-2506:\n", - "Process ForkPoolWorker-2504:\n", - "Process ForkPoolWorker-2497:\n", - "Process ForkPoolWorker-2557:\n", - "Process ForkPoolWorker-2572:\n", - "Process ForkPoolWorker-5315:\n", - "Process ForkPoolWorker-2531:\n", - "Process ForkPoolWorker-2567:\n", - "Process ForkPoolWorker-5265:\n", - "Process ForkPoolWorker-5264:\n", - "Process ForkPoolWorker-2512:\n", - "Process ForkPoolWorker-5312:\n", - "Process ForkPoolWorker-5324:\n", - "Process ForkPoolWorker-5267:\n", - "Process ForkPoolWorker-5283:\n", - "Process ForkPoolWorker-5270:\n", - "Process ForkPoolWorker-2507:\n", - "Process ForkPoolWorker-2532:\n", - "Process ForkPoolWorker-2510:\n", - "Process ForkPoolWorker-2564:\n", - "Process ForkPoolWorker-5305:\n", - "Process ForkPoolWorker-5273:\n", - "Process ForkPoolWorker-5298:\n", - "Process ForkPoolWorker-5293:\n", - "Process ForkPoolWorker-5284:\n", - "Process ForkPoolWorker-5282:\n", - "Process ForkPoolWorker-5278:\n", - "Process ForkPoolWorker-5263:\n", - "Process ForkPoolWorker-5277:\n", - "Process ForkPoolWorker-5275:\n", - "Process ForkPoolWorker-5272:\n", - "Process ForkPoolWorker-5271:\n", - "Process ForkPoolWorker-5269:\n", - "Process ForkPoolWorker-2517:\n", - "Process ForkPoolWorker-2514:\n", - "Process ForkPoolWorker-2520:\n", - "Process ForkPoolWorker-2522:\n", - "Process ForkPoolWorker-2513:\n", - "Process ForkPoolWorker-2523:\n", - "Process ForkPoolWorker-2508:\n", - "Process ForkPoolWorker-2524:\n", - "Process ForkPoolWorker-2525:\n", - "Process ForkPoolWorker-2526:\n", - "Process ForkPoolWorker-2530:\n", - "Process ForkPoolWorker-2554:\n", - "Process ForkPoolWorker-2555:\n", - "Process ForkPoolWorker-2575:\n", - "Process ForkPoolWorker-5268:\n", - "Process ForkPoolWorker-2574:\n", - "Process ForkPoolWorker-5266:\n", - "Process ForkPoolWorker-2568:\n", - "Process ForkPoolWorker-2586:\n", - "Process ForkPoolWorker-2563:\n", - "Process ForkPoolWorker-2580:\n", - "Process ForkPoolWorker-2562:\n", - "Process ForkPoolWorker-2576:\n", - "Process ForkPoolWorker-2561:\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "Traceback (most recent call last):\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 352, in get\n", - " res = self._reader.recv_bytes()\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 216, in recv_bytes\n", - " buf = self._recv_bytes(maxlength)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 407, in _recv_bytes\n", - " buf = self._recv(4)\n", - " File \"/usr/lib/python3.7/multiprocessing/connection.py\", line 379, in _recv\n", - " chunk = read(handle, remaining)\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n", - "KeyboardInterrupt\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 297, in _bootstrap\n", - " self.run()\n", - " File \"/usr/lib/python3.7/multiprocessing/process.py\", line 99, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"/usr/lib/python3.7/multiprocessing/pool.py\", line 110, in worker\n", - " task = get()\n", - " File \"/usr/lib/python3.7/multiprocessing/queues.py\", line 351, in get\n", - " with self._rlock:\n", - " File \"/usr/lib/python3.7/multiprocessing/synchronize.py\", line 95, in __enter__\n", - " return self._semlock.__enter__()\n", - "KeyboardInterrupt\n" - ] - } - ], - "source": [ - "!python /content/github_repo/code/reproduce_results.py '../../content/data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/' '../data/ICBEB/' '../../content/drive/MyDrive/PTB-xl-output/'" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1986c1d6-8c33-4e71-bd39-31c25cd57af6", - "metadata": { - "id": "1986c1d6-8c33-4e71-bd39-31c25cd57af6" - }, - "outputs": [], - "source": [ - "sampling_frequency=100 #500\n", - "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task='superdiagnostic'\n", - "outputfolder='./'" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9565781f-afb0-4649-b3a3-8e39dd598ae2", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "9565781f-afb0-4649-b3a3-8e39dd598ae2", - "outputId": "835fcbf1-bab9-4997-fb54-b9fe10baaed1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wfdb in /usr/local/lib/python3.7/dist-packages (4.0.0)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (0.10.3.post1)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.3.5)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.7/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.7/dist-packages (from wfdb) (2.23.0)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.7/dist-packages (from kiwisolver>=1.0.1->matplotlib<4.0.0,>=3.2.2->wfdb) (4.1.1)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.7/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.2.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.6.15)\n", - "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.0.4)\n", - "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.7/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.7/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n" - ] - } - ], - "source": [ - "!pip install wfdb\n", - "import wfdb" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c0514023-5537-4297-8865-b28ab6bf8581", - "metadata": { - "id": "c0514023-5537-4297-8865-b28ab6bf8581" - }, - "outputs": [], - "source": [ - "import os\n", - "import sys\n", - "import re\n", - "import glob\n", - "import pickle\n", - "import copy\n", - "\n", - "import pandas as pd\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from tqdm import tqdm\n", - "\n", - "import ast\n", - "from sklearn.metrics import fbeta_score, roc_auc_score, roc_curve, roc_curve, auc\n", - "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", - "from matplotlib.axes._axes import _log as matplotlib_axes_logger\n", - "import warnings\n", - "\n", - "# EVALUATION STUFF\n", - "def generate_results(idxs, y_true, y_pred, thresholds):\n", - " return evaluate_experiment(y_true[idxs], y_pred[idxs], thresholds)\n", - "\n", - "def evaluate_experiment(y_true, y_pred, thresholds=None):\n", - " results = {}\n", - "\n", - " if not thresholds is None:\n", - " # binary predictions\n", - " y_pred_binary = apply_thresholds(y_pred, thresholds)\n", - " # PhysioNet/CinC Challenges metrics\n", - " challenge_scores = challenge_metrics(y_true, y_pred_binary, beta1=2, beta2=2)\n", - " results['F_beta_macro'] = challenge_scores['F_beta_macro']\n", - " results['G_beta_macro'] = challenge_scores['G_beta_macro']\n", - "\n", - " # label based metric\n", - " results['macro_auc'] = roc_auc_score(y_true, y_pred, average='macro')\n", - " \n", - " df_result = pd.DataFrame(results, index=[0])\n", - " return df_result\n", - "\n", - "def challenge_metrics(y_true, y_pred, beta1=2, beta2=2, class_weights=None, single=False):\n", - " f_beta = 0\n", - " g_beta = 0\n", - " if single: # if evaluating single class in case of threshold-optimization\n", - " sample_weights = np.ones(y_true.sum(axis=1).shape)\n", - " else:\n", - " sample_weights = y_true.sum(axis=1)\n", - " for classi in range(y_true.shape[1]):\n", - " y_truei, y_predi = y_true[:,classi], y_pred[:,classi]\n", - " TP, FP, TN, FN = 0.,0.,0.,0.\n", - " for i in range(len(y_predi)):\n", - " sample_weight = sample_weights[i]\n", - " if y_truei[i]==y_predi[i]==1: \n", - " TP += 1./sample_weight\n", - " if ((y_predi[i]==1) and (y_truei[i]!=y_predi[i])): \n", - " FP += 1./sample_weight\n", - " if y_truei[i]==y_predi[i]==0: \n", - " TN += 1./sample_weight\n", - " if ((y_predi[i]==0) and (y_truei[i]!=y_predi[i])): \n", - " FN += 1./sample_weight \n", - " f_beta_i = ((1+beta1**2)*TP)/((1+beta1**2)*TP + FP + (beta1**2)*FN)\n", - " g_beta_i = (TP)/(TP+FP+beta2*FN)\n", - "\n", - " f_beta += f_beta_i\n", - " g_beta += g_beta_i\n", - "\n", - " return {'F_beta_macro':f_beta/y_true.shape[1], 'G_beta_macro':g_beta/y_true.shape[1]}\n", - "\n", - "def get_appropriate_bootstrap_samples(y_true, n_bootstraping_samples):\n", - " samples=[]\n", - " while True:\n", - " ridxs = np.random.randint(0, len(y_true), len(y_true))\n", - " if y_true[ridxs].sum(axis=0).min() != 0:\n", - " samples.append(ridxs)\n", - " if len(samples) == n_bootstraping_samples:\n", - " break\n", - " return samples\n", - "\n", - "def find_optimal_cutoff_threshold(target, predicted):\n", - " \"\"\" \n", - " Find the optimal probability cutoff point for a classification model related to event rate\n", - " \"\"\"\n", - " fpr, tpr, threshold = roc_curve(target, predicted)\n", - " optimal_idx = np.argmax(tpr - fpr)\n", - " optimal_threshold = threshold[optimal_idx]\n", - " return optimal_threshold\n", - "\n", - "def find_optimal_cutoff_thresholds(y_true, y_pred):\n", - "\treturn [find_optimal_cutoff_threshold(y_true[:,i], y_pred[:,i]) for i in range(y_true.shape[1])]\n", - "\n", - "def find_optimal_cutoff_threshold_for_Gbeta(target, predicted, n_thresholds=100):\n", - " thresholds = np.linspace(0.00,1,n_thresholds)\n", - " scores = [challenge_metrics(target, predicted>t, single=True)['G_beta_macro'] for t in thresholds]\n", - " optimal_idx = np.argmax(scores)\n", - " return thresholds[optimal_idx]\n", - "\n", - "def find_optimal_cutoff_thresholds_for_Gbeta(y_true, y_pred):\n", - " print(\"optimize thresholds with respect to G_beta\")\n", - " return [find_optimal_cutoff_threshold_for_Gbeta(y_true[:,k][:,np.newaxis], y_pred[:,k][:,np.newaxis]) for k in tqdm(range(y_true.shape[1]))]\n", - "\n", - "def apply_thresholds(preds, thresholds):\n", - " \"\"\"\n", - " apply class-wise thresholds to prediction score in order to get binary format.\n", - " BUT: if no score is above threshold, pick maximum. This is needed due to metric issues.\n", - " \"\"\"\n", - " tmp = []\n", - " for p in preds:\n", - " tmp_p = (p > thresholds).astype(int)\n", - " if np.sum(tmp_p) == 0:\n", - " tmp_p[np.argmax(p)] = 1\n", - " tmp.append(tmp_p)\n", - " tmp = np.array(tmp)\n", - " return tmp\n", - "\n", - "# DATA PROCESSING STUFF\n", - "\n", - "def load_dataset(path, sampling_rate, release=False):\n", - " if path.split('/')[-2] == 'ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1':\n", - " # load and convert annotation data\n", - " Y = pd.read_csv(path+'ptbxl_database.csv', index_col='ecg_id')\n", - " Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x))\n", - "\n", - " # Load raw signal data\n", - " X = load_raw_data_ptbxl(Y, sampling_rate, path)\n", - "\n", - " elif path.split('/')[-2] == 'ICBEB':\n", - " # load and convert annotation data\n", - " Y = pd.read_csv(path+'icbeb_database.csv', index_col='ecg_id')\n", - " Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x))\n", - "\n", - " # Load raw signal data\n", - " X = load_raw_data_icbeb(Y, sampling_rate, path)\n", - "\n", - " return X, Y\n", - "\n", - "\n", - "def load_raw_data_icbeb(df, sampling_rate, path):\n", - "\n", - " if sampling_rate == 100:\n", - " if os.path.exists(path + 'raw100.npy'):\n", - " data = np.load(path+'raw100.npy', allow_pickle=True)\n", - " else:\n", - " data = [wfdb.rdsamp(path + 'records100/'+str(f)) for f in tqdm(df.index)]\n", - " data = np.array([signal for signal, meta in data])\n", - " pickle.dump(data, open(path+'raw100.npy', 'wb'), protocol=4)\n", - " elif sampling_rate == 500:\n", - " if os.path.exists(path + 'raw500.npy'):\n", - " data = np.load(path+'raw500.npy', allow_pickle=True)\n", - " else:\n", - " data = [wfdb.rdsamp(path + 'records500/'+str(f)) for f in tqdm(df.index)]\n", - " data = np.array([signal for signal, meta in data])\n", - " pickle.dump(data, open(path+'raw500.npy', 'wb'), protocol=4)\n", - " return data\n", - "\n", - "def load_raw_data_ptbxl(df, sampling_rate, path):\n", - " if sampling_rate == 100:\n", - " if os.path.exists(path + 'raw100.npy'):\n", - " data = np.load(path+'raw100.npy', allow_pickle=True)\n", - " else:\n", - " data = [wfdb.rdsamp(path+f) for f in tqdm(df.filename_lr)]\n", - " data = np.array([signal for signal, meta in data])\n", - " pickle.dump(data, open(\"./\"+'raw100.npy', 'wb'), protocol=4)\n", - " elif sampling_rate == 500:\n", - " if os.path.exists(path + 'raw500.npy'):\n", - " data = np.load(path+'raw500.npy', allow_pickle=True)\n", - " else:\n", - " data = [wfdb.rdsamp(path+f) for f in tqdm(df.filename_hr)]\n", - " data = np.array([signal for signal, meta in data])\n", - " pickle.dump(data, open(path+'raw500.npy', 'wb'), protocol=4)\n", - " return data\n", - "\n", - "def compute_label_aggregations(df, folder, ctype):\n", - "\n", - " df['scp_codes_len'] = df.scp_codes.apply(lambda x: len(x))\n", - "\n", - " aggregation_df = pd.read_csv(folder+'scp_statements.csv', index_col=0)\n", - "\n", - " if ctype in ['diagnostic', 'subdiagnostic', 'superdiagnostic']:\n", - "\n", - " def aggregate_all_diagnostic(y_dic):\n", - " tmp = []\n", - " for key in y_dic.keys():\n", - " if key in diag_agg_df.index:\n", - " tmp.append(key)\n", - " return list(set(tmp))\n", - "\n", - " def aggregate_subdiagnostic(y_dic):\n", - " tmp = []\n", - " for key in y_dic.keys():\n", - " if key in diag_agg_df.index:\n", - " c = diag_agg_df.loc[key].diagnostic_subclass\n", - " if str(c) != 'nan':\n", - " tmp.append(c)\n", - " return list(set(tmp))\n", - "\n", - " def aggregate_diagnostic(y_dic):\n", - " tmp = []\n", - " for key in y_dic.keys():\n", - " if key in diag_agg_df.index:\n", - " c = diag_agg_df.loc[key].diagnostic_class\n", - " if str(c) != 'nan':\n", - " tmp.append(c)\n", - " return list(set(tmp))\n", - "\n", - " diag_agg_df = aggregation_df[aggregation_df.diagnostic == 1.0]\n", - " if ctype == 'diagnostic':\n", - " df['diagnostic'] = df.scp_codes.apply(aggregate_all_diagnostic)\n", - " df['diagnostic_len'] = df.diagnostic.apply(lambda x: len(x))\n", - " elif ctype == 'subdiagnostic':\n", - " df['subdiagnostic'] = df.scp_codes.apply(aggregate_subdiagnostic)\n", - " df['subdiagnostic_len'] = df.subdiagnostic.apply(lambda x: len(x))\n", - " elif ctype == 'superdiagnostic':\n", - " df['superdiagnostic'] = df.scp_codes.apply(aggregate_diagnostic)\n", - " df['superdiagnostic_len'] = df.superdiagnostic.apply(lambda x: len(x))\n", - " elif ctype == 'form':\n", - " form_agg_df = aggregation_df[aggregation_df.form == 1.0]\n", - "\n", - " def aggregate_form(y_dic):\n", - " tmp = []\n", - " for key in y_dic.keys():\n", - " if key in form_agg_df.index:\n", - " c = key\n", - " if str(c) != 'nan':\n", - " tmp.append(c)\n", - " return list(set(tmp))\n", - "\n", - " df['form'] = df.scp_codes.apply(aggregate_form)\n", - " df['form_len'] = df.form.apply(lambda x: len(x))\n", - " elif ctype == 'rhythm':\n", - " rhythm_agg_df = aggregation_df[aggregation_df.rhythm == 1.0]\n", - "\n", - " def aggregate_rhythm(y_dic):\n", - " tmp = []\n", - " for key in y_dic.keys():\n", - " if key in rhythm_agg_df.index:\n", - " c = key\n", - " if str(c) != 'nan':\n", - " tmp.append(c)\n", - " return list(set(tmp))\n", - "\n", - " df['rhythm'] = df.scp_codes.apply(aggregate_rhythm)\n", - " df['rhythm_len'] = df.rhythm.apply(lambda x: len(x))\n", - " elif ctype == 'all':\n", - " df['all_scp'] = df.scp_codes.apply(lambda x: list(set(x.keys())))\n", - "\n", - " return df\n", - "\n", - "def select_data(XX,YY, ctype, min_samples, outputfolder):\n", - " # convert multilabel to multi-hot\n", - " mlb = MultiLabelBinarizer()\n", - "\n", - " if ctype == 'diagnostic':\n", - " X = XX[YY.diagnostic_len > 0]\n", - " Y = YY[YY.diagnostic_len > 0]\n", - " mlb.fit(Y.diagnostic.values)\n", - " y = mlb.transform(Y.diagnostic.values)\n", - " elif ctype == 'subdiagnostic':\n", - " counts = pd.Series(np.concatenate(YY.subdiagnostic.values)).value_counts()\n", - " counts = counts[counts > min_samples]\n", - " YY.subdiagnostic = YY.subdiagnostic.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", - " YY['subdiagnostic_len'] = YY.subdiagnostic.apply(lambda x: len(x))\n", - " X = XX[YY.subdiagnostic_len > 0]\n", - " Y = YY[YY.subdiagnostic_len > 0]\n", - " mlb.fit(Y.subdiagnostic.values)\n", - " y = mlb.transform(Y.subdiagnostic.values)\n", - " elif ctype == 'superdiagnostic':\n", - " counts = pd.Series(np.concatenate(YY.superdiagnostic.values)).value_counts()\n", - " counts = counts[counts > min_samples]\n", - " YY.superdiagnostic = YY.superdiagnostic.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", - " YY['superdiagnostic_len'] = YY.superdiagnostic.apply(lambda x: len(x))\n", - " X = XX[YY.superdiagnostic_len > 0]\n", - " Y = YY[YY.superdiagnostic_len > 0]\n", - " mlb.fit(Y.superdiagnostic.values)\n", - " y = mlb.transform(Y.superdiagnostic.values)\n", - " elif ctype == 'form':\n", - " # filter\n", - " counts = pd.Series(np.concatenate(YY.form.values)).value_counts()\n", - " counts = counts[counts > min_samples]\n", - " YY.form = YY.form.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", - " YY['form_len'] = YY.form.apply(lambda x: len(x))\n", - " # select\n", - " X = XX[YY.form_len > 0]\n", - " Y = YY[YY.form_len > 0]\n", - " mlb.fit(Y.form.values)\n", - " y = mlb.transform(Y.form.values)\n", - " elif ctype == 'rhythm':\n", - " # filter \n", - " counts = pd.Series(np.concatenate(YY.rhythm.values)).value_counts()\n", - " counts = counts[counts > min_samples]\n", - " YY.rhythm = YY.rhythm.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", - " YY['rhythm_len'] = YY.rhythm.apply(lambda x: len(x))\n", - " # select\n", - " X = XX[YY.rhythm_len > 0]\n", - " Y = YY[YY.rhythm_len > 0]\n", - " mlb.fit(Y.rhythm.values)\n", - " y = mlb.transform(Y.rhythm.values)\n", - " elif ctype == 'all':\n", - " # filter \n", - " counts = pd.Series(np.concatenate(YY.all_scp.values)).value_counts()\n", - " counts = counts[counts > min_samples]\n", - " YY.all_scp = YY.all_scp.apply(lambda x: list(set(x).intersection(set(counts.index.values))))\n", - " YY['all_scp_len'] = YY.all_scp.apply(lambda x: len(x))\n", - " # select\n", - " X = XX[YY.all_scp_len > 0]\n", - " Y = YY[YY.all_scp_len > 0]\n", - " mlb.fit(Y.all_scp.values)\n", - " y = mlb.transform(Y.all_scp.values)\n", - " else:\n", - " pass\n", - "\n", - " # save LabelBinarizer\n", - " with open(outputfolder+'mlb.pkl', 'wb') as tokenizer:\n", - " pickle.dump(mlb, tokenizer)\n", - "\n", - " return X, Y, y, mlb\n", - "\n", - "def preprocess_signals(X_train, X_validation, X_test, outputfolder):\n", - " # Standardize data such that mean 0 and variance 1\n", - " ss = StandardScaler()\n", - " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", - " \n", - " # Save Standardizer data\n", - " with open(outputfolder+'standard_scaler.pkl', 'wb') as ss_file:\n", - " pickle.dump(ss, ss_file)\n", - "\n", - " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss), apply_standardizer(X_test, ss)\n", - "\n", - "def apply_standardizer(X, ss):\n", - " X_tmp = []\n", - " for x in X:\n", - " x_shape = x.shape\n", - " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", - " X_tmp = np.array(X_tmp)\n", - " return X_tmp\n", - "\n", - "\n", - "# DOCUMENTATION STUFF\n", - "\n", - "def generate_ptbxl_summary_table(selection=None, folder='../output/'):\n", - "\n", - " exps = ['exp0', 'exp1', 'exp1.1', 'exp1.1.1', 'exp2', 'exp3']\n", - " metric1 = 'macro_auc'\n", - "\n", - " # get models\n", - " models = {}\n", - " for i, exp in enumerate(exps):\n", - " if selection is None:\n", - " exp_models = [m.split('/')[-1] for m in glob.glob(folder+str(exp)+'/models/*')]\n", - " else:\n", - " exp_models = selection\n", - " if i == 0:\n", - " models = set(exp_models)\n", - " else:\n", - " models = models.union(set(exp_models))\n", - "\n", - " results_dic = {'Method':[], \n", - " 'exp0_AUC':[], \n", - " 'exp1_AUC':[], \n", - " 'exp1.1_AUC':[], \n", - " 'exp1.1.1_AUC':[], \n", - " 'exp2_AUC':[],\n", - " 'exp3_AUC':[]\n", - " }\n", - "\n", - " for m in models:\n", - " results_dic['Method'].append(m)\n", - " \n", - " for e in exps:\n", - " \n", - " try:\n", - " me_res = pd.read_csv(folder+str(e)+'/models/'+str(m)+'/results/te_results.csv', index_col=0)\n", - " \n", - " mean1 = me_res.loc['point'][metric1]\n", - " unc1 = max(me_res.loc['upper'][metric1]-me_res.loc['point'][metric1], me_res.loc['point'][metric1]-me_res.loc['lower'][metric1])\n", - "\n", - " results_dic[e+'_AUC'].append(\"%.3f(%.2d)\" %(np.round(mean1,3), int(unc1*1000)))\n", - "\n", - " except FileNotFoundError:\n", - " results_dic[e+'_AUC'].append(\"--\")\n", - " \n", - " \n", - " df = pd.DataFrame(results_dic)\n", - " df_index = df[df.Method.isin(['naive', 'ensemble'])]\n", - " df_rest = df[~df.Method.isin(['naive', 'ensemble'])]\n", - " df = pd.concat([df_rest, df_index])\n", - " df.to_csv(folder+'results_ptbxl.csv')\n", - "\n", - " titles = [\n", - " '### 1. PTB-XL: all statements',\n", - " '### 2. PTB-XL: diagnostic statements',\n", - " '### 3. PTB-XL: Diagnostic subclasses',\n", - " '### 4. PTB-XL: Diagnostic superclasses',\n", - " '### 5. PTB-XL: Form statements',\n", - " '### 6. PTB-XL: Rhythm statements' \n", - " ]\n", - "\n", - " # helper output function for markdown tables\n", - " our_work = 'https://arxiv.org/abs/2004.13701'\n", - " our_repo = 'https://github.com/helme/ecg_ptbxl_benchmarking/'\n", - " md_source = ''\n", - " for i, e in enumerate(exps):\n", - " md_source += '\\n '+titles[i]+' \\n \\n'\n", - " md_source += '| Model | AUC ↓ | paper/source | code | \\n'\n", - " md_source += '|---:|:---|:---|:---| \\n'\n", - " for row in df_rest[['Method', e+'_AUC']].sort_values(e+'_AUC', ascending=False).values:\n", - " md_source += '| ' + row[0].replace('fastai_', '') + ' | ' + row[1] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \\n'\n", - " print(md_source)\n", - "\n", - "def ICBEBE_table(selection=None, folder='../output/'):\n", - " cols = ['macro_auc', 'F_beta_macro', 'G_beta_macro']\n", - "\n", - " if selection is None:\n", - " models = [m.split('/')[-1].split('_pretrained')[0] for m in glob.glob(folder+'exp_ICBEB/models/*')]\n", - " else:\n", - " models = [] \n", - " for s in selection:\n", - " #if s != 'Wavelet+NN':\n", - " models.append(s)\n", - "\n", - " data = []\n", - " for model in models:\n", - " me_res = pd.read_csv(folder+'exp_ICBEB/models/'+model+'/results/te_results.csv', index_col=0)\n", - " mcol=[]\n", - " for col in cols:\n", - " mean = me_res.ix['point'][col]\n", - " unc = max(me_res.ix['upper'][col]-me_res.ix['point'][col], me_res.ix['point'][col]-me_res.ix['lower'][col])\n", - " mcol.append(\"%.3f(%.2d)\" %(np.round(mean,3), int(unc*1000)))\n", - " data.append(mcol)\n", - " data = np.array(data)\n", - "\n", - " df = pd.DataFrame(data, columns=cols, index=models)\n", - " df.to_csv(folder+'results_icbeb.csv')\n", - "\n", - " df_rest = df[~df.index.isin(['naive', 'ensemble'])]\n", - " df_rest = df_rest.sort_values('macro_auc', ascending=False)\n", - " our_work = 'https://arxiv.org/abs/2004.13701'\n", - " our_repo = 'https://github.com/helme/ecg_ptbxl_benchmarking/'\n", - "\n", - " md_source = '| Model | AUC ↓ | F_beta=2 | G_beta=2 | paper/source | code | \\n'\n", - " md_source += '|---:|:---|:---|:---|:---|:---| \\n'\n", - " for i, row in enumerate(df_rest[cols].values):\n", - " md_source += '| ' + df_rest.index[i].replace('fastai_', '') + ' | ' + row[0] + ' | ' + row[1] + ' | ' + row[2] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \\n'\n", - " print(md_source)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c4167b83-41cb-4a0a-aa4e-7a8a8790c021", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "c4167b83-41cb-4a0a-aa4e-7a8a8790c021", - "outputId": "aa4c4607-2f1e-47ce-9bad-a6d7c4867162" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 21837/21837 [01:07<00:00, 323.92it/s]\n" - ] - } - ], - "source": [ - "# Load PTB-XL data\n", - "data, raw_labels = load_dataset(datafolder, sampling_frequency)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2507b016-ab63-4263-9e34-6f52346dd468", - "metadata": { - "id": "2507b016-ab63-4263-9e34-6f52346dd468" - }, - "outputs": [], - "source": [ - "labels = compute_label_aggregations(raw_labels, datafolder, task)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "84e05e6c-b826-4638-b950-d78889afa4e0", - "metadata": { - "id": "84e05e6c-b826-4638-b950-d78889afa4e0" - }, - "outputs": [], - "source": [ - "# Select relevant data and convert to one-hot\n", - "data, labels, Y, mlb = select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "95bc3349-5f35-4848-b1ad-ba57cce241c2", - "metadata": { - "id": "95bc3349-5f35-4848-b1ad-ba57cce241c2" - }, - "outputs": [], - "source": [ - "labels.reset_index(inplace=True)" - ] - }, - { - "cell_type": "markdown", - "id": "00e60322-f45b-4815-9d94-7addb100531d", - "metadata": { - "id": "00e60322-f45b-4815-9d94-7addb100531d" - }, - "source": [ - "Superclass:\n", - "* col 1 (indx 0) = CD\n", - "* col 2 = HYP\n", - "* col 3 = MI\n", - "* col 4 = NORM\n", - "* col 5 = STTC" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "58e05225-a5c1-48d0-9bfa-d412d5cbb9e9", - "metadata": { - "id": "58e05225-a5c1-48d0-9bfa-d412d5cbb9e9" - }, - "outputs": [], - "source": [ - "mi_indx = []\n", - "for i,j in enumerate(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==1)]):\n", - " mi_indx.append(i)\n", - "mi_indx = np.asarray(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==1)].index[mi_indx]) #the 3th col is the MI superclass\n", - "\n", - "mi_data = data[mi_indx]\n", - "Y_mi = Y[mi_indx]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "14463a7d-5f9a-41b7-8dfe-bc120d0789da", - "metadata": { - "id": "14463a7d-5f9a-41b7-8dfe-bc120d0789da" - }, - "outputs": [], - "source": [ - "norm_indx = []\n", - "for i,j in enumerate(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==0)]):\n", - " norm_indx.append(i)\n", - "norm_indx = np.asarray(labels[\"superdiagnostic\"].iloc[np.where(Y[:,2]==0)].index[norm_indx]) #the 4th col is the Norm superclass\n", - "\n", - "norm_data = data[norm_indx]\n", - "Y_norm = Y[norm_indx]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f6f0c951-3995-419e-aa4a-d481dfeed7a3", - "metadata": { - "id": "f6f0c951-3995-419e-aa4a-d481dfeed7a3", - "tags": [] - }, - "outputs": [], - "source": [ - "all_diag = []\n", - "for i,j in enumerate(labels.scp_codes[mi_indx]):\n", - " for k in j:\n", - " all_diag.append(k)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b36fa309-6407-48b4-8dec-8377f3a59d84", - "metadata": { - "id": "b36fa309-6407-48b4-8dec-8377f3a59d84" - }, - "outputs": [], - "source": [ - "df = pd.read_csv(datafolder + \"scp_statements.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "6d733dc3-cf06-4429-8cc1-ade1866be56b", - "metadata": { - "id": "6d733dc3-cf06-4429-8cc1-ade1866be56b" - }, - "outputs": [], - "source": [ - "full_diag_name = []\n", - "for i in np.unique(all_diag,return_counts=True)[0]:\n", - " diag_idx = np.where(df.iloc[:,0]==i)[0]\n", - " full_diag_name.append(df.iloc[diag_idx,1].ravel()[0])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8f6b6f0c-2246-4b01-8a9c-91ef2f739028", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 568 - }, - "id": "8f6b6f0c-2246-4b01-8a9c-91ef2f739028", - "outputId": "35f3e2a3-93c4-4bb0-cfd3-6768d1a1d599" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "pd.DataFrame({\"Diagnose\":full_diag_name, \"Number of patients with diagnose\":np.unique(all_diag,return_counts=True)[1]}).sort_values(by=[\"Number of patients with diagnose\"],ascending=False).iloc[:20].plot.bar(x='Diagnose', y='Number of patients with diagnose')\n", - "plt.savefig(\"MI_subdiagnoses.png\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "43b4d221-2d87-44b9-9cb5-6b177a064dbd", - "metadata": { - "id": "43b4d221-2d87-44b9-9cb5-6b177a064dbd" - }, - "outputs": [], - "source": [ - "pd.DataFrame({\"Diagnose\":full_diag_name, \"Number of patients with diagnose\":np.unique(all_diag,return_counts=True)[1]}).to_csv(\"diagnoses-MI-patients.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9ac0d7b0-ab44-4306-ae1d-e6d7c9671c48", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "9ac0d7b0-ab44-4306-ae1d-e6d7c9671c48", - "outputId": "7d37e207-8c9d-449b-be71-1443d1aa0d9e" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(20,20))\n", - "plt.bar(np.unique(all_diag,return_counts=True)[0],np.unique(all_diag,return_counts=True)[1])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3883b0d8-0d1f-4df7-aab0-3b177f728f1b", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3883b0d8-0d1f-4df7-aab0-3b177f728f1b", - "outputId": "828c8283-97a7-4612-c1a2-79b34a42810b" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(15944, 1000, 12)" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "norm_data.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "42dde4c5-103e-4d1a-a4a5-6f8a288c025d", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "42dde4c5-103e-4d1a-a4a5-6f8a288c025d", - "outputId": "bf112d20-57c3-4860-e2a6-a0c755c6ce7b" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "(5486, 1000, 12)" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "mi_data.shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4ccb2263-9522-4507-bf30-a53cb62a629c", - "metadata": { - "id": "4ccb2263-9522-4507-bf30-a53cb62a629c" - }, - "outputs": [], - "source": [ - "Y_norm = np.zeros((norm_data.shape[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c81e5f46-3c29-4869-97b6-8431c457f81c", - "metadata": { - "id": "c81e5f46-3c29-4869-97b6-8431c457f81c" - }, - "outputs": [], - "source": [ - "Y_mi = np.ones((mi_data.shape[0]))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3fcf47ba-3c66-4068-bb19-076f5edb9fff", - "metadata": { - "id": "3fcf47ba-3c66-4068-bb19-076f5edb9fff" - }, - "outputs": [], - "source": [ - "X = np.vstack((norm_data,mi_data))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "uKN4Lx0y4PYc", - "metadata": { - "id": "uKN4Lx0y4PYc" - }, - "outputs": [], - "source": [ - "#X = np.expand_dims(X[:,:,1],2)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "COAefnPG4XM9", - "metadata": { - "id": "COAefnPG4XM9" - }, - "outputs": [], - "source": [ - "#v = X[:,:,0] # foo[:, -1] for the last column\n", - "#X[:,:, 0] = (v - v.min()) / (v.max() - v.min())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f51c4ea1-5024-4e12-bacc-ae66213fa316", - "metadata": { - "id": "f51c4ea1-5024-4e12-bacc-ae66213fa316" - }, - "outputs": [], - "source": [ - "y = np.hstack((Y_norm,Y_mi))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c9dd1cf6-eb6b-4783-ba2e-6731c48637d6", - "metadata": { - "id": "c9dd1cf6-eb6b-4783-ba2e-6731c48637d6" - }, - "outputs": [], - "source": [ - "all_idx = np.hstack((norm_indx,mi_indx))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f13e051c-4edb-4dc1-a285-87a79473c045", - "metadata": { - "id": "f13e051c-4edb-4dc1-a285-87a79473c045" - }, - "outputs": [], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "X_train, X_test, y_train, y_test, idx_train, idx_test = train_test_split(X, y, all_idx, test_size=0.33, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7c37f38e-ae7b-4d5c-83f9-46dfa1cf2083", - "metadata": { - "id": "7c37f38e-ae7b-4d5c-83f9-46dfa1cf2083" - }, - "outputs": [], - "source": [ - "weight_mi = np.unique(y_train, return_counts=True)[1][0]/np.unique(y_train, return_counts=True)[1][1]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "4102c5e9-6d74-4f5a-901f-51624bdb3219", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "4102c5e9-6d74-4f5a-901f-51624bdb3219", - "outputId": "5e9a88f1-5b38-41b0-8a29-410069f02940" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "{0: 1.0, 1: 2.88474025974026}" - ] - }, - "execution_count": 80, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "class_w_dict = {0: 1.0, 1:weight_mi}\n", - "class_w_dict" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b5faf7a9-8036-41b0-9414-8c48b617e402", - "metadata": { - "id": "b5faf7a9-8036-41b0-9414-8c48b617e402" - }, - "outputs": [], - "source": [ - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=3, nb_filters=3):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False, name=\"conv1\")(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", - " strides=stride, padding='same', activation=activation, kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3), use_bias=False, name=\"conv\" + str(i+2))(\n", - " input_inception))\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False, name = \"conv5\", kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3))(max_pool_1)\n", - "\n", - " conv_list.append(conv_6)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='same', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - "\n", - " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_model(input_shape, nb_classes, depth=1, use_residual=True):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer)\n", - "\n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\"\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\"\n", - " )\n", - " ])\n", - " \n", - " return model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "sLVXZL7SgkOJ", - "metadata": { - "id": "sLVXZL7SgkOJ" - }, - "outputs": [], - "source": [ - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='valid', activation=activation, use_bias=False \n", - " #,name=\"conv1\"\n", - " )(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " #crop_size = kernel_size_s\n", - " #crop_size = np.asarray(crop_size)\n", - " #crop_size[0] = 0\n", - " #crop_size = sorted(crop_size)\n", - " crop_size = [0,10,15]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " incept_conv = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i]+1,\n", - " strides=stride, padding='valid', activation=activation, kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3), use_bias=False#, name=\"conv\" + str(i+2)\n", - " )(input_inception)\n", - " #incept_padd = tf.keras.layers.ZeroPadding1D(padding=int(kernel_size // (2 ** i)/2))(incept_conv)\n", - " incept_crop = tf.keras.layers.Cropping1D(cropping=(crop_size[i], crop_size[i]))(incept_conv)\n", - " conv_list.append(incept_crop)\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='valid')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='valid', activation=activation, use_bias=False, #name = \"conv5\", \n", - " kernel_initializer=tf.keras.initializers.RandomNormal(mean=0.5, stddev=0.3))(max_pool_1)\n", - " conv_crop = tf.keras.layers.Cropping1D(cropping=(19, 19))(conv_6)\n", - " conv_list.append(conv_crop)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='valid', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - " diff = shortcut_y.shape[1]-out_tensor.shape[1]\n", - " crop = tf.keras.layers.Cropping1D(cropping=(diff//2, diff//2))(shortcut_y)\n", - " x = tf.keras.layers.Add()([crop, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_model(input_shape, nb_classes, depth=6, use_residual=True):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer)\n", - "\n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=0.001), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\"\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\"\n", - " )\n", - " ])\n", - " \n", - " return model" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "QEO-kyIs3A2z", - "metadata": { - "id": "QEO-kyIs3A2z" - }, - "outputs": [], - "source": [ - "batchsize = 32\n", - "model = build_model((1000,1),1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2a8d7913-4ba1-483d-b5d5-f3cb7b16a433", - "metadata": { - "id": "2a8d7913-4ba1-483d-b5d5-f3cb7b16a433" - }, - "outputs": [], - "source": [ - "def scheduler(epoch, lr):\n", - " if epoch == 5:\n", - " return lr*0.1\n", - " elif epoch == 10:\n", - " return lr*0.1\n", - " elif epoch == 15:\n", - " return lr*0.1\n", - " else:\n", - " return lr" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "8782a0a1-63d1-4bae-9bfb-b06b3439ed60", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "8782a0a1-63d1-4bae-9bfb-b06b3439ed60", - "outputId": "83ac48aa-1973-48ee-bdf7-86891af79f06" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Num GPUs Available: 1\n" - ] - } - ], - "source": [ - "print(\"Num GPUs Available: \", len(tf.config.list_physical_devices('GPU')))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7de5a8ea-fc2b-4d25-822d-7cd1d3b579e0", - "metadata": { - "id": "7de5a8ea-fc2b-4d25-822d-7cd1d3b579e0" - }, - "outputs": [], - "source": [ - "class PlotLosses(tf.keras.callbacks.Callback):\n", - " def on_train_begin(self, logs={}):\n", - " self.i = 0\n", - " self.x = []\n", - " self.losses = []\n", - " self.val_losses = []\n", - "\n", - " self.fig = plt.figure()\n", - "\n", - " self.logs = []\n", - "\n", - " def on_epoch_end(self, epoch, logs={}):\n", - "\n", - " self.logs.append(logs)\n", - " self.x.append(self.i)\n", - " self.losses.append(logs.get('loss'))\n", - " self.val_losses.append(logs.get('val_loss'))\n", - " self.i += 1\n", - "\n", - " clear_output(wait=True)\n", - " plt.plot(self.x, self.losses, label=\"loss\")\n", - " plt.plot(self.x, self.val_losses, label=\"val_loss\")\n", - " plt.legend()\n", - " plt.show();\n", - " #def on_train_end(self, epoch, logs={}):\n", - " #plt.plot(self.x, self.losses, label=\"loss\")\n", - " #plt.plot(self.x, self.val_losses, label=\"val_loss\")\n", - " #plt.legend()\n", - " #plt.show();\n", - "\n", - "plot_losses = PlotLosses()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1f76d05e-fc5e-450f-b56e-ca2634d47a4a", - "metadata": { - "id": "1f76d05e-fc5e-450f-b56e-ca2634d47a4a" - }, - "outputs": [], - "source": [ - "from IPython.display import clear_output" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "RBztHZVdz0nH", - "metadata": { - "id": "RBztHZVdz0nH" - }, - "outputs": [], - "source": [ - "#tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "IjwhZio6Azxl", - "metadata": { - "id": "IjwhZio6Azxl" - }, - "outputs": [], - "source": [ - "ecg_plot = X_test[0,25:125,0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "173a2565-c5d4-41e8-a422-cedd293f2c1b", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "173a2565-c5d4-41e8-a422-cedd293f2c1b", - "outputId": "b16dc02a-ec81-4d33-b29f-7bec44e1be8c" - }, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "ignored", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"pink\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlabel\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"filter 3\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlegend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m history = model.fit(x=X_train,y=y_train, epochs=5, batch_size=batchsize,\n\u001b[1;32m 18\u001b[0m \u001b[0mvalidation_data\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msteps_per_epoch\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX_train\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mbatchsize\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m 270\u001b[0m \"\"\"\n\u001b[1;32m 271\u001b[0m \u001b[0;32mglobal\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 273\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m 41\u001b[0m display(\n\u001b[1;32m 42\u001b[0m \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 44\u001b[0m )\n\u001b[1;32m 45\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 314\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 181\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 225\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 340\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 342\u001b[0m \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m 242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 245\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 246\u001b[0m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 2124\u001b[0m \u001b[0morientation\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morientation\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2125\u001b[0m \u001b[0mbbox_inches_restore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_bbox_inches_restore\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2126\u001b[0;31m **kwargs)\n\u001b[0m\u001b[1;32m 2127\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2128\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbbox_inches\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mrestore_bbox\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mprint_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs, *args, **kwargs)\u001b[0m\n\u001b[1;32m 512\u001b[0m }\n\u001b[1;32m 513\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 514\u001b[0;31m \u001b[0mFigureCanvasAgg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 515\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mpil_kwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 516\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mPIL\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mImage\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backends/backend_agg.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 391\u001b[0m (self.toolbar._wait_cursor_for_draw_cm() if self.toolbar\n\u001b[1;32m 392\u001b[0m else nullcontext()):\n\u001b[0;32m--> 393\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 394\u001b[0m \u001b[0;31m# A GUI class may be need to update a window using this draw, so\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 395\u001b[0m \u001b[0;31m# don't forget to call the superclass.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 39\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 1734\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1735\u001b[0m mimage._draw_list_compositing_images(\n\u001b[0;32m-> 1736\u001b[0;31m renderer, self, artists, self.suppressComposite)\n\u001b[0m\u001b[1;32m 1737\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1738\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'figure'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 138\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 39\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, inframe)\u001b[0m\n\u001b[1;32m 2628\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstop_rasterizing\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2629\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2630\u001b[0;31m \u001b[0mmimage\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_draw_list_compositing_images\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2631\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2632\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'axes'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/image.py\u001b[0m in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mnot_composite\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mhas_images\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 136\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 138\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0;31m# Composite any adjacent images together\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/artist.py\u001b[0m in \u001b[0;36mdraw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 36\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstart_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 37\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 38\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0martist\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 39\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0martist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_agg_filter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mdraw\u001b[0;34m(self, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m 1225\u001b[0m \u001b[0mrenderer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m__name__\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_gid\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1226\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1227\u001b[0;31m \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1228\u001b[0m ticklabelBoxes, ticklabelBoxes2 = self._get_tick_bboxes(ticks_to_draw,\n\u001b[1;32m 1229\u001b[0m renderer)\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_update_ticks\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1101\u001b[0m \u001b[0mthe\u001b[0m \u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m \u001b[0mReturn\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mlist\u001b[0m \u001b[0mof\u001b[0m \u001b[0mticks\u001b[0m \u001b[0mthat\u001b[0m \u001b[0mwill\u001b[0m \u001b[0mbe\u001b[0m \u001b[0mdrawn\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1102\u001b[0m \"\"\"\n\u001b[0;32m-> 1103\u001b[0;31m \u001b[0mmajor_locs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_majorticklocs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1104\u001b[0m \u001b[0mmajor_labels\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1105\u001b[0m \u001b[0mmajor_ticks\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_major_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmajor_locs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_majorticklocs\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1346\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_majorticklocs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1347\u001b[0m \u001b[0;34m\"\"\"Get the array of major tick locations in data coordinates.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1348\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlocator\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1349\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1350\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_minorticklocs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/ticker.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2201\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__call__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2202\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_view_interval\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2203\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2204\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2205\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mtick_values\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/ticker.py\u001b[0m in \u001b[0;36mtick_values\u001b[0;34m(self, vmin, vmax)\u001b[0m\n\u001b[1;32m 2209\u001b[0m vmin, vmax = mtransforms.nonsingular(\n\u001b[1;32m 2210\u001b[0m vmin, vmax, expander=1e-13, tiny=1e-14)\n\u001b[0;32m-> 2211\u001b[0;31m \u001b[0mlocs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_raw_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvmin\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvmax\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2212\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2213\u001b[0m \u001b[0mprune\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_prune\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/ticker.py\u001b[0m in \u001b[0;36m_raw_ticks\u001b[0;34m(self, vmin, vmax)\u001b[0m\n\u001b[1;32m 2148\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_nbins\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'auto'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2149\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2150\u001b[0;31m nbins = np.clip(self.axis.get_tick_space(),\n\u001b[0m\u001b[1;32m 2151\u001b[0m max(1, self._min_n_ticks - 1), 9)\n\u001b[1;32m 2152\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_tick_space\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 2188\u001b[0m \u001b[0mends\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransAxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2189\u001b[0m \u001b[0mlength\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mends\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0mends\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdpi\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0;36m72\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2190\u001b[0;31m \u001b[0mtick\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2191\u001b[0m \u001b[0;31m# There is a heuristic here that the aspect ratio of tick text\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2192\u001b[0m \u001b[0;31m# is no more than 3:1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_get_tick\u001b[0;34m(self, major)\u001b[0m\n\u001b[1;32m 1941\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1942\u001b[0m \u001b[0mtick_kw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_minor_tick_kw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1943\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mXTick\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m''\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmajor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmajor\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mtick_kw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1944\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1945\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_get_label\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, axes, loc, label, size, width, color, tickdir, pad, labelsize, labelcolor, zorder, gridOn, tick1On, tick2On, label1On, label2On, major, labelrotation, grid_color, grid_linestyle, grid_linewidth, grid_alpha, **kw)\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 157\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick1line\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick1line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 158\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtick2line\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tick2line\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 159\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgridline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_gridline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 160\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlabel1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_text1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_get_tick2line\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[0mmarkersize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_size\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 478\u001b[0m \u001b[0mmarkeredgewidth\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_width\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 479\u001b[0;31m zorder=self._zorder)\n\u001b[0m\u001b[1;32m 480\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 481\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_xaxis_transform\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mwhich\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'tick2'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/lines.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, xdata, ydata, linewidth, linestyle, color, marker, markersize, markeredgewidth, markeredgecolor, markerfacecolor, markerfacecoloralt, fillstyle, antialiased, dash_capstyle, solid_capstyle, dash_joinstyle, solid_joinstyle, pickradius, drawstyle, markevery, **kwargs)\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_color\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 377\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_color\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 378\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMarkerStyle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfillstyle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 379\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 380\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_markevery\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, marker, fillstyle)\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker_function\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 224\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_fillstyle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfillstyle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 225\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_marker\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmarker\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 226\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 227\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_recache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36mset_marker\u001b[0;34m(self, marker)\u001b[0m\n\u001b[1;32m 294\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 295\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 296\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_recache\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 297\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 298\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_path\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36m_recache\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_capstyle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'butt'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_marker_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__bool__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/markers.py\u001b[0m in \u001b[0;36m_set_tickup\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 726\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 727\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_set_tickup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 728\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_transform\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mAffine2D\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1.0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 729\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_snap_threshold\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1.0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 730\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filled\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mscale\u001b[0;34m(self, sx, sy)\u001b[0m\n\u001b[1;32m 1998\u001b[0m \u001b[0msy\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1999\u001b[0m scale_mtx = np.array(\n\u001b[0;32m-> 2000\u001b[0;31m [[sx, 0.0, 0.0], [0.0, sy, 0.0], [0.0, 0.0, 1.0]], float)\n\u001b[0m\u001b[1;32m 2001\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mtx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscale_mtx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_mtx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2002\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minvalidate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "epochs=40\n", - "batchsize = 32\n", - "model = build_model((1000,1),1)\n", - "for g in range(0,epochs):\n", - " for layer_name in [\"conv2\", \"conv3\", \"conv4\"]:\n", - " for i in range(len(ecg_plot)-model.get_layer(layer_name).weights[0][:,:,:].shape[0]):\n", - " clear_output(wait=True)\n", - " fig,ax = plt.subplots(figsize=(20,2))\n", - " plt.title(layer_name + \", epoch_\" + str(g))\n", - " ax.plot(ecg_plot)\n", - " ax2=ax.twinx()\n", - " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,0], \"r\", label=\"filter 1\")\n", - " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,1], \"g\", label=\"filter 2\")\n", - " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,2], \"pink\", label=\"filter 3\")\n", - " plt.legend()\n", - " plt.show()\n", - " history = model.fit(x=X_train,y=y_train, epochs=5, batch_size=batchsize,\n", - " validation_data=(X_test,y_test),steps_per_epoch=(len(X_train)/batchsize),\n", - " class_weight=class_w_dict, \n", - " #callbacks = [plot_losses],\n", - " verbose = 1, shuffle = True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "KzoC-omnK0kn", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 376 - }, - "id": "KzoC-omnK0kn", - "outputId": "ab814309-4817-4576-9f3e-e49ae51be0fc" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\r448/448 [==============================] - 36s 79ms/step - loss: 0.8209 - binary_accuracy: 0.7257 - ROC: 0.7961 - PRC: 0.5695 - val_loss: 0.5064 - val_binary_accuracy: 0.7633 - val_ROC: 0.8106 - val_PRC: 0.5828 - lr: 0.0010\n", - "\n", - "Epoch 3: LearningRateScheduler setting learning rate to 0.0010000000474974513.\n", - "Epoch 3/20\n", - "296/448 [==================>...........] - ETA: 10s - loss: 0.7829 - binary_accuracy: 0.7488 - ROC: 0.8143 - PRC: 0.6043" - ] - } - ], - "source": [ - "batchsize = 32\n", - "model = build_model((1000,12),1)\n", - "history = model.fit(x=X_train,y=y_train, epochs=20, batch_size=batchsize,\n", - " validation_data=(X_test,y_test),steps_per_epoch=(len(X_train)/batchsize),\n", - " class_weight=class_w_dict, \n", - " callbacks = [plot_losses, tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)],\n", - " verbose = 1, shuffle = True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "XEoxcIU7KrqU", - "metadata": { - "id": "XEoxcIU7KrqU" - }, - "outputs": [], - "source": [ - "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv1d_95\").output, model.output])\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "JZv28B--LxD3", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 283 - }, - "id": "JZv28B--LxD3", - "outputId": "a918e0c5-8083-44ae-c13b-e1db1c78ae1b" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 139, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(20,4))\n", - "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "OVce6_vhM1DZ", - "metadata": { - "id": "OVce6_vhM1DZ" - }, - "outputs": [], - "source": [ - "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv3\").output, model.output])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "Q0a7PE_7M5ic", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 285 - }, - "id": "Q0a7PE_7M5ic", - "outputId": "8cd9a710-073c-437b-fa16-1a76ef9cb01f" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 210, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(20,4))\n", - "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "GR7LtK8uM6uv", - "metadata": { - "id": "GR7LtK8uM6uv" - }, - "outputs": [], - "source": [ - "new_model = tf.keras.models.Model([model.inputs], [model.get_layer(\"conv4\").output, model.output])\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "sawQr7PPM_Um", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 284 - }, - "id": "sawQr7PPM_Um", - "outputId": "466e3d22-9df2-477a-e652-a5191b84e339" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 73, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(20,4))\n", - "plt.plot(new_model(X_test[0:1,:,0:1])[0][0,:,2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "tvxhRKAF54kU", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "tvxhRKAF54kU", - "outputId": "021c15b8-31c3-43cd-d1dc-1bb2743da054" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model_2\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_14 (InputLayer) [(None, 1000, 1)] 0 [] \n", - " \n", - " max_pooling1d_12 (MaxPooling1D (None, 998, 1) 0 ['input_14[0][0]'] \n", - " ) \n", - " \n", - " conv2 (Conv1D) (None, 960, 3) 123 ['input_14[0][0]'] \n", - " \n", - " conv3 (Conv1D) (None, 980, 3) 63 ['input_14[0][0]'] \n", - " \n", - " conv4 (Conv1D) (None, 990, 3) 33 ['input_14[0][0]'] \n", - " \n", - " conv5 (Conv1D) (None, 998, 3) 3 ['max_pooling1d_12[0][0]'] \n", - " \n", - " zero_padding1d_35 (ZeroPadding (None, 1000, 3) 0 ['conv2[0][0]'] \n", - " 1D) \n", - " \n", - " zero_padding1d_36 (ZeroPadding (None, 1000, 3) 0 ['conv3[0][0]'] \n", - " 1D) \n", - " \n", - " zero_padding1d_37 (ZeroPadding (None, 1000, 3) 0 ['conv4[0][0]'] \n", - " 1D) \n", - " \n", - " zero_padding1d_38 (ZeroPadding (None, 1000, 3) 0 ['conv5[0][0]'] \n", - " 1D) \n", - " \n", - " concatenate_12 (Concatenate) (None, 1000, 12) 0 ['zero_padding1d_35[0][0]', \n", - " 'zero_padding1d_36[0][0]', \n", - " 'zero_padding1d_37[0][0]', \n", - " 'zero_padding1d_38[0][0]'] \n", - " \n", - " batch_normalization_2 (BatchNo (None, 1000, 12) 48 ['concatenate_12[0][0]'] \n", - " rmalization) \n", - " \n", - " activation_2 (Activation) (None, 1000, 12) 0 ['batch_normalization_2[0][0]'] \n", - " \n", - " global_average_pooling1d_2 (Gl (None, 12) 0 ['activation_2[0][0]'] \n", - " obalAveragePooling1D) \n", - " \n", - " dense_2 (Dense) (None, 1) 13 ['global_average_pooling1d_2[0][0\n", - " ]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 283\n", - "Trainable params: 259\n", - "Non-trainable params: 24\n", - "__________________________________________________________________________________________________\n" - ] - } - ], - "source": [ - "model.summary()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a4FNE_gF90jd", - "metadata": { - "id": "a4FNE_gF90jd" - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "SgSG4hEr79Rb", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "SgSG4hEr79Rb", - "outputId": "d9fb4718-6ef2-4232-d654-f79a7c5b3f66" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 158, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.get_layer(\"conv5\").weights[0][:,:,:].shape[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5mGSpUU8-oMx", - "metadata": { - "id": "5mGSpUU8-oMx" - }, - "outputs": [], - "source": [ - "ecg_plot = X_test[0,25:125,0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "txIQ2HBc7Cru", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "txIQ2HBc7Cru", - "outputId": "131cd2c9-4aad-4783-f621-f797d5c34058" - }, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "ignored", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtwinx\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_layer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlayer_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mweights\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mh\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"r\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m 270\u001b[0m \"\"\"\n\u001b[1;32m 271\u001b[0m \u001b[0;32mglobal\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 272\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 273\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 274\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m 41\u001b[0m display(\n\u001b[1;32m 42\u001b[0m \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 44\u001b[0m )\n\u001b[1;32m 45\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m 311\u001b[0m \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 312\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 313\u001b[0;31m \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 314\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 315\u001b[0m \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m 178\u001b[0m \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 179\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 181\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 182\u001b[0m \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 222\u001b[0m \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 223\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 225\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 226\u001b[0m \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m 339\u001b[0m \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 340\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 342\u001b[0m \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 343\u001b[0m \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m 242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 243\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 245\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 246\u001b[0m \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 127\u001b[0m \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m 2101\u001b[0m \u001b[0mbbox_artists\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"bbox_extra_artists\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2102\u001b[0m bbox_inches = self.figure.get_tightbbox(renderer,\n\u001b[0;32m-> 2103\u001b[0;31m bbox_extra_artists=bbox_artists)\n\u001b[0m\u001b[1;32m 2104\u001b[0m \u001b[0mpad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"pad_inches\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2105\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mpad\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer, bbox_extra_artists)\u001b[0m\n\u001b[1;32m 2383\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2384\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0martists\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2385\u001b[0;31m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2386\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwidth\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mheight\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2387\u001b[0m \u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer, call_axes_locator, bbox_extra_artists)\u001b[0m\n\u001b[1;32m 4321\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4322\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxison\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4323\u001b[0;31m \u001b[0mbb_xaxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxaxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4324\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mbb_xaxis\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4325\u001b[0m \u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb_xaxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 1186\u001b[0m \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1187\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1188\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_label_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1189\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1190\u001b[0m \u001b[0;31m# go back to just this axis's tick labels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36m_update_label_position\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m 2030\u001b[0m \u001b[0;31m# use axes if spine doesn't exist\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2031\u001b[0m \u001b[0mspinebbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2032\u001b[0;31m \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmtransforms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mBbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munion\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbboxes\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mspinebbox\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2033\u001b[0m \u001b[0mbottom\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0my0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2034\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36munion\u001b[0;34m(bboxes)\u001b[0m\n\u001b[1;32m 702\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvalid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 703\u001b[0m \u001b[0mx0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 704\u001b[0;31m \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 705\u001b[0m \u001b[0my0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 706\u001b[0m \u001b[0my1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 702\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0merrstate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minvalid\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'ignore'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 703\u001b[0m \u001b[0mx0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 704\u001b[0;31m \u001b[0mx1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxmax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 705\u001b[0m \u001b[0my0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymin\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 706\u001b[0m \u001b[0my1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mbbox\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mymax\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mbbox\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbboxes\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/matplotlib/transforms.py\u001b[0m in \u001b[0;36mxmax\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 357\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mxmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 358\u001b[0m \u001b[0;34m\"\"\"The right edge of the bounding box.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 359\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_points\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 360\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 361\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mamax\u001b[0;34m(*args, **kwargs)\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36mamax\u001b[0;34m(a, axis, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 2753\u001b[0m \"\"\"\n\u001b[1;32m 2754\u001b[0m return _wrapreduction(a, np.maximum, 'max', axis, None, out,\n\u001b[0;32m-> 2755\u001b[0;31m keepdims=keepdims, initial=initial, where=where)\n\u001b[0m\u001b[1;32m 2756\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2757\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/fromnumeric.py\u001b[0m in \u001b[0;36m_wrapreduction\u001b[0;34m(obj, ufunc, method, axis, dtype, out, **kwargs)\u001b[0m\n\u001b[1;32m 84\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mreduction\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 85\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 86\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mufunc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mpasskwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 87\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "for layer_name in [\"conv2\", \"conv3\", \"conv4\"]:\n", - " for h in range(3):\n", - " for i in range(len(ecg_plot)-model.get_layer(layer_name).weights[0][:,:,:].shape[0]):\n", - " clear_output(wait=True)\n", - " fig,ax = plt.subplots(figsize=(20,2))\n", - " ax.plot(ecg_plot)\n", - " ax2=ax.twinx()\n", - " ax2.plot(np.arange(model.get_layer(layer_name).weights[0][:,:,:].shape[0])+i,model.get_layer(layer_name).weights[0][:,:,h], \"r\")\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ajaT6gM78Y5I", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ajaT6gM78Y5I", - "outputId": "6096c0d5-fa0b-434b-a7aa-c8b14bbe16e1" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", - " 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", - " 34, 35, 36, 37, 38, 39])" - ] - }, - "execution_count": 144, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.arange(40)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "uveifoEV8OUU", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 260 - }, - "id": "uveifoEV8OUU", - "outputId": "08b39943-99fa-4055-d306-b92f784c62d7" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 146, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig,ax = plt.subplots(figsize=(30,4))\n", - "ax.plot(X_test[0,:,0])\n", - "ax2=ax.twinx()\n", - "ax2.plot(np.arange(40),model.get_layer(\"conv2\").weights[0][:,:,2], \"r\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a2lKpEYu1LjZ", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "a2lKpEYu1LjZ", - "outputId": "228b1416-b9f3-4eea-a557-70bc72714bf1" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "TensorShape([40, 1])" - ] - }, - "execution_count": 126, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.get_layer(\"conv2\").weights[0][:,:,0].shape" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "gl5foXzj5_EU", - "metadata": { - "id": "gl5foXzj5_EU" - }, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "qMRXBlrt5xPT", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "qMRXBlrt5xPT", - "outputId": "243bf6e3-1385-469f-cbcc-1f9288b65410" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "TensorShape([40, 1, 3])" - ] - }, - "execution_count": 130, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.get_layer(\"conv2\").weights[0]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "XgROt0J-3SgG", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 283 - }, - "id": "XgROt0J-3SgG", - "outputId": "fb48329b-e791-4039-bc71-a8e0e8ccabde" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 132, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(model.get_layer(\"conv2\").weights[0][:,:,2])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9b5e5e9c-1bd5-426c-a829-7b5d2ca2bb8a", - "metadata": { - "id": "9b5e5e9c-1bd5-426c-a829-7b5d2ca2bb8a" - }, - "outputs": [], - "source": [ - "y_hat = model.predict(X_test)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d25ddad0-d812-4fbb-a893-4da48f323a0c", - "metadata": { - "id": "d25ddad0-d812-4fbb-a893-4da48f323a0c" - }, - "outputs": [], - "source": [ - "from sklearn.metrics import roc_curve\n", - "from sklearn.metrics import roc_auc_score" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "83b111ad-5e34-484b-91b2-6aa390ead690", - "metadata": { - "id": "83b111ad-5e34-484b-91b2-6aa390ead690" - }, - "outputs": [], - "source": [ - "cm = confusion_matrix(y_test,(y_hat>0.5)*1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "40b249b1-2016-4e8a-8d46-86704394428f", - "metadata": { - "id": "40b249b1-2016-4e8a-8d46-86704394428f" - }, - "outputs": [], - "source": [ - "cmn = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "508b4903-ea75-4fff-bdf2-00b4e0a402e8", - "metadata": { - "id": "508b4903-ea75-4fff-bdf2-00b4e0a402e8" - }, - "outputs": [], - "source": [ - "df_cm = pd.DataFrame(cm)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c78bd277-df44-4542-8de2-931961c9d312", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "c78bd277-df44-4542-8de2-931961c9d312", - "outputId": "a31f9539-db25-487b-d3b5-ed11bc9f8e7b" - }, - "outputs": [ - { - "data": { - "text/plain": [ - "0.9135903743926352" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "roc_auc_score(y_test,y_hat)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eead1308-33f7-4bff-9126-11594c7a4e7b", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 295 - }, - "id": "eead1308-33f7-4bff-9126-11594c7a4e7b", - "outputId": "8e6e30a6-c4c7-47ea-a282-facb0913dd8f" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "roc_score = roc_auc_score(y_test,y_hat)\n", - "fpr, tpr, thresholds = roc_curve(y_test,y_hat)\n", - "plt.title(\"MI/Normal ROC={}\".format(round(roc_score,2)))\n", - "plt.plot(fpr,tpr)\n", - "plt.ylabel('True Positive Rate')\n", - "plt.xlabel('False Positive Rate')\n", - "plt.savefig(\"ROC_mi_vs_all.png\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "19c3f7a0-19f0-4f65-babb-f30ec45c298b", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 497 - }, - "id": "19c3f7a0-19f0-4f65-babb-f30ec45c298b", - "outputId": "5f591ad6-7658-47fd-8578-cb65e6a04c6b" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(8,8))\n", - "sns.heatmap(df_cm, annot=True, cmap=\"Blues\",fmt='.0f',xticklabels=[\"Normal\",\"MI\"], yticklabels=[\"Normal\",\"MI\"])\n", - "plt.ylabel('Actual')\n", - "plt.xlabel('Predicted')\n", - "plt.savefig(\"conf_matrix_mi_vs_all.png\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "bb1bf812-2daf-4033-825f-81b002f14ca0", - "metadata": { - "id": "bb1bf812-2daf-4033-825f-81b002f14ca0" - }, - "outputs": [], - "source": [ - "y_predicted_bin = ((y_hat>0.5)*1).ravel()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "70284675-f2f5-4b99-a371-c823e21e5dbc", - "metadata": { - "id": "70284675-f2f5-4b99-a371-c823e21e5dbc" - }, - "outputs": [], - "source": [ - "tp = []\n", - "fp = []\n", - "tn = []\n", - "fn = []\n", - "for i, j in enumerate(zip(y_predicted_bin, y_test.astype(int))):\n", - " true = j[1]\n", - " predicted = j[0]\n", - " if (predicted == 1) and (true == 1):\n", - " tp.append(i)\n", - " elif (predicted == 0) and (true == 0):\n", - " tn.append(i)\n", - " elif (predicted == 1) and (true == 0):\n", - " fp.append(i)\n", - " elif (predicted == 0) and (true == 1):\n", - " fn.append(i)\n", - " else:\n", - " print(\"something went wrong\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f9aebfd8-30f6-41cd-a589-7a2e47c7c5fd", - "metadata": { - "id": "f9aebfd8-30f6-41cd-a589-7a2e47c7c5fd" - }, - "outputs": [], - "source": [ - "tp_diag = np.zeros(len(df.iloc[:,0]))\n", - "\n", - "for j in idx_test[tp]:\n", - " for k in labels.scp_codes[j]:\n", - " for l , m in enumerate(df.iloc[:,0]):\n", - " if k == m:\n", - " tp_diag[l] += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "56adb106-aaa6-402c-9d6b-5a9e3a876688", - "metadata": { - "id": "56adb106-aaa6-402c-9d6b-5a9e3a876688" - }, - "outputs": [], - "source": [ - "tn_diag = np.zeros(len(df.iloc[:,0]))\n", - "\n", - "for j in idx_test[tn]:\n", - " for k in labels.scp_codes[j]:\n", - " for l , m in enumerate(df.iloc[:,0]):\n", - " if k == m:\n", - " tn_diag[l] += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eb776b46-3bad-4bb5-a9d9-cbbfd461f57e", - "metadata": { - "id": "eb776b46-3bad-4bb5-a9d9-cbbfd461f57e" - }, - "outputs": [], - "source": [ - "fn_diag = np.zeros(len(df.iloc[:,0]))\n", - "\n", - "for j in idx_test[fn]:\n", - " for k in labels.scp_codes[j]:\n", - " for l , m in enumerate(df.iloc[:,0]):\n", - " if k == m:\n", - " fn_diag[l] += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "76a591da-405b-48bc-ba66-27a352a0f60a", - "metadata": { - "id": "76a591da-405b-48bc-ba66-27a352a0f60a" - }, - "outputs": [], - "source": [ - "fp_diag = np.zeros(len(df.iloc[:,0]))\n", - "\n", - "for j in idx_test[fp]:\n", - " for k in labels.scp_codes[j]:\n", - " for l , m in enumerate(df.iloc[:,0]):\n", - " if k == m:\n", - " fp_diag[l] += 1" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "433b2055-b988-419a-9754-85371eddbb8d", - "metadata": { - "id": "433b2055-b988-419a-9754-85371eddbb8d" - }, - "outputs": [], - "source": [ - "results = pd.DataFrame({\"Diagnose\":df.description, \"tp\":tp_diag.astype(int), \"tn\":tn_diag.astype(int), \"fp\":fp_diag.astype(int), \"fn\":fn_diag.astype(int)})" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a49bce11-2d7d-4f80-a87b-b0e479c4af00", - "metadata": { - "id": "a49bce11-2d7d-4f80-a87b-b0e479c4af00" - }, - "outputs": [], - "source": [ - "results[\"Sensitivity\"] = results[\"tp\"]/(results[\"tp\"]+results[\"fn\"])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "39766202-4eb1-4337-aa7b-531ecba7b43f", - "metadata": { - "id": "39766202-4eb1-4337-aa7b-531ecba7b43f" - }, - "outputs": [], - "source": [ - "results[\"Specifisity\"] = results[\"tn\"]/(results[\"tn\"]+results[\"fp\"])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eb47a59a-3e64-4756-a5d7-aef5339c18e2", - "metadata": { - "id": "eb47a59a-3e64-4756-a5d7-aef5339c18e2" - }, - "outputs": [], - "source": [ - "results[\"Precision (PPV)\"] = results[\"tp\"]/(results[\"tp\"]+results[\"fp\"])" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0af17f88-9d3f-4e05-b3e1-aea3ddb1356c", - "metadata": { - "id": "0af17f88-9d3f-4e05-b3e1-aea3ddb1356c" - }, - "outputs": [], - "source": [ - "results.to_csv(\"subdiag.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "SlX6WKtojmgk", - "metadata": { - "id": "SlX6WKtojmgk" - }, - "outputs": [], - "source": [ - "infarction_list = [\"inferior myocardial infarction\",\"anteroseptal myocardial infarction\", \"anterior myocardial infarction\",\n", - " \"lateral myocardial infarction\",\"anterolateral myocardial infarction\",\"inferolateral myocardial infarction\",\n", - " \"inferoposterolateral myocardial infarction\",\"posterior myocardial infarction\"]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "WlOqoR3Ti4GA", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "WlOqoR3Ti4GA", - "outputId": "bf49ed94-04d4-43f7-cbdf-4a9c8d5738dc" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Diagnose inferior myocardial infarction\n", - "tp 614\n", - "tn 0\n", - "fp 0\n", - "fn 262\n", - "Sensitivity 0.700913\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 5, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose anteroseptal myocardial infarction\n", - "tp 605\n", - "tn 0\n", - "fp 0\n", - "fn 170\n", - "Sensitivity 0.780645\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 6, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose anterior myocardial infarction\n", - "tp 56\n", - "tn 0\n", - "fp 0\n", - "fn 63\n", - "Sensitivity 0.470588\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 18, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose lateral myocardial infarction\n", - "tp 31\n", - "tn 0\n", - "fp 0\n", - "fn 36\n", - "Sensitivity 0.462687\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 22, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose anterolateral myocardial infarction\n", - "tp 73\n", - "tn 0\n", - "fp 0\n", - "fn 24\n", - "Sensitivity 0.752577\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 19, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose inferolateral myocardial infarction\n", - "tp 124\n", - "tn 0\n", - "fp 0\n", - "fn 20\n", - "Sensitivity 0.861111\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 16, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose inferoposterolateral myocardial infarction\n", - "tp 8\n", - "tn 0\n", - "fp 0\n", - "fn 7\n", - "Sensitivity 0.533333\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 34, dtype: object\n", - "-----------------------\n", - "-----------------------\n", - "Diagnose posterior myocardial infarction\n", - "tp 2\n", - "tn 0\n", - "fp 0\n", - "fn 2\n", - "Sensitivity 0.5\n", - "Specifisity NaN\n", - "Precision (PPV) 1.0\n", - "Name: 40, dtype: object\n", - "-----------------------\n", - "-----------------------\n" - ] - } - ], - "source": [ - "for mi_type in infarction_list:\n", - " print(results.iloc[np.where(results[\"Diagnose\"]==mi_type)[0][0]])\n", - " print(\"-----------------------\")\n", - " print(\"-----------------------\")" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "machine_shape": "hm", - "name": "MI_detection_PTB-XL.ipynb", - "provenance": [] - }, - "environment": { - "kernel": "python3", - "name": "tf2-gpu.2-8.m93", - "type": "gcloud", - "uri": "gcr.io/deeplearning-platform-release/tf2-gpu.2-8:m93" - }, - "gpuClass": "standard", - "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.7.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 401c39d01931bff45d949a6af90525f7a0c98a50 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:16:21 +0200 Subject: [PATCH 41/51] Delete My_Finetuning170223.ipynb --- My_Finetuning170223.ipynb | 869 -------------------------------------- 1 file changed, 869 deletions(-) delete mode 100644 My_Finetuning170223.ipynb diff --git a/My_Finetuning170223.ipynb b/My_Finetuning170223.ipynb deleted file mode 100644 index 8127864..0000000 --- a/My_Finetuning170223.ipynb +++ /dev/null @@ -1,869 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "IG6fwukq5oSe" - }, - "source": [ - "# Load your data\n", - "\n", - "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", - "\n", - "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", - "\n", - "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", - "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0L-abXib6HkK", - "outputId": "809c59a7-9ff2-430f-f627-b6e94dc0f4ef" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting wget\n", - " Downloading wget-3.2.zip (10 kB)\n", - " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "Collecting wfdb\n", - " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting tensorflow-addons\n", - " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m28.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", - "Collecting SoundFile<0.12.0,>=0.10.0\n", - " Downloading soundfile-0.11.0-py2.py3-none-any.whl (23 kB)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", - "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", - "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Building wheels for collected packages: wget\n", - " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=0c010b4ac873a3810927fbc4110402b55c605341cc2410eee2934b2cb04d2b35\n", - " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", - "Successfully built wget\n", - "Installing collected packages: wget, tensorflow-addons, SoundFile, wfdb\n", - " Attempting uninstall: SoundFile\n", - " Found existing installation: soundfile 0.12.1\n", - " Uninstalling soundfile-0.12.1:\n", - " Successfully uninstalled soundfile-0.12.1\n", - "Successfully installed SoundFile-0.11.0 tensorflow-addons-0.19.0 wfdb-4.1.0 wget-3.2\n" - ] - } - ], - "source": [ - "!pip install wget wfdb tensorflow-addons" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Y4NQeLDBZUlm", - "outputId": "8cd2652c-134d-48b7-8f83-c0902d5e09f9" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mounted at /content/drive\n" - ] - } - ], - "source": [ - "from google.colab import drive\n", - "drive.mount(\"/content/drive\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "Jqxss_rS6Jxn" - }, - "outputs": [], - "source": [ - "import wget\n", - "import numpy as np\n", - "import os\n", - "import zipfile\n", - "import tensorflow as tf\n", - "from sklearn.utils.class_weight import compute_class_weight\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "from sklearn.metrics import confusion_matrix\n", - "import pickle\n", - "import tensorflow_addons as tfa\n", - "from sklearn.metrics import roc_auc_score\n", - "from sklearn.model_selection import StratifiedKFold" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AcjcSuO06o-6", - "outputId": "7d3e9e1a-af41-4cc5-dc8c-70be7d269596" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--2023-02-19 17:49:54-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "Resolving physionet.org (physionet.org)... 18.18.42.54\n", - "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 1842722380 (1.7G) [application/zip]\n", - "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", - "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 3.08MB/s in 11m 41s \n", - "\n", - "2023-02-19 18:01:35 (2.51 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", - "\n" - ] - } - ], - "source": [ - "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "\n", - "os.mkdir(\"./data/\")\n", - "\n", - "\n", - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3Qv9hVm-5wyi", - "outputId": "159e0c4e-f603-4946-8a5c-18183c5ec5bf" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting GitPython\n", - " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m6.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Installing collected packages: smmap, gitdb, GitPython\n", - "Successfully installed GitPython-3.1.31 gitdb-4.0.10 smmap-5.0.0\n" - ] - } - ], - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "u4T-c5KI5y2W" - }, - "outputs": [], - "source": [ - "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", - "DEST_NAME = 'github_repo'" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "r8hm-j6751kC", - "outputId": "72d7691d-d731-4b81-de52-cbf96716b853" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 7 - } - ], - "source": [ - "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "SRUZICm6562J" - }, - "outputs": [], - "source": [ - "from github_repo.code import *\n", - "%matplotlib inline\n", - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CmW7xaR_5oSf", - "outputId": "5ed7d833-2bfd-4671-a5b7-6fc816a9bed9" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 21837/21837 [01:05<00:00, 334.86it/s]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "((19634, 1000, 12), (19634, 71), (2203, 1000, 12), (2203, 71))" - ] - }, - "metadata": {}, - "execution_count": 9 - } - ], - "source": [ - "from github_repo.code.utils import utils\n", - "\n", - "sampling_frequency=100\n", - "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task= 'YOUR_EXPERIMENT_NAME' # 'all' , 'diagnostic' , 'subdiagnostic', 'superdiagnostic', 'form', 'rhythm'\n", - "outputfolder='./github_repo/output/'\n", - "\n", - "# Load PTB-XL data\n", - "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", - "# Preprocess label data\n", - "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", - "# Select relevant data and convert to one-hot\n", - "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "# 1-9 for training \n", - "X_train = data[labels.strat_fold < 10]\n", - "y_train = Y[labels.strat_fold < 10]\n", - "# 10 for validation\n", - "X_val = data[labels.strat_fold == 10]\n", - "y_val = Y[labels.strat_fold == 10]\n", - "\n", - "num_classes = y_train.shape[1] # <=== number of classes in the finetuning dataset\n", - "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", - "\n", - "X_train.shape, y_train.shape, X_val.shape, y_val.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - }, - "id": "DIKpffEJMllK", - "outputId": "5767901f-bc87-4953-9a94-ad55abe64dcd" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "-a6LeAwqOm_i" - }, - "outputs": [], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "\n", - "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "QW5xSWezMWo-", - "outputId": "6d4f9c1a-e082-4d91-cee2-c8929948a050" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(1964, 1000, 12)" - ] - }, - "metadata": {}, - "execution_count": 12 - } - ], - "source": [ - "X_grid.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - }, - "id": "fDz352LpQNds", - "outputId": "0aef9990-146b-4d91-c940-8fe5685c3a51" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1UyIF9kv5oSg" - }, - "source": [ - "# Train or download models\n", - "There are two possibilities:\n", - " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", - " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", - "\n", - "# Load pretrained model\n", - "\n", - "For loading a pretrained model:\n", - " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", - " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", - " \n", - "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "id": "kg7-fD1ocLBB" - }, - "outputs": [], - "source": [ - "from github_repo.code.models.base_model import ClassificationModel\n", - "import tensorflow as tf\n", - "import numpy as np\n", - "import tensorflow_addons as tfa\n", - "\n", - " \n", - "class inception_time_model(ClassificationModel):\n", - " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", - " super(inception_time_model, self).__init__()\n", - " self.name = name\n", - " self.n_classes = n_classes\n", - " self.sampling_frequency = sampling_frequency\n", - " self.outputfolder = outputfolder\n", - " self.input_shape = input_shape\n", - " if loss == \"bce\":\n", - " self.loss = tf.keras.losses.BinaryCrossentropy()\n", - " elif loss == \"wbce\":\n", - " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", - " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", - " self.epoch = epoch\n", - " self.batch_size = batch_size\n", - " self.lr_red = lr_red\n", - " self.verbose = verbose\n", - "\n", - " \n", - " \n", - "\n", - " def fit(self, X_train, y_train, X_val, y_val):\n", - "\n", - " if self.lr_red == \"no\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose)\n", - " elif self.lr_red == \"yes\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose,\n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", - " else:\n", - " print(\"Error: wrong lr_red argument\")\n", - "\n", - " \n", - " def fit_tf(self, traindata, valdata):\n", - "\n", - " if self.lr_red == \"no\":\n", - " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=valdata, verbose=self.verbose)\n", - " elif self.lr_red == \"yes\":\n", - " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=valdata, verbose=self.verbose,\n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", - " else:\n", - " print(\"Error: wrong lr_red argument\")\n", - "\n", - " #self.model.save(self.outputfolder +'last_model.h5')\n", - " def predict(self, X):\n", - " return self.model.predict(X)\n", - "\n", - "\n", - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", - " strides=stride, padding='same', activation=activation, use_bias=False)(\n", - " input_inception))\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", - "\n", - " conv_list.append(conv_6)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='same', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - "\n", - " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=loss,\n", - " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\",\n", - " multi_label=True,\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\",\n", - " multi_label=True,\n", - " )\n", - " ])\n", - " print(\"Inception model built.\")\n", - " return model\n", - "\n", - "def scheduler(epoch, lr):\n", - " if epoch % 5 == 0:\n", - " return lr*0.1\n", - " else:\n", - " return lr\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cEx-BdLJ5oSh", - "outputId": "ccfa4460-1fb9-4be8-96e6-eefe3ac15a75" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n" - ] - } - ], - "source": [ - "#from github_repo.code.models.your_model import inception_time_model\n", - "\n", - "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", - "\n", - "experiment = 'exp0'\n", - "modelname = 'fastai_xresnet1d101'\n", - "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", - "mpath='../output/' # <=== path where the finetuned model will be stored\n", - "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", - "\n", - "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", - "\n", - "#model = fastai_model(\n", - "# modelname, \n", - "# num_classes, \n", - "# sampling_frequency, \n", - "# mpath, \n", - "# input_shape=input_shape, \n", - "# pretrainedfolder=pretrainedfolder,\n", - "# n_classes_pretrained=n_classes_pretrained, \n", - "# pretrained=True,\n", - "# epochs_finetuning=2,\n", - "#)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "V6dtMWU15oSh" - }, - "source": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# Preprocess data with pretrained Standardizer\n", - "\n", - "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "id": "uqSSsK_V5oSh" - }, - "outputs": [], - "source": [ - "import pickle\n", - "from github_repo.code.utils import utils\n", - "\n", - "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", - "\n", - "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", - "#X_val = utils.apply_standardizer(X_val, standard_scaler)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "id": "lOSQURgFUycV" - }, - "outputs": [], - "source": [ - "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", - "\n", - "def apply_standardizer(X, ss):\n", - " X_tmp = []\n", - " for x in X:\n", - " x_shape = x.shape\n", - " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", - " X_tmp = np.array(X_tmp)\n", - " return X_tmp\n", - "\n", - "def preprocess_signals(X_train, X_validation):\n", - " # Standardize data such that mean 0 and variance 1\n", - " ss = StandardScaler()\n", - " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", - " \n", - " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vfdlaRZr5oSh" - }, - "source": [ - "# Finetune model\n", - "\n", - "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "PlLyg3zHQVFh", - "outputId": "e2644fda-d890-4c9b-f5de-7c547608a0f1" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "All devices: [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]\n" - ] - } - ], - "source": [ - "resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n", - "tf.config.experimental_connect_to_cluster(resolver)\n", - "# This is the TPU initialization code that has to be at the beginning.\n", - "tf.tpu.experimental.initialize_tpu_system(resolver)\n", - "print(\"All devices: \", tf.config.list_logical_devices('TPU'))\n", - "strategy = tf.distribute.TPUStrategy(resolver)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "background_save": true, - "base_uri": "https://localhost:8080/" - }, - "id": "MxzCOgaP5oSi", - "outputId": "bd27baac-c15c-47eb-b590-07aa31a3777d" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Running gridsearch nr 436 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - } - ], - "source": [ - "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", - "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", - "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_YOUR_EXPERIMENT_NAME.csv\")\n", - "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", - "init_rows = df_score.shape[0]\n", - "\n", - "for gsr in range(gs_left):\n", - " gsr = gsr + init_rows #if previous gridsearch results exists\n", - " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", - " auc_score = []\n", - " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", - " with strategy.scope():\n", - " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", - " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", - " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", - " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", - " cv_x_train = X_grid[train_index]\n", - " cv_y_train = y_grid[train_index] \n", - " cv_x_test = X_grid[test_index]\n", - " cv_y_test = y_grid[test_index]\n", - " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", - " \n", - " tf_dataset_train = tf.data.Dataset.from_tensor_slices((cv_x_train, cv_y_train)) #tf.data.Dataset.from_tensor_slices((X_train, y_train))\n", - " tf_dataset_train = tf_dataset_train.cache()\n", - " tf_dataset_train = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", - " tf_dataset_train = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", - "\n", - " tf_dataset_val = tf.data.Dataset.from_tensor_slices((cv_x_test, cv_y_test))\n", - " tf_dataset_val = tf_dataset_train.cache()\n", - " tf_dataset_val = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", - " tf_dataset_val = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", - "\n", - " model.fit_tf(tf_dataset_train, tf_dataset_val)\n", - " y_hat_test = model.predict(cv_x_test)\n", - " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", - " auc_score.append(score)\n", - " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", - " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", - " df_score=df_score.append(df_grid.loc[gsr])\n", - " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_YOUR_EXPERIMENT_NAME.csv\", index=False) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "background_save": true - }, - "id": "SPSC9F4wPf9J" - }, - "outputs": [], - "source": [ - "utils.utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kvnNlyCX5oSi" - }, - "source": [ - "# Evaluate model on validation data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "background_save": true - }, - "id": "m1rgPocD5oSi" - }, - "outputs": [], - "source": [ - "y_val_pred = model.predict(X_val)\n", - "utils.evaluate_experiment(y_val, y_val_pred)" - ] - } - ], - "metadata": { - "accelerator": "TPU", - "colab": { - "machine_shape": "hm", - "provenance": [] - }, - "gpuClass": "standard", - "kernelspec": { - "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", - "language": "python", - "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" - }, - "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.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file From 99c98c8e080800333bbbee38807b000b6eeaf5ed Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:16:32 +0200 Subject: [PATCH 42/51] Delete My_Finetuning2.ipynb --- My_Finetuning2.ipynb | 738 ------------------------------------------- 1 file changed, 738 deletions(-) delete mode 100644 My_Finetuning2.ipynb diff --git a/My_Finetuning2.ipynb b/My_Finetuning2.ipynb deleted file mode 100644 index cba3cee..0000000 --- a/My_Finetuning2.ipynb +++ /dev/null @@ -1,738 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "IG6fwukq5oSe" - }, - "source": [ - "# Load your data\n", - "\n", - "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", - "\n", - "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", - "\n", - "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", - "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0L-abXib6HkK", - "outputId": "472d330c-0510-416a-cfe0-a545e80d38c5" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting wget\n", - " Downloading wget-3.2.zip (10 kB)\n", - " Preparing metadata (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - "Collecting wfdb\n", - " Downloading wfdb-4.1.0-py3-none-any.whl (159 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m159.9/159.9 KB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting tensorflow-addons\n", - " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m29.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", - "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", - "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Building wheels for collected packages: wget\n", - " Building wheel for wget (setup.py) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for wget: filename=wget-3.2-py3-none-any.whl size=9674 sha256=09ec8b04d514d3cf890037f4569ee419b94f145c81bb1a85b7cffa31ae0205b6\n", - " Stored in directory: /root/.cache/pip/wheels/bd/a8/c3/3cf2c14a1837a4e04bd98631724e81f33f462d86a1d895fae0\n", - "Successfully built wget\n", - "Installing collected packages: wget, tensorflow-addons, wfdb\n", - "Successfully installed tensorflow-addons-0.19.0 wfdb-4.1.0 wget-3.2\n" - ] - } - ], - "source": [ - "!pip install wget wfdb tensorflow-addons" - ] - }, - { - "cell_type": "code", - "source": [ - "from google.colab import drive\n", - "drive.mount(\"/content/drive\")" - ], - "metadata": { - "id": "Y4NQeLDBZUlm", - "outputId": "597b0155-5c98-4d66-d50c-fb8f8ed81794", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": 2, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mounted at /content/drive\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "Jqxss_rS6Jxn" - }, - "outputs": [], - "source": [ - "import wget\n", - "import numpy as np\n", - "import os\n", - "import zipfile\n", - "import tensorflow as tf\n", - "from sklearn.utils.class_weight import compute_class_weight\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "from sklearn.metrics import confusion_matrix\n", - "import pickle\n", - "import tensorflow_addons as tfa\n", - "from sklearn.metrics import roc_auc_score\n", - "from sklearn.model_selection import StratifiedKFold" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AcjcSuO06o-6", - "outputId": "f35858d8-1bb1-4e24-d948-e301f0d56732" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--2023-02-09 18:21:51-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "Resolving physionet.org (physionet.org)... 18.18.42.54\n", - "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 1842722380 (1.7G) [application/zip]\n", - "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", - "\n", - "b-xl-a-large-public 28%[====> ] 495.66M 2.07MB/s eta 12m 40s" - ] - } - ], - "source": [ - "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "\n", - "os.mkdir(\"./data/\")\n", - "\n", - "\n", - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "3Qv9hVm-5wyi" - }, - "outputs": [], - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "u4T-c5KI5y2W" - }, - "outputs": [], - "source": [ - "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", - "DEST_NAME = 'github_repo'" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "r8hm-j6751kC" - }, - "outputs": [], - "source": [ - "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "SRUZICm6562J" - }, - "outputs": [], - "source": [ - "from github_repo.code import *\n", - "%matplotlib inline\n", - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "CmW7xaR_5oSf" - }, - "outputs": [], - "source": [ - "from github_repo.code.utils import utils\n", - "\n", - "sampling_frequency=100\n", - "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task='all'\n", - "outputfolder='./github_repo/output/'\n", - "\n", - "\n", - "# Load PTB-XL data\n", - "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", - "# Preprocess label data\n", - "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", - "# Select relevant data and convert to one-hot\n", - "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "# 1-9 for training \n", - "X_train = data[labels.strat_fold < 10]\n", - "y_train = Y[labels.strat_fold < 10]\n", - "# 10 for validation\n", - "X_val = data[labels.strat_fold == 10]\n", - "y_val = Y[labels.strat_fold == 10]\n", - "\n", - "num_classes = 71 # <=== number of classes in the finetuning dataset\n", - "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", - "\n", - "X_train.shape, y_train.shape, X_val.shape, y_val.shape" - ] - }, - { - "cell_type": "code", - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ], - "metadata": { - "id": "DIKpffEJMllK" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "from sklearn.model_selection import train_test_split\n", - "\n", - "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" - ], - "metadata": { - "id": "-a6LeAwqOm_i" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "X_grid.shape" - ], - "metadata": { - "id": "QW5xSWezMWo-" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ], - "metadata": { - "id": "fDz352LpQNds" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1UyIF9kv5oSg" - }, - "source": [ - "# Train or download models\n", - "There are two possibilities:\n", - " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", - " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", - "\n", - "# Load pretrained model\n", - "\n", - "For loading a pretrained model:\n", - " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", - " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", - " \n", - "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." - ] - }, - { - "cell_type": "code", - "source": [ - "from github_repo.code.models.base_model import ClassificationModel\n", - "import tensorflow as tf\n", - "import numpy as np\n", - "import tensorflow_addons as tfa\n", - "\n", - " \n", - "class inception_time_model(ClassificationModel):\n", - " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", - " super(inception_time_model, self).__init__()\n", - " self.name = name\n", - " self.n_classes = n_classes\n", - " self.sampling_frequency = sampling_frequency\n", - " self.outputfolder = outputfolder\n", - " self.input_shape = input_shape\n", - " if loss == \"bce\":\n", - " self.loss = tf.keras.losses.BinaryCrossentropy()\n", - " elif loss == \"wbce\":\n", - " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", - " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", - " self.epoch = epoch\n", - " self.batch_size = batch_size\n", - " self.lr_red = lr_red\n", - " self.verbose = verbose\n", - "\n", - " \n", - " \n", - "\n", - " def fit(self, X_train, y_train, X_val, y_val):\n", - "\n", - " if self.lr_red == \"no\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose)\n", - " elif self.lr_red == \"yes\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose,\n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", - " else:\n", - " print(\"Error: wrong lr_red argument\")\n", - "\n", - " #self.model.save(self.outputfolder +'last_model.h5')\n", - " def predict(self, X):\n", - " return self.model.predict(X)\n", - "\n", - "\n", - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", - " strides=stride, padding='same', activation=activation, use_bias=False)(\n", - " input_inception))\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", - "\n", - " conv_list.append(conv_6)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='same', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - "\n", - " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=loss,\n", - " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\",\n", - " multi_label=True,\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\",\n", - " multi_label=True,\n", - " )\n", - " ])\n", - " print(\"Inception model built.\")\n", - " return model\n", - "\n", - "def scheduler(epoch, lr):\n", - " if epoch % 5 == 0:\n", - " return lr*0.1\n", - " else:\n", - " return lr\n" - ], - "metadata": { - "id": "kg7-fD1ocLBB" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "cEx-BdLJ5oSh" - }, - "outputs": [], - "source": [ - "#from github_repo.code.models.your_model import inception_time_model\n", - "\n", - "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", - "\n", - "experiment = 'exp0'\n", - "modelname = 'fastai_xresnet1d101'\n", - "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", - "mpath='../output/' # <=== path where the finetuned model will be stored\n", - "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", - "\n", - "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", - "\n", - "#model = fastai_model(\n", - "# modelname, \n", - "# num_classes, \n", - "# sampling_frequency, \n", - "# mpath, \n", - "# input_shape=input_shape, \n", - "# pretrainedfolder=pretrainedfolder,\n", - "# n_classes_pretrained=n_classes_pretrained, \n", - "# pretrained=True,\n", - "# epochs_finetuning=2,\n", - "#)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "V6dtMWU15oSh" - }, - "source": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# Preprocess data with pretrained Standardizer\n", - "\n", - "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "uqSSsK_V5oSh" - }, - "outputs": [], - "source": [ - "import pickle\n", - "from github_repo.code.utils import utils\n", - "\n", - "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", - "\n", - "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", - "#X_val = utils.apply_standardizer(X_val, standard_scaler)" - ] - }, - { - "cell_type": "code", - "source": [ - "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", - "\n", - "def apply_standardizer(X, ss):\n", - " X_tmp = []\n", - " for x in X:\n", - " x_shape = x.shape\n", - " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", - " X_tmp = np.array(X_tmp)\n", - " return X_tmp\n", - "\n", - "def preprocess_signals(X_train, X_validation):\n", - " # Standardize data such that mean 0 and variance 1\n", - " ss = StandardScaler()\n", - " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", - " \n", - " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" - ], - "metadata": { - "id": "lOSQURgFUycV" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vfdlaRZr5oSh" - }, - "source": [ - "# Finetune model\n", - "\n", - "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "MxzCOgaP5oSi", - "outputId": "4ec349e4-6aee-4c73-9bc4-bb307d5c3e74" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Running gridsearch nr 0 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 17ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.781634 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 17ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.786307 (AUROC score)\n", - "Inception model built.\n" - ] - } - ], - "source": [ - "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", - "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", - "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\")\n", - "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", - "init_rows = df_score.shape[0]\n", - "\n", - "for gsr in range(gs_left):\n", - " gsr = gsr + init_rows #if previous gridsearch results exists\n", - " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", - " auc_score = []\n", - " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", - " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", - " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", - " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", - " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", - " cv_x_train = X_grid[train_index]\n", - " cv_y_train = y_grid[train_index] \n", - " cv_x_test = X_grid[test_index]\n", - " cv_y_test = y_grid[test_index]\n", - " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", - "\n", - " model.fit(cv_x_train, cv_y_train, cv_x_test, cv_y_test)\n", - " y_hat_test = model.predict(cv_x_test)\n", - " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", - " auc_score.append(score)\n", - " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", - " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", - " df_score=df_score.append(df_grid.loc[gsr])\n", - " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_all.csv\", index=False) " - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kvnNlyCX5oSi" - }, - "source": [ - "# Evaluate model on validation data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "m1rgPocD5oSi", - "outputId": "6d91d6ab-7d00-4433-cdbd-2d7fd083cdaa" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "aggregating predictions...\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
macro_aucFmax
00.9314580.827961
\n", - "
" - ], - "text/plain": [ - " macro_auc Fmax\n", - "0 0.931458 0.827961" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_val_pred = model.predict(X_val)\n", - "utils.evaluate_experiment(y_val, y_val_pred)" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "provenance": [], - "machine_shape": "hm" - }, - "gpuClass": "standard", - "kernelspec": { - "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", - "language": "python", - "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" - }, - "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.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file From 8333ec3b0d32d76d5e82a5b3e81cdf53abe4f7d9 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:16:43 +0200 Subject: [PATCH 43/51] Delete Gridsearch280323.ipynb --- Gridsearch280323.ipynb | 1810 ---------------------------------------- 1 file changed, 1810 deletions(-) delete mode 100644 Gridsearch280323.ipynb diff --git a/Gridsearch280323.ipynb b/Gridsearch280323.ipynb deleted file mode 100644 index 4707f4c..0000000 --- a/Gridsearch280323.ipynb +++ /dev/null @@ -1,1810 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "IG6fwukq5oSe" - }, - "source": [ - "# Load your data\n", - "\n", - "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", - "\n", - "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", - "\n", - "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", - "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0L-abXib6HkK", - "outputId": "61aa2656-a0f0-49ce-a597-dd343bb689dc" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wget in /usr/local/lib/python3.9/dist-packages (3.2)\n", - "Requirement already satisfied: wfdb in /usr/local/lib/python3.9/dist-packages (4.1.0)\n", - "Requirement already satisfied: tensorflow-addons in /usr/local/lib/python3.9/dist-packages (0.19.0)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from wfdb) (1.4.4)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.9/dist-packages (from wfdb) (2.27.1)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.9/dist-packages (from wfdb) (0.11.0)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.9/dist-packages (from wfdb) (1.10.1)\n", - "Requirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.9/dist-packages (from wfdb) (1.24.2)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.9/dist-packages (from wfdb) (3.7.1)\n", - "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.9/dist-packages (from tensorflow-addons) (3.0.2)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.9/dist-packages (from tensorflow-addons) (23.0)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.0.7)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (4.39.2)\n", - "Requirement already satisfied: importlib-resources>=3.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (5.12.0)\n", - "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (8.4.0)\n", - "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.9/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.9/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.26.15)\n", - "Requirement already satisfied: charset-normalizer~=2.0.0 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.0.12)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (3.4)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.9/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", - "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.9/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", - "Requirement already satisfied: importlib-metadata>=3.6 in /usr/local/lib/python3.9/dist-packages (from typeguard>=2.7->tensorflow-addons) (6.1.0)\n", - "Requirement already satisfied: typing-extensions>=4.4.0 in /usr/local/lib/python3.9/dist-packages (from typeguard>=2.7->tensorflow-addons) (4.5.0)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.9/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Requirement already satisfied: zipp>=0.5 in /usr/local/lib/python3.9/dist-packages (from importlib-metadata>=3.6->typeguard>=2.7->tensorflow-addons) (3.15.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.9/dist-packages (from python-dateutil>=2.7->matplotlib<4.0.0,>=3.2.2->wfdb) (1.16.0)\n" - ] - } - ], - "source": [ - "!pip install wget wfdb tensorflow-addons" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Y4NQeLDBZUlm", - "outputId": "1ecdd03f-a324-4889-a390-032358123033" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mounted at /content/drive\n" - ] - } - ], - "source": [ - "from google.colab import drive\n", - "drive.mount(\"/content/drive\")" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "id": "Jqxss_rS6Jxn" - }, - "outputs": [], - "source": [ - "import wget\n", - "import numpy as np\n", - "import os\n", - "import zipfile\n", - "import tensorflow as tf\n", - "from sklearn.utils.class_weight import compute_class_weight\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "from sklearn.metrics import confusion_matrix\n", - "import pickle\n", - "import tensorflow_addons as tfa\n", - "from sklearn.metrics import roc_auc_score\n", - "from sklearn.model_selection import StratifiedKFold" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AcjcSuO06o-6", - "outputId": "ba24cbd7-8791-4df2-8dcd-f28176ff5b68" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--2023-03-28 06:32:23-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "Resolving physionet.org (physionet.org)... 18.18.42.54\n", - "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 1842722380 (1.7G) [application/zip]\n", - "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", - "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 704KB/s in 39m 59s \n", - "\n", - "2023-03-28 07:12:22 (750 KB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", - "\n" - ] - } - ], - "source": [ - "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "\n", - "os.mkdir(\"./data/\")\n", - "\n", - "\n", - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3Qv9hVm-5wyi", - "outputId": "9491eee6-ec8c-4197-fdf1-2c86885dedd4" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting GitPython\n", - " Downloading GitPython-3.1.31-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.3/184.3 KB\u001b[0m \u001b[31m5.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m8.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Installing collected packages: smmap, gitdb, GitPython\n", - "Successfully installed GitPython-3.1.31 gitdb-4.0.10 smmap-5.0.0\n" - ] - } - ], - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "u4T-c5KI5y2W" - }, - "outputs": [], - "source": [ - "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", - "DEST_NAME = 'github_repo'" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "r8hm-j6751kC", - "outputId": "16d381b0-9ba6-4de6-8bce-6587ff9d8b0e" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 9 - } - ], - "source": [ - "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "id": "SRUZICm6562J" - }, - "outputs": [], - "source": [ - "from github_repo.code import *\n", - "%matplotlib inline\n", - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CmW7xaR_5oSf", - "outputId": "a0c6929e-9631-4c0d-e1ae-03051df706ee" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "100%|██████████| 21837/21837 [01:05<00:00, 334.36it/s]\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "((19267, 1000, 12), (19267, 5), (2163, 1000, 12), (2163, 5))" - ] - }, - "metadata": {}, - "execution_count": 11 - } - ], - "source": [ - "from github_repo.code.utils import utils\n", - "\n", - "sampling_frequency=100\n", - "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task= 'superdiagnostic' # 'all' , 'diagnostic' , 'subdiagnostic', 'superdiagnostic', 'form', 'rhythm'\n", - "outputfolder='./github_repo/output/'\n", - "\n", - "# Load PTB-XL data\n", - "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", - "# Preprocess label data\n", - "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", - "# Select relevant data and convert to one-hot\n", - "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "# 1-9 for training \n", - "X_train = data[labels.strat_fold < 10]\n", - "y_train = Y[labels.strat_fold < 10]\n", - "# 10 for validation\n", - "X_val = data[labels.strat_fold == 10]\n", - "y_val = Y[labels.strat_fold == 10]\n", - "\n", - "num_classes = y_train.shape[1] # <=== number of classes in the finetuning dataset\n", - "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", - "\n", - "X_train.shape, y_train.shape, X_val.shape, y_val.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - }, - "id": "DIKpffEJMllK", - "outputId": "8c22fd61-1e45-4dbf-e8fd-7e094a3a89de" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "-a6LeAwqOm_i" - }, - "outputs": [], - "source": [ - "from sklearn.model_selection import train_test_split\n", - "\n", - "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "QW5xSWezMWo-", - "outputId": "a17b552a-4e2c-4900-df2f-22c0ce9a6f41" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(1927, 1000, 12)" - ] - }, - "metadata": {}, - "execution_count": 14 - } - ], - "source": [ - "X_grid.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - }, - "id": "fDz352LpQNds", - "outputId": "ecfc7875-1aa0-4b3c-9b3a-fa00ec07253c" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "source": [ - "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1UyIF9kv5oSg" - }, - "source": [ - "# Train or download models\n", - "There are two possibilities:\n", - " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", - " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", - "\n", - "# Load pretrained model\n", - "\n", - "For loading a pretrained model:\n", - " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", - " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", - " \n", - "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "id": "kg7-fD1ocLBB" - }, - "outputs": [], - "source": [ - "from github_repo.code.models.base_model import ClassificationModel\n", - "import tensorflow as tf\n", - "import numpy as np\n", - "import tensorflow_addons as tfa\n", - "\n", - " \n", - "class inception_time_model(ClassificationModel):\n", - " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", - " super(inception_time_model, self).__init__()\n", - " self.name = name\n", - " self.n_classes = n_classes\n", - " self.sampling_frequency = sampling_frequency\n", - " self.outputfolder = outputfolder\n", - " self.input_shape = input_shape\n", - " if loss == \"bce\":\n", - " self.loss = tf.keras.losses.BinaryCrossentropy()\n", - " elif loss == \"wbce\":\n", - " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", - " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", - " self.epoch = epoch\n", - " self.batch_size = batch_size\n", - " self.lr_red = lr_red\n", - " self.verbose = verbose\n", - "\n", - " \n", - " \n", - "\n", - " def fit(self, X_train, y_train, X_val, y_val):\n", - "\n", - " if self.lr_red == \"no\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose)\n", - " elif self.lr_red == \"yes\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose,\n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", - " else:\n", - " print(\"Error: wrong lr_red argument\")\n", - "\n", - " \n", - " def fit_tf(self, traindata, valdata):\n", - "\n", - " if self.lr_red == \"no\":\n", - " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=valdata, verbose=self.verbose)\n", - " elif self.lr_red == \"yes\":\n", - " self.model.fit(traindata, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=valdata, verbose=self.verbose,\n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", - " else:\n", - " print(\"Error: wrong lr_red argument\")\n", - "\n", - " #self.model.save(self.outputfolder +'last_model.h5')\n", - " def predict(self, X):\n", - " return self.model.predict(X)\n", - "\n", - "\n", - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", - " strides=stride, padding='same', activation=activation, use_bias=False)(\n", - " input_inception))\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", - "\n", - " conv_list.append(conv_6)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='same', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - "\n", - " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=loss,\n", - " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\",\n", - " multi_label=True,\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\",\n", - " multi_label=True,\n", - " )\n", - " ])\n", - " print(\"Inception model built.\")\n", - " return model\n", - "\n", - "def scheduler(epoch, lr):\n", - " if epoch % 5 == 0:\n", - " return lr*0.1\n", - " else:\n", - " return lr\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cEx-BdLJ5oSh", - "outputId": "597463e5-ead4-40ab-8850-a6b75e65be89" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n" - ] - } - ], - "source": [ - "#from github_repo.code.models.your_model import inception_time_model\n", - "\n", - "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", - "\n", - "experiment = 'exp0'\n", - "modelname = 'fastai_xresnet1d101'\n", - "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", - "mpath='../output/' # <=== path where the finetuned model will be stored\n", - "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", - "\n", - "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", - "\n", - "#model = fastai_model(\n", - "# modelname, \n", - "# num_classes, \n", - "# sampling_frequency, \n", - "# mpath, \n", - "# input_shape=input_shape, \n", - "# pretrainedfolder=pretrainedfolder,\n", - "# n_classes_pretrained=n_classes_pretrained, \n", - "# pretrained=True,\n", - "# epochs_finetuning=2,\n", - "#)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "V6dtMWU15oSh" - }, - "source": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# Preprocess data with pretrained Standardizer\n", - "\n", - "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "id": "uqSSsK_V5oSh" - }, - "outputs": [], - "source": [ - "import pickle\n", - "from github_repo.code.utils import utils\n", - "\n", - "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", - "\n", - "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", - "#X_val = utils.apply_standardizer(X_val, standard_scaler)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "id": "lOSQURgFUycV" - }, - "outputs": [], - "source": [ - "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", - "\n", - "def apply_standardizer(X, ss):\n", - " X_tmp = []\n", - " for x in X:\n", - " x_shape = x.shape\n", - " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", - " X_tmp = np.array(X_tmp)\n", - " return X_tmp\n", - "\n", - "def preprocess_signals(X_train, X_validation):\n", - " # Standardize data such that mean 0 and variance 1\n", - " ss = StandardScaler()\n", - " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", - " \n", - " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vfdlaRZr5oSh" - }, - "source": [ - "# Finetune model\n", - "\n", - "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "PlLyg3zHQVFh", - "outputId": "8e2094e3-7a8c-4dbf-c8c9-b4236277b33a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "All devices: [LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:0', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:1', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:2', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:3', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:4', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:5', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:6', device_type='TPU'), LogicalDevice(name='/job:worker/replica:0/task:0/device:TPU:7', device_type='TPU')]\n" - ] - } - ], - "source": [ - "resolver = tf.distribute.cluster_resolver.TPUClusterResolver(tpu='')\n", - "tf.config.experimental_connect_to_cluster(resolver)\n", - "# This is the TPU initialization code that has to be at the beginning.\n", - "tf.tpu.experimental.initialize_tpu_system(resolver)\n", - "print(\"All devices: \", tf.config.list_logical_devices('TPU'))\n", - "strategy = tf.distribute.TPUStrategy(resolver)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "MxzCOgaP5oSi", - "outputId": "47708ddc-db9a-481e-e4f1-e1a2205739a1" - }, - "outputs": [ - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Running gridsearch nr 773 of 972...\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 230ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.875927 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 234ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.879164 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 237ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.893471 (AUROC score)\n", - "Running gridsearch nr 774 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 3s 109ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.851221 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 109ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.873682 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 109ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.868266 (AUROC score)\n", - "Running gridsearch nr 775 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 128ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.877054 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 128ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.88111 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 129ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.890032 (AUROC score)\n", - "Running gridsearch nr 776 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 176ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.859853 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 177ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.865822 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 176ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.857429 (AUROC score)\n", - "Running gridsearch nr 777 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 3s 112ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.879027 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 108ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.872127 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 111ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.887514 (AUROC score)\n", - "Running gridsearch nr 778 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 127ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.870224 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 128ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.875355 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 130ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.876755 (AUROC score)\n", - "Running gridsearch nr 779 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 180ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.880301 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 178ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.883572 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 183ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.862774 (AUROC score)\n", - "Running gridsearch nr 780 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 137ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.876724 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 134ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.868919 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 136ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.860753 (AUROC score)\n", - "Running gridsearch nr 781 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 154ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.872357 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 154ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.849907 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 153ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.871234 (AUROC score)\n", - "Running gridsearch nr 782 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 210ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.863062 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 210ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.873208 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 206ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.870427 (AUROC score)\n", - "Running gridsearch nr 783 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 137ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.862762 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 135ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.866377 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 135ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.876808 (AUROC score)\n", - "Running gridsearch nr 784 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 155ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.856176 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 157ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.866409 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 156ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.888049 (AUROC score)\n", - "Running gridsearch nr 785 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 6s 213ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.871113 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 209ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.879743 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 208ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.869063 (AUROC score)\n", - "Running gridsearch nr 786 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 161ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.862035 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 157ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.86776 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 159ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.88166 (AUROC score)\n", - "Running gridsearch nr 787 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 179ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.876252 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 181ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.88044 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 179ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.880374 (AUROC score)\n", - "Running gridsearch nr 788 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 6s 236ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.872432 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 235ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.875169 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 237ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.883025 (AUROC score)\n", - "Running gridsearch nr 789 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 158ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.877194 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 158ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.879591 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 159ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.871315 (AUROC score)\n", - "Running gridsearch nr 790 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 181ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.874268 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 179ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.870436 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 180ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.871527 (AUROC score)\n", - "Running gridsearch nr 791 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 6s 236ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.883336 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 241ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.846127 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 236ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.881243 (AUROC score)\n", - "Running gridsearch nr 792 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 3s 113ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.701763 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 111ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.75426 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 109ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.705248 (AUROC score)\n", - "Running gridsearch nr 793 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 129ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.798136 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 133ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.791599 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 131ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.789322 (AUROC score)\n", - "Running gridsearch nr 794 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 182ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.810941 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 182ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.850941 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 183ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.785455 (AUROC score)\n", - "Running gridsearch nr 795 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 113ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.698142 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 110ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.665589 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 3s 113ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.612971 (AUROC score)\n", - "Running gridsearch nr 796 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 130ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.722301 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 134ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.753098 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 132ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.813672 (AUROC score)\n", - "Running gridsearch nr 797 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 187ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.765699 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 184ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.770361 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 5s 184ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.786691 (AUROC score)\n", - "Running gridsearch nr 798 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 134ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.753515 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 135ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.779601 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 138ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.756694 (AUROC score)\n", - "Running gridsearch nr 799 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 159ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.786646 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 158ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.822237 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 162ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.818343 (AUROC score)\n", - "Running gridsearch nr 800 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 5s 211ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.789703 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 216ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.840821 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 6s 216ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.82497 (AUROC score)\n", - "Running gridsearch nr 801 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 136ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.729646 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 138ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.639953 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 139ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.641304 (AUROC score)\n", - "Running gridsearch nr 802 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - ":39: FutureWarning: The frame.append method is deprecated and will be removed from pandas in a future version. Use pandas.concat instead.\n", - " df_score=df_score.append(df_grid.loc[gsr])\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 4s 157ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.750653 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 4s 158ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.805098 (AUROC score)\n", - "Inception model built.\n", - " 1/21 [>.............................] - ETA: 25s" - ] - } - ], - "source": [ - "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", - "df_grid = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_params.csv\")\n", - "df_score = pd.read_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_superdiagnostic.csv\")\n", - "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", - "init_rows = df_score.shape[0]\n", - "\n", - "for gsr in range(gs_left):\n", - " gsr = gsr + init_rows #if previous gridsearch results exists\n", - " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", - " auc_score = []\n", - " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", - " with strategy.scope():\n", - " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", - " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", - " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", - " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", - " cv_x_train = X_grid[train_index]\n", - " cv_y_train = y_grid[train_index] \n", - " cv_x_test = X_grid[test_index]\n", - " cv_y_test = y_grid[test_index]\n", - " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", - " \n", - " tf_dataset_train = tf.data.Dataset.from_tensor_slices((cv_x_train, cv_y_train)) #tf.data.Dataset.from_tensor_slices((X_train, y_train))\n", - " tf_dataset_train = tf_dataset_train.cache()\n", - " tf_dataset_train = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", - " tf_dataset_train = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", - "\n", - " tf_dataset_val = tf.data.Dataset.from_tensor_slices((cv_x_test, cv_y_test))\n", - " tf_dataset_val = tf_dataset_train.cache()\n", - " tf_dataset_val = tf_dataset_train.batch(int(df_grid.iloc[gsr][\"batch_size\"]))\n", - " tf_dataset_val = tf_dataset_train.prefetch(tf.data.AUTOTUNE)\n", - "\n", - " model.fit_tf(tf_dataset_train, tf_dataset_val)\n", - " y_hat_test = model.predict(cv_x_test)\n", - " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", - " auc_score.append(score)\n", - " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", - " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", - " df_score=df_score.append(df_grid.loc[gsr])\n", - " df_score.to_csv(\"/content/drive/MyDrive/ptb-xl-gridsearch/gridsearch_score_superdiagnostic.csv\", index=False) " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "SPSC9F4wPf9J" - }, - "outputs": [], - "source": [ - "utils.utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kvnNlyCX5oSi" - }, - "source": [ - "# Evaluate model on validation data" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "m1rgPocD5oSi" - }, - "outputs": [], - "source": [ - "y_val_pred = model.predict(X_val)\n", - "utils.evaluate_experiment(y_val, y_val_pred)" - ] - } - ], - "metadata": { - "accelerator": "TPU", - "colab": { - "machine_shape": "hm", - "provenance": [] - }, - "gpuClass": "standard", - "kernelspec": { - "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", - "language": "python", - "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" - }, - "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.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file From 9475602b58a2843f42a951b5e123793aed6009d9 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:16:54 +0200 Subject: [PATCH 44/51] Delete My_Finetuning.ipynb --- My_Finetuning.ipynb | 1760 ------------------------------------------- 1 file changed, 1760 deletions(-) delete mode 100644 My_Finetuning.ipynb diff --git a/My_Finetuning.ipynb b/My_Finetuning.ipynb deleted file mode 100644 index ba65262..0000000 --- a/My_Finetuning.ipynb +++ /dev/null @@ -1,1760 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "IG6fwukq5oSe" - }, - "source": [ - "# Load your data\n", - "\n", - "Before finetuning a pretrained model of the experiments we provide in our repository (or precomputed and provided [here](https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq)), first load your custom 100 Hz sampled 12-lead ECG signal data `X` of shape `[N,L,12]` in Millivolts (mV) and multi-hot encoded labels `y` of shape `[N,C]` as numpy arrays, where `C` is the number of classes and `N` the number of total samples in this dataset. Although PTB-XL comes with fixed `L=1000` (i,e. 10 seconds), it is not required to be fixed, **BUT** the shortest sample must be longer than `input_size` of the specific model (e.g. 2.5 seconds for our fastai-models).\n", - "\n", - "For proper tinetuning split your data into four numpy arrays: `X_train`,`y_train`,`X_val` and `y_val`\n", - "\n", - "### Example: finetune model trained on all (71) on superdiagnostic (5)\n", - "Below we provide an example for loading [PTB-XL](https://physionet.org/content/ptb-xl/1.0.1/) aggregated at the `superdiagnostic` level, where we use the provided folds for train-validation-split:" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "0L-abXib6HkK", - "outputId": "9195fc47-5a83-4da7-d9de-6380794e0780" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Requirement already satisfied: wget in /usr/local/lib/python3.8/dist-packages (3.2)\n", - "Requirement already satisfied: wfdb in /usr/local/lib/python3.8/dist-packages (4.1.0)\n", - "Collecting tensorflow-addons\n", - " Downloading tensorflow_addons-0.19.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.1 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.1/1.1 MB\u001b[0m \u001b[31m16.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hRequirement already satisfied: numpy<2.0.0,>=1.10.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.21.6)\n", - "Requirement already satisfied: requests<3.0.0,>=2.8.1 in /usr/local/lib/python3.8/dist-packages (from wfdb) (2.25.1)\n", - "Requirement already satisfied: SoundFile<0.12.0,>=0.10.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (0.11.0)\n", - "Requirement already satisfied: scipy<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.7.3)\n", - "Requirement already satisfied: matplotlib<4.0.0,>=3.2.2 in /usr/local/lib/python3.8/dist-packages (from wfdb) (3.2.2)\n", - "Requirement already satisfied: pandas<2.0.0,>=1.0.0 in /usr/local/lib/python3.8/dist-packages (from wfdb) (1.3.5)\n", - "Requirement already satisfied: packaging in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (23.0)\n", - "Requirement already satisfied: typeguard>=2.7 in /usr/local/lib/python3.8/dist-packages (from tensorflow-addons) (2.7.1)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (0.11.0)\n", - "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (2.8.2)\n", - "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (1.4.4)\n", - "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib<4.0.0,>=3.2.2->wfdb) (3.0.9)\n", - "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas<2.0.0,>=1.0.0->wfdb) (2022.7.1)\n", - "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (1.24.3)\n", - "Requirement already satisfied: chardet<5,>=3.0.2 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (4.0.0)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2022.12.7)\n", - "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.8/dist-packages (from requests<3.0.0,>=2.8.1->wfdb) (2.10)\n", - "Requirement already satisfied: cffi>=1.0 in /usr/local/lib/python3.8/dist-packages (from SoundFile<0.12.0,>=0.10.0->wfdb) (1.15.1)\n", - "Requirement already satisfied: pycparser in /usr/local/lib/python3.8/dist-packages (from cffi>=1.0->SoundFile<0.12.0,>=0.10.0->wfdb) (2.21)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib<4.0.0,>=3.2.2->wfdb) (1.15.0)\n", - "Installing collected packages: tensorflow-addons\n", - "Successfully installed tensorflow-addons-0.19.0\n" - ] - } - ], - "source": [ - "!pip install wget wfdb tensorflow-addons" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "Jqxss_rS6Jxn" - }, - "outputs": [], - "source": [ - "import wget\n", - "import numpy as np\n", - "import os\n", - "import zipfile\n", - "import tensorflow as tf\n", - "from sklearn.utils.class_weight import compute_class_weight\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "from sklearn.metrics import confusion_matrix\n", - "import pickle\n", - "from sklearn.metrics import roc_auc_score\n", - "from sklearn.model_selection import StratifiedKFold" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "AcjcSuO06o-6", - "outputId": "be744e1b-2e40-4e12-f735-0182402c6108" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--2023-02-08 08:07:05-- https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "Resolving physionet.org (physionet.org)... 18.18.42.54\n", - "Connecting to physionet.org (physionet.org)|18.18.42.54|:443... connected.\n", - "HTTP request sent, awaiting response... 200 OK\n", - "Length: 1842722380 (1.7G) [application/zip]\n", - "Saving to: ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’\n", - "\n", - "ptb-xl-a-large-publ 100%[===================>] 1.72G 1.76MB/s in 14m 26s \n", - "\n", - "2023-02-08 08:21:31 (2.03 MB/s) - ‘ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip’ saved [1842722380/1842722380]\n", - "\n" - ] - } - ], - "source": [ - "!wget https://physionet.org/static/published-projects/ptb-xl/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\n", - "\n", - "os.mkdir(\"./data/\")\n", - "\n", - "\n", - "with zipfile.ZipFile(\"./ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1.zip\", 'r') as zip_ref:\n", - " zip_ref.extractall(\"./data/\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "3Qv9hVm-5wyi", - "outputId": "0462259a-3378-4590-fe3c-441eea0a5f93" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", - "Collecting GitPython\n", - " Downloading GitPython-3.1.30-py3-none-any.whl (184 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m184.0/184.0 KB\u001b[0m \u001b[31m4.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting gitdb<5,>=4.0.1\n", - " Downloading gitdb-4.0.10-py3-none-any.whl (62 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m62.7/62.7 KB\u001b[0m \u001b[31m7.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hCollecting smmap<6,>=3.0.1\n", - " Downloading smmap-5.0.0-py3-none-any.whl (24 kB)\n", - "Installing collected packages: smmap, gitdb, GitPython\n", - "Successfully installed GitPython-3.1.30 gitdb-4.0.10 smmap-5.0.0\n" - ] - } - ], - "source": [ - "!pip install GitPython\n", - "from git import Repo" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "u4T-c5KI5y2W" - }, - "outputs": [], - "source": [ - "HTTPS_REMOTE_URL = 'https://github.com/Bsingstad/ecg_ptbxl_benchmarking.git'\n", - "DEST_NAME = 'github_repo'" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "r8hm-j6751kC", - "outputId": "180a7b25-f676-4462-8d74-f4bc9507cb32" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 6 - } - ], - "source": [ - "Repo.clone_from(HTTPS_REMOTE_URL, DEST_NAME)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "SRUZICm6562J", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "b88ccb7c-79cd-4b5a-90f7-e030de2f6fef" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "from github_repo.code import *\n", - "%matplotlib inline\n", - "%load_ext autoreload" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CmW7xaR_5oSf", - "outputId": "39005e7c-389c-41a3-9c4e-a5ea436c04be" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "((19634, 1000, 12), (19634, 71), (2203, 1000, 12), (2203, 71))" - ] - }, - "metadata": {}, - "execution_count": 172 - } - ], - "source": [ - "from github_repo.code.utils import utils\n", - "\n", - "sampling_frequency=100\n", - "datafolder='./data/ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1/'\n", - "task='all'\n", - "outputfolder='./github_repo/output/'\n", - "\n", - "\n", - "# Load PTB-XL data\n", - "data, raw_labels = utils.load_dataset(datafolder, sampling_frequency)\n", - "# Preprocess label data\n", - "labels = utils.compute_label_aggregations(raw_labels, datafolder, task)\n", - "# Select relevant data and convert to one-hot\n", - "#data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "data, labels, Y, _ = utils.select_data(data, labels, task, min_samples=0, outputfolder=outputfolder)\n", - "\n", - "# 1-9 for training \n", - "X_train = data[labels.strat_fold < 10]\n", - "y_train = Y[labels.strat_fold < 10]\n", - "# 10 for validation\n", - "X_val = data[labels.strat_fold == 10]\n", - "y_val = Y[labels.strat_fold == 10]\n", - "\n", - "num_classes = 71 # <=== number of classes in the finetuning dataset\n", - "input_shape = [1000,12] # <=== shape of samples, [None, 12] in case of different lengths\n", - "\n", - "X_train.shape, y_train.shape, X_val.shape, y_val.shape" - ] - }, - { - "cell_type": "code", - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.bar(np.unique(y_train.argmax(axis=1),return_counts=True)[0],np.unique(y_train.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ], - "metadata": { - "id": "DIKpffEJMllK", - "outputId": "cf3ae66c-a95e-4670-ff05-64ce78602e27", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - } - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "code", - "source": [ - "from sklearn.model_selection import train_test_split\n", - "\n", - "_, X_grid, _, y_grid= train_test_split(X_train, y_train, test_size=0.10, random_state=42)" - ], - "metadata": { - "id": "-a6LeAwqOm_i" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "X_grid.shape" - ], - "metadata": { - "id": "QW5xSWezMWo-", - "outputId": "c723adea-2161-4f0b-fd64-90ef25f84106", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "(1964, 1000, 12)" - ] - }, - "metadata": {}, - "execution_count": 182 - } - ] - }, - { - "cell_type": "code", - "source": [ - "plt.bar(np.unique(y_grid.argmax(axis=1),return_counts=True)[0],np.unique(y_grid.argmax(axis=1),return_counts=True)[1])\n", - "plt.show()" - ], - "metadata": { - "id": "fDz352LpQNds", - "outputId": "f0194fae-4695-4aa8-e7cc-a3cd8773e042", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 265 - } - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": { - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1UyIF9kv5oSg" - }, - "source": [ - "# Train or download models\n", - "There are two possibilities:\n", - " 1. Run the experiments as described in README. Afterwards you find trained in models in `output/expX/models/`\n", - " 2. Download the precomputed `output`-folder with all experiments and models from [here]((https://datacloud.hhi.fraunhofer.de/nextcloud/s/NCjYws3mamLrkKq))\n", - "\n", - "# Load pretrained model\n", - "\n", - "For loading a pretrained model:\n", - " 1. specify `modelname` which can be seen in `code/configs/` (e.g. `modelname='fastai_xresnet1d101'`)\n", - " 2. provide `experiment` to build the path `pretrainedfolder` (here: `exp0` refers to the experiment with `all` 71 SCP-statements)\n", - " \n", - "This returns the pretrained model where the classification is replaced by a random initialized head with the same number of outputs as the number of classes." - ] - }, - { - "cell_type": "code", - "source": [ - "from github_repo.code.models.base_model import ClassificationModel\n", - "import tensorflow as tf\n", - "import numpy as np\n", - "\n", - "def scheduler(epoch, lr):\n", - " if epoch % 5 == 0:\n", - " return lr*0.1\n", - " else:\n", - " return lr\n", - " \n", - "class inception_time_model(ClassificationModel):\n", - " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\"):\n", - " super(inception_time_model, self).__init__()\n", - " self.name = name\n", - " self.n_classes = n_classes\n", - " self.sampling_frequency = sampling_frequency\n", - " self.outputfolder = outputfolder\n", - " self.input_shape = input_shape\n", - " self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = 0.001, depth=model_depth, kernel_size=40, bottleneck_size=32, nb_filters=32,clf=\"binary\")\n", - " self.epoch = epoch \n", - " self.batch_size = batch_size\n", - " self.lr_red = lr_red\n", - " self.loss = loss\n", - " \n", - "\n", - " def fit(self, X_train, y_train, X_val, y_val):\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), \n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=1)\n", - " ])\n", - " #self.model.save(self.outputfolder +'last_model.h5')\n", - " def predict(self, X):\n", - " return self.model.predict(X)\n", - "\n", - "\n", - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", - " strides=stride, padding='same', activation=activation, use_bias=False)(\n", - " input_inception))\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", - "\n", - " conv_list.append(conv_6)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='same', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - "\n", - " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\"):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\",\n", - " multi_label=True,\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\",\n", - " multi_label=True,\n", - " )\n", - " ])\n", - " print(\"Inception model built.\")\n", - " return model\n", - "\n", - "\n" - ], - "metadata": { - "id": "kg7-fD1ocLBB" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "model.model.loss" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "gAY6-vMvAZmH", - "outputId": "f52575d5-5e99-44f4-cd34-22ed4c315dff" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "" - ] - }, - "metadata": {}, - "execution_count": 210 - } - ] - }, - { - "cell_type": "code", - "source": [ - "from github_repo.code.models.base_model import ClassificationModel\n", - "import tensorflow as tf\n", - "import numpy as np\n", - "import tensorflow_addons as tfa\n", - "\n", - " \n", - "class inception_time_model(ClassificationModel):\n", - " def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red=\"yes\", model_depth=6, loss=\"bce\", kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", verbose=0):\n", - " super(inception_time_model, self).__init__()\n", - " self.name = name\n", - " self.n_classes = n_classes\n", - " self.sampling_frequency = sampling_frequency\n", - " self.outputfolder = outputfolder\n", - " self.input_shape = input_shape\n", - " if loss == \"bce\":\n", - " self.loss = tf.keras.losses.BinaryCrossentropy()\n", - " elif loss == \"wbce\":\n", - " self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce\n", - " self.model = build_modelol((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss=self.loss)\n", - " self.epoch = epoch\n", - " self.batch_size = batch_size\n", - " self.lr_red = lr_red\n", - " self.verbose = verbose\n", - "\n", - " \n", - " \n", - "\n", - " def fit(self, X_train, y_train, X_val, y_val):\n", - "\n", - " if self.lr_red == \"no\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose)\n", - " elif self.lr_red == \"yes\":\n", - " self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n", - " validation_data=(X_val, y_val), verbose=self.verbose,\n", - " callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)])\n", - " else:\n", - " print(\"Error: wrong lr_red argument\")\n", - "\n", - " #self.model.save(self.outputfolder +'last_model.h5')\n", - " def predict(self, X):\n", - " return self.model.predict(X)\n", - "\n", - "\n", - "def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32):\n", - "\n", - " if use_bottleneck and int(input_tensor.shape[-1]) > 1:\n", - " input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(input_tensor)\n", - " else:\n", - " input_inception = input_tensor\n", - "\n", - " # kernel_size_s = [3, 5, 8, 11, 17]\n", - " kernel_size_s = [kernel_size // (2 ** i) for i in range(3)]\n", - "\n", - " conv_list = []\n", - "\n", - " for i in range(len(kernel_size_s)):\n", - " conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i],\n", - " strides=stride, padding='same', activation=activation, use_bias=False)(\n", - " input_inception))\n", - "\n", - " max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)\n", - "\n", - " conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1,\n", - " padding='same', activation=activation, use_bias=False)(max_pool_1)\n", - "\n", - " conv_list.append(conv_6)\n", - "\n", - " x = tf.keras.layers.Concatenate(axis=2)(conv_list)\n", - " x = tf.keras.layers.BatchNormalization()(x)\n", - " x = tf.keras.layers.Activation(activation='relu')(x)\n", - " return x\n", - "\n", - "def _shortcut_layer(input_tensor, out_tensor):\n", - " shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,\n", - " padding='same', use_bias=False)(input_tensor)\n", - " shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y)\n", - "\n", - " x = tf.keras.layers.Add()([shortcut_y, out_tensor])\n", - " x = tf.keras.layers.Activation('relu')(x)\n", - " return x\n", - "\n", - "def build_modelol(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf=\"binary\", loss=tf.keras.losses.BinaryCrossentropy()):\n", - " input_layer = tf.keras.layers.Input(input_shape)\n", - "\n", - " x = input_layer\n", - " input_res = input_layer\n", - "\n", - " for d in range(depth):\n", - "\n", - " x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters)\n", - "\n", - " if use_residual and d % 3 == 2:\n", - " x = _shortcut_layer(input_res, x)\n", - " input_res = x\n", - "\n", - " gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x)\n", - "\n", - " output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) \n", - " model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer)\n", - " model.compile(loss=loss,\n", - " optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), \n", - " metrics=[tf.keras.metrics.BinaryAccuracy(),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='ROC',\n", - " summation_method='interpolation',\n", - " name=\"ROC\",\n", - " multi_label=True,\n", - " ),\n", - " tf.keras.metrics.AUC(\n", - " num_thresholds=200,\n", - " curve='PR',\n", - " summation_method='interpolation',\n", - " name=\"PRC\",\n", - " multi_label=True,\n", - " )\n", - " ])\n", - " print(\"Inception model built.\")\n", - " return model\n", - "\n", - "def scheduler(epoch, lr):\n", - " if epoch % 5 == 0:\n", - " return lr*0.1\n", - " else:\n", - " return lr\n" - ], - "metadata": { - "id": "_sdQPeYY_1_o" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cEx-BdLJ5oSh", - "outputId": "0d90955e-0671-49ee-9485-4c3a695c041a" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n" - ] - } - ], - "source": [ - "#from github_repo.code.models.your_model import inception_time_model\n", - "\n", - "# change first line in your_model.py to from github_repo.code.models.base_model import ClassificationModel\n", - "\n", - "experiment = 'exp0'\n", - "modelname = 'fastai_xresnet1d101'\n", - "pretrainedfolder = '../output/'+experiment+'/models/'+modelname+'/'\n", - "mpath='../output/' # <=== path where the finetuned model will be stored\n", - "n_classes_pretrained = 71 # <=== because we load the model from exp0, this should be fixed because this depends the experiment\n", - "\n", - "model = inception_time_model(\"tf_inception\", num_classes, sampling_frequency, mpath, input_shape)\n", - "\n", - "#model = fastai_model(\n", - "# modelname, \n", - "# num_classes, \n", - "# sampling_frequency, \n", - "# mpath, \n", - "# input_shape=input_shape, \n", - "# pretrainedfolder=pretrainedfolder,\n", - "# n_classes_pretrained=n_classes_pretrained, \n", - "# pretrained=True,\n", - "# epochs_finetuning=2,\n", - "#)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "V6dtMWU15oSh" - }, - "source": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "# Preprocess data with pretrained Standardizer\n", - "\n", - "Since we standardize inputs to zero mean and unit variance, your custom data needs to be standardized with the respective mean and variance. This is also provided in the respective experiment folder `output/expX/data/standard_scaler.pkl`" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "uqSSsK_V5oSh" - }, - "outputs": [], - "source": [ - "import pickle\n", - "from github_repo.code.utils import utils\n", - "\n", - "#standard_scaler = pickle.load(open('./github_repo/output/'+experiment+'/data/standard_scaler.pkl', \"rb\"))\n", - "\n", - "#X_grid = utils.apply_standardizer(X_grid, standard_scaler)\n", - "#X_val = utils.apply_standardizer(X_val, standard_scaler)" - ] - }, - { - "cell_type": "code", - "source": [ - "from sklearn.preprocessing import StandardScaler, MultiLabelBinarizer\n", - "\n", - "def apply_standardizer(X, ss):\n", - " X_tmp = []\n", - " for x in X:\n", - " x_shape = x.shape\n", - " X_tmp.append(ss.transform(x.flatten()[:,np.newaxis]).reshape(x_shape))\n", - " X_tmp = np.array(X_tmp)\n", - " return X_tmp\n", - "\n", - "def preprocess_signals(X_train, X_validation):\n", - " # Standardize data such that mean 0 and variance 1\n", - " ss = StandardScaler()\n", - " ss.fit(np.vstack(X_train).flatten()[:,np.newaxis].astype(float))\n", - " \n", - " return apply_standardizer(X_train, ss), apply_standardizer(X_validation, ss)\n" - ], - "metadata": { - "id": "lOSQURgFUycV" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "vfdlaRZr5oSh" - }, - "source": [ - "# Finetune model\n", - "\n", - "Calling `model.fit` of a model with `pretrained=True` will perform finetuning as proposed in our work i.e. **gradual unfreezing and discriminative learning rates**. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "MxzCOgaP5oSi", - "outputId": "4ba7077e-2803-46e3-eca4-a9ef40b945fc" - }, - "outputs": [ - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Running gridsearch nr 0 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.785309 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 17ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.804568 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 17ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.791498 (AUROC score)\n", - "Running gridsearch nr 1 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.81849 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.820807 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.821093 (AUROC score)\n", - "Running gridsearch nr 2 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.83337 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.821804 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.837105 (AUROC score)\n", - "Running gridsearch nr 3 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 17ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.773381 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.748142 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.726756 (AUROC score)\n", - "Running gridsearch nr 4 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.820982 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.778317 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.819262 (AUROC score)\n", - "Running gridsearch nr 5 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.824672 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.789657 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.812811 (AUROC score)\n", - "Running gridsearch nr 6 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.821719 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.81206 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.794849 (AUROC score)\n", - "Running gridsearch nr 7 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 28ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.836565 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 28ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.803726 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 28ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.817623 (AUROC score)\n", - "Running gridsearch nr 8 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.834711 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.805836 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.825461 (AUROC score)\n", - "Running gridsearch nr 9 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.796138 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.749337 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.804074 (AUROC score)\n", - "Running gridsearch nr 10 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 32ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.836407 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 28ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.806131 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 28ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.793941 (AUROC score)\n", - "Running gridsearch nr 11 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stdout", - "output_type": "stream", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.805754 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.79209 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.808169 (AUROC score)\n", - "Running gridsearch nr 12 of 972...\n" - ] - }, - { - "metadata": { - "tags": null - }, - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 35ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.816178 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 35ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.78194 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 35ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.81159 (AUROC score)\n", - "Running gridsearch nr 13 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 2s 38ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.82238 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 38ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.825624 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 38ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.807163 (AUROC score)\n", - "Running gridsearch nr 14 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 2s 39ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.823611 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 39ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.799625 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 39ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.829105 (AUROC score)\n", - "Running gridsearch nr 15 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 2s 35ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.775262 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 36ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.758773 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 35ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.803473 (AUROC score)\n", - "Running gridsearch nr 16 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 2s 38ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.823635 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 38ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.776986 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 38ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.804917 (AUROC score)\n", - "Running gridsearch nr 17 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 2s 39ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.816949 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 39ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.772254 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 39ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.82311 (AUROC score)\n", - "Running gridsearch nr 18 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 2s 17ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.88794 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.86945 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.888054 (AUROC score)\n", - "Running gridsearch nr 19 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.895454 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.870784 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.88359 (AUROC score)\n", - "Running gridsearch nr 20 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.87756 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.879005 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 20ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.879999 (AUROC score)\n", - "Running gridsearch nr 21 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.882987 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.869587 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 18ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.883509 (AUROC score)\n", - "Running gridsearch nr 22 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.866746 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.870394 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.886791 (AUROC score)\n", - "Running gridsearch nr 23 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.876125 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 20ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.860956 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 19ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.875806 (AUROC score)\n", - "Running gridsearch nr 24 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.888203 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 26ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.881306 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 27ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.887909 (AUROC score)\n", - "Running gridsearch nr 25 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 28ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.882829 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 2s 28ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.880861 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 28ms/step\n", - "Score CV 3 : macro_auc\n", - "0 0.895306 (AUROC score)\n", - "Running gridsearch nr 26 of 972...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.8/dist-packages/sklearn/model_selection/_split.py:676: UserWarning: The least populated class in y has only 1 members, which is less than n_splits=3.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 1 : macro_auc\n", - "0 0.880683 (AUROC score)\n", - "Inception model built.\n", - "21/21 [==============================] - 1s 29ms/step\n", - "Score CV 2 : macro_auc\n", - "0 0.879229 (AUROC score)\n", - "Inception model built.\n" - ] - }, - { - "output_type": "error", - "ename": "KeyboardInterrupt", - "evalue": "ignored", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 20\u001b[0m \u001b[0mcv_x_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcv_x_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpreprocess_signals\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_x_train\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcv_x_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_x_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv_y_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv_x_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcv_y_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 23\u001b[0m \u001b[0my_hat_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_x_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 24\u001b[0m \u001b[0mscore\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mutils\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mevaluate_experiment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcv_y_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcv_y_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0my_hat_test\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my_hat_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, X_train, y_train, X_val, y_val)\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 30\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr_red\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"no\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 31\u001b[0;31m self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, \n\u001b[0m\u001b[1;32m 32\u001b[0m validation_data=(X_val, y_val), verbose=self.verbose)\n\u001b[1;32m 33\u001b[0m \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlr_red\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"yes\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/utils/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 62\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 65\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pylint: disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m 1407\u001b[0m _r=1):\n\u001b[1;32m 1408\u001b[0m \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1409\u001b[0;31m \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1410\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata_handler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshould_sync\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1411\u001b[0m \u001b[0mcontext\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0masync_wait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/util/traceback_utils.py\u001b[0m in \u001b[0;36merror_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 148\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 149\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 150\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 151\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0mfiltered_tb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_process_traceback_frames\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__traceback__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 913\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_jit_compile\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 915\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 916\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 917\u001b[0m \u001b[0mnew_tracing_count\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m 961\u001b[0m \u001b[0;31m# This is the first call of __call__, so we have to initialize.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 962\u001b[0m \u001b[0minitializers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 963\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_initialize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0madd_initializers_to\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minitializers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 964\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 965\u001b[0m \u001b[0;31m# At this point we know that the initialization is complete (or less\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_initialize\u001b[0;34m(self, args, kwds, add_initializers_to)\u001b[0m\n\u001b[1;32m 783\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_graph_deleter\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFunctionDeleter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lifted_initializer_graph\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 784\u001b[0m self._concrete_stateful_fn = (\n\u001b[0;32m--> 785\u001b[0;31m self._stateful_fn._get_concrete_function_internal_garbage_collected( # pylint: disable=protected-access\n\u001b[0m\u001b[1;32m 786\u001b[0m *args, **kwds))\n\u001b[1;32m 787\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_get_concrete_function_internal_garbage_collected\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 2478\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2479\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2480\u001b[0;31m \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2481\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2482\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_maybe_define_function\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 2709\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcache_key\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_placeholder_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2710\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2711\u001b[0;31m \u001b[0mgraph_function\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_create_graph_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2712\u001b[0m self._function_cache.add(cache_key, cache_key_deletion_observer,\n\u001b[1;32m 2713\u001b[0m graph_function)\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_create_graph_function\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m 2625\u001b[0m \u001b[0marg_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbase_arg_names\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mmissing_arg_names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2626\u001b[0m graph_function = ConcreteFunction(\n\u001b[0;32m-> 2627\u001b[0;31m func_graph_module.func_graph_from_py_func(\n\u001b[0m\u001b[1;32m 2628\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2629\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_python_function\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mfunc_graph_from_py_func\u001b[0;34m(name, python_func, args, kwargs, signature, func_graph, autograph, autograph_options, add_control_dependencies, arg_names, op_return_value, collections, capture_by_value, acd_record_initial_resource_uses)\u001b[0m\n\u001b[1;32m 1139\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moriginal_func\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf_decorator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0munwrap\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpython_func\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1140\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1141\u001b[0;31m \u001b[0mfunc_outputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpython_func\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0mfunc_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfunc_kwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1142\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1143\u001b[0m \u001b[0;31m# invariant: `func_outputs` contains only Tensors, CompositeTensors,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36mwrapped_fn\u001b[0;34m(*args, **kwds)\u001b[0m\n\u001b[1;32m 675\u001b[0m \u001b[0;31m# the function a weak reference to itself to avoid a reference cycle.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mOptionalXlaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcompile_with_xla\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 677\u001b[0;31m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mweak_wrapped_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__wrapped__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 678\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 679\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/func_graph.py\u001b[0m in \u001b[0;36mautograph_handler\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 1114\u001b[0m \u001b[0;31m# TODO(mdan): Push this block higher in tf.function's call stack.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1115\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1116\u001b[0;31m return autograph.converted_call(\n\u001b[0m\u001b[1;32m 1117\u001b[0m \u001b[0moriginal_func\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1118\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mconverted_call\u001b[0;34m(f, args, kwargs, caller_fn_scope, options)\u001b[0m\n\u001b[1;32m 437\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 438\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 439\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconverted_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meffective_args\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 440\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 441\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mconverted_f\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0meffective_args\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mtf__train_function\u001b[0;34m(iterator)\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mdo_return\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mretval_\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconverted_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep_function\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mag__\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mld\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfscope\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 16\u001b[0m \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0mdo_return\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mconverted_call\u001b[0;34m(f, args, kwargs, caller_fn_scope, options)\u001b[0m\n\u001b[1;32m 375\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_requested\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mconversion\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_allowlisted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_call_unconverted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 378\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[0;31m# internal_convert_user_code is for example turned off when issuing a dynamic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36m_call_unconverted\u001b[0;34m(f, args, kwargs, options, update_cache)\u001b[0m\n\u001b[1;32m 457\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 458\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 459\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 461\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mstep_function\u001b[0;34m(model, iterator)\u001b[0m\n\u001b[1;32m 1038\u001b[0m run_step, jit_compile=True, reduce_retracing=True)\n\u001b[1;32m 1039\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1040\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdistribute_strategy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrun_step\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1041\u001b[0m outputs = reduce_per_replica(\n\u001b[1;32m 1042\u001b[0m outputs, self.distribute_strategy, reduction='first')\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36mrun\u001b[0;34m(***failed resolving arguments***)\u001b[0m\n\u001b[1;32m 1310\u001b[0m fn = autograph.tf_convert(\n\u001b[1;32m 1311\u001b[0m fn, autograph_ctx.control_status_ctx(), convert_by_default=False)\n\u001b[0;32m-> 1312\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_extended\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcall_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1313\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1314\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mreduce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36mcall_for_each_replica\u001b[0;34m(self, fn, args, kwargs)\u001b[0m\n\u001b[1;32m 2886\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2887\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_container_strategy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2888\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2889\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2890\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_call_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/distribute/distribute_lib.py\u001b[0m in \u001b[0;36m_call_for_each_replica\u001b[0;34m(self, fn, args, kwargs)\u001b[0m\n\u001b[1;32m 3687\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_call_for_each_replica\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3688\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mReplicaContext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_container_strategy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreplica_id_in_sync_group\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3689\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3690\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 3691\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_reduce_to\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mreduce_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdestinations\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 687\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 688\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mconversion_ctx\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 689\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mconverted_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 690\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pylint:disable=broad-except\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 691\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'ag_error_metadata'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36mconverted_call\u001b[0;34m(f, args, kwargs, caller_fn_scope, options)\u001b[0m\n\u001b[1;32m 375\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 376\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0muser_requested\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mconversion\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_allowlisted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_call_unconverted\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 378\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 379\u001b[0m \u001b[0;31m# internal_convert_user_code is for example turned off when issuing a dynamic\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/autograph/impl/api.py\u001b[0m in \u001b[0;36m_call_unconverted\u001b[0;34m(f, args, kwargs, options, update_cache)\u001b[0m\n\u001b[1;32m 456\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 457\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 458\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 459\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 460\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mrun_step\u001b[0;34m(data)\u001b[0m\n\u001b[1;32m 1028\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1029\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mrun_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1030\u001b[0;31m \u001b[0moutputs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrain_step\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1031\u001b[0m \u001b[0;31m# Ensure counter is updated only if `train_step` succeeds.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1032\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcontrol_dependencies\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m_minimum_control_deps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/engine/training.py\u001b[0m in \u001b[0;36mtrain_step\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 891\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validate_target_and_loss\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 892\u001b[0m \u001b[0;31m# Run backwards pass.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 893\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptimizer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mminimize\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtrainable_variables\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 894\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_metrics\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_pred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msample_weight\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 895\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/optimizer_v2.py\u001b[0m in \u001b[0;36mminimize\u001b[0;34m(self, loss, var_list, grad_loss, name, tape)\u001b[0m\n\u001b[1;32m 535\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 536\u001b[0m \"\"\"\n\u001b[0;32m--> 537\u001b[0;31m grads_and_vars = self._compute_gradients(\n\u001b[0m\u001b[1;32m 538\u001b[0m loss, var_list=var_list, grad_loss=grad_loss, tape=tape)\n\u001b[1;32m 539\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrads_and_vars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/optimizer_v2.py\u001b[0m in \u001b[0;36m_compute_gradients\u001b[0;34m(self, loss, var_list, grad_loss, tape)\u001b[0m\n\u001b[1;32m 588\u001b[0m \u001b[0mvar_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnest\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflatten\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 589\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_name\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/gradients\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 590\u001b[0;31m \u001b[0mgrads_and_vars\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 591\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 592\u001b[0m self._assert_valid_dtypes([\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/keras/optimizers/optimizer_v2/optimizer_v2.py\u001b[0m in \u001b[0;36m_get_gradients\u001b[0;34m(self, tape, loss, var_list, grad_loss)\u001b[0m\n\u001b[1;32m 469\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_get_gradients\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_loss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m \u001b[0;34m\"\"\"Called in `minimize` to compute gradients from loss.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 471\u001b[0;31m \u001b[0mgrads\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mloss\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad_loss\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 472\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgrads\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvar_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 473\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36mgradient\u001b[0;34m(self, target, sources, output_gradients, unconnected_gradients)\u001b[0m\n\u001b[1;32m 1098\u001b[0m for x in output_gradients]\n\u001b[1;32m 1099\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1100\u001b[0;31m flat_grad = imperative_grad.imperative_grad(\n\u001b[0m\u001b[1;32m 1101\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1102\u001b[0m \u001b[0mflat_targets\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/imperative_grad.py\u001b[0m in \u001b[0;36mimperative_grad\u001b[0;34m(tape, target, sources, output_gradients, sources_raw, unconnected_gradients)\u001b[0m\n\u001b[1;32m 65\u001b[0m \"Unknown value for unconnected_gradients: %r\" % unconnected_gradients)\n\u001b[1;32m 66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m return pywrap_tfe.TFE_Py_TapeGradient(\n\u001b[0m\u001b[1;32m 68\u001b[0m \u001b[0mtape\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tape\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 69\u001b[0m \u001b[0mtarget\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/eager/backprop.py\u001b[0m in \u001b[0;36m_gradient_function\u001b[0;34m(op_name, attr_tuple, num_inputs, inputs, outputs, out_grads, skip_input_indices, forward_pass_name_scope)\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0mgradient_name_scope\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mforward_pass_name_scope\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"/\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 156\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgradient_name_scope\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 157\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 158\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 159\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mgrad_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmock_op\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0mout_grads\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/ops/nn_grad.py\u001b[0m in \u001b[0;36m_MaxPoolGrad\u001b[0;34m(op, grad)\u001b[0m\n\u001b[1;32m 672\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mops\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mRegisterGradient\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"MaxPool\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 673\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_MaxPoolGrad\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgrad\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 674\u001b[0;31m return gen_nn_ops.max_pool_grad(\n\u001b[0m\u001b[1;32m 675\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 676\u001b[0m \u001b[0mop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moutputs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/ops/gen_nn_ops.py\u001b[0m in \u001b[0;36mmax_pool_grad\u001b[0;34m(orig_input, orig_output, grad, ksize, strides, padding, explicit_paddings, data_format, name)\u001b[0m\n\u001b[1;32m 5839\u001b[0m \u001b[0mdata_format\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"NHWC\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5840\u001b[0m \u001b[0mdata_format\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_execute\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmake_str\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata_format\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"data_format\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 5841\u001b[0;31m _, _, _op, _outputs = _op_def_library._apply_op_helper(\n\u001b[0m\u001b[1;32m 5842\u001b[0m \u001b[0;34m\"MaxPoolGrad\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morig_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morig_input\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morig_output\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0morig_output\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5843\u001b[0m \u001b[0mgrad\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgrad\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mksize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mksize\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstrides\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mstrides\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_apply_op_helper\u001b[0;34m(op_type_name, name, **keywords)\u001b[0m\n\u001b[1;32m 782\u001b[0m _ExtractRemainingAttrs(op_type_name, op_def, keywords,\n\u001b[1;32m 783\u001b[0m default_type_attr_map, attrs)\n\u001b[0;32m--> 784\u001b[0;31m \u001b[0m_ExtractAttrProto\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mop_type_name\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr_protos\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 785\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mattrs\u001b[0m \u001b[0;31m# attrs is no longer authoritative, use attr_protos instead\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 786\u001b[0m _ExtractOutputStructure(op_type_name, op_def, attr_protos,\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_ExtractAttrProto\u001b[0;34m(op_type_name, op_def, attrs, attr_protos)\u001b[0m\n\u001b[1;32m 341\u001b[0m \u001b[0m_SatisfiesIntMinimumConstraint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattr_value\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mop_type_name\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 342\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"type\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 343\u001b[0;31m \u001b[0m_SatisfiesTypeConstraint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattr_value\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 344\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"list(type)\"\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mvalue\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mattr_value\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m_SatisfiesTypeConstraint\u001b[0;34m(dtype, attr_def, param_name)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHasField\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"allowed_values\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0mallowed_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallowed_values\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mallowed_values\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\", \"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m raise TypeError(\n", - "\u001b[0;32m/usr/local/lib/python3.8/dist-packages/tensorflow/python/framework/op_def_library.py\u001b[0m in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 54\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mHasField\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"allowed_values\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 55\u001b[0m \u001b[0mallowed_list\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mattr_def\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mallowed_values\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mallowed_values\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\", \"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdtypes\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_dtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdtype\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mallowed_list\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m raise TypeError(\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "skf = StratifiedKFold(n_splits=3, shuffle=True, random_state=42)\n", - "df_grid = pd.read_csv(\"/content/gridsearch_params.csv\")\n", - "df_score = pd.read_csv(\"/content/gridsearch_scores.csv\")\n", - "gs_left = df_grid.shape[0] - df_score.shape[0] # run only the remaining gridsearch\n", - "init_rows = df_score.shape[0]\n", - "\n", - "for gsr in range(gs_left):\n", - " gsr = gsr + init_rows #if previous gridsearch results exists\n", - " print(\"Running gridsearch nr {} of {}...\".format(gsr,df_grid.shape[0]))\n", - " auc_score = []\n", - " for i, (train_index, test_index) in enumerate(skf.split(X_grid, y_grid.argmax(axis=1))):\n", - " model = inception_time_model(name=\"tf_inception\", n_classes=num_classes, sampling_frequency=sampling_frequency, outputfolder=mpath, input_shape=input_shape, \n", - " epoch=int(df_grid.iloc[gsr][\"epochs\"]), batch_size=int(df_grid.iloc[gsr][\"batch_size\"]), lr_init = df_grid.iloc[gsr][\"init_lr\"],\n", - " lr_red=df_grid.iloc[gsr][\"lr_red\"], model_depth=int(df_grid.iloc[gsr][\"model_depth\"]), loss=df_grid.iloc[gsr][\"loss\"], \n", - " kernel_size=int(df_grid.iloc[gsr][\"kernel_size\"].split(\",\")[0].split(\"(\")[1]))\n", - " cv_x_train = X_grid[train_index]\n", - " cv_y_train = y_grid[train_index] \n", - " cv_x_test = X_grid[test_index]\n", - " cv_y_test = y_grid[test_index]\n", - " cv_x_train,cv_x_test = preprocess_signals(cv_x_train,cv_x_test)\n", - "\n", - " model.fit(cv_x_train, cv_y_train, cv_x_test, cv_y_test)\n", - " y_hat_test = model.predict(cv_x_test)\n", - " score=utils.evaluate_experiment(np.vstack([cv_y_test,np.ones(cv_y_test.shape[1])]), np.vstack([y_hat_test,np.ones(y_hat_test.shape[1])]))\n", - " auc_score.append(score)\n", - " print(\"Score CV {} : {} (AUROC score)\".format(i+1,score))\n", - " df_grid.loc[gsr, 'auc'] = np.asarray(auc_score).mean()\n", - " df_score=df_score.append(df_grid.loc[gsr])\n", - "df_score.to_csv(\"gridsearch_scores_updated.csv\", index=False) " - ] - }, - { - "cell_type": "code", - "source": [ - "df_score.to_csv(\"gridsearch_scores_updated.csv\", index=False) " - ], - "metadata": { - "id": "P3NeuYETgz1E" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "kvnNlyCX5oSi" - }, - "source": [ - "# Evaluate model on validation data" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "provenance": [], - "machine_shape": "hm" - }, - "gpuClass": "standard", - "kernelspec": { - "display_name": "Python 3.7.4 64-bit ('ecg_python37': conda)", - "language": "python", - "name": "python37464bitecgpython37condacca13046f89242bdbe235da55b7380ab" - }, - "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.7.4" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file From 6232cb9fedc5b528134787195fee14759e768024 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Fri, 28 Apr 2023 12:18:21 +0200 Subject: [PATCH 45/51] delete GS folder --- gridsearch/Find best params.ipynb | 270 ----- gridsearch/gridsearch_score_all.csv | 973 ------------------ gridsearch/gridsearch_score_diagnostic.csv | 973 ------------------ gridsearch/gridsearch_score_form.csv | 973 ------------------ gridsearch/gridsearch_score_rhythm.csv | 973 ------------------ gridsearch/gridsearch_score_subdiagnostic.csv | 973 ------------------ .../gridsearch_score_superdiagnostic.csv | 973 ------------------ 7 files changed, 6108 deletions(-) delete mode 100644 gridsearch/Find best params.ipynb delete mode 100644 gridsearch/gridsearch_score_all.csv delete mode 100644 gridsearch/gridsearch_score_diagnostic.csv delete mode 100644 gridsearch/gridsearch_score_form.csv delete mode 100644 gridsearch/gridsearch_score_rhythm.csv delete mode 100644 gridsearch/gridsearch_score_subdiagnostic.csv delete mode 100644 gridsearch/gridsearch_score_superdiagnostic.csv diff --git a/gridsearch/Find best params.ipynb b/gridsearch/Find best params.ipynb deleted file mode 100644 index 28d290b..0000000 --- a/gridsearch/Find best params.ipynb +++ /dev/null @@ -1,270 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "384fcbe5", - "metadata": {}, - "outputs": [], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "import os" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "284c378a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "all\n", - "--------------------------\n", - "epochs 15.0\n", - "batch_size 16.0\n", - "init_lr 0.001\n", - "lr_red no\n", - "model_depth 9.0\n", - "loss bce\n", - "kernel_size (60, 30, 15)\n", - "auc 0.886827\n", - "Name: 26, dtype: object\n", - "--------------------------\n", - "diagnostic\n", - "--------------------------\n", - "epochs 25.0\n", - "batch_size 32.0\n", - "init_lr 0.001\n", - "lr_red no\n", - "model_depth 6.0\n", - "loss bce\n", - "kernel_size (60, 30, 15)\n", - "auc 0.87052\n", - "Name: 776, dtype: object\n", - "--------------------------\n", - "form\n", - "--------------------------\n", - "epochs 25.0\n", - "batch_size 64.0\n", - "init_lr 0.001\n", - "lr_red no\n", - "model_depth 6.0\n", - "loss bce\n", - "kernel_size (20, 10, 5)\n", - "auc 0.800552\n", - "Name: 882, dtype: object\n", - "--------------------------\n", - "rhythm\n", - "--------------------------\n", - "epochs 25.0\n", - "batch_size 16.0\n", - "init_lr 0.001\n", - "lr_red no\n", - "model_depth 9.0\n", - "loss wbce\n", - "kernel_size (40, 20, 10)\n", - "auc 0.91494\n", - "Name: 676, dtype: object\n", - "--------------------------\n", - "subdiagnostic\n", - "--------------------------\n", - "epochs 15.0\n", - "batch_size 64.0\n", - "init_lr 0.001\n", - "lr_red no\n", - "model_depth 6.0\n", - "loss wbce\n", - "kernel_size (20, 10, 5)\n", - "auc 0.877651\n", - "Name: 237, dtype: object\n", - "--------------------------\n", - "superdiagnostic\n", - "--------------------------\n", - "epochs 25.0\n", - "batch_size 64.0\n", - "init_lr 0.001\n", - "lr_red yes\n", - "model_depth 12.0\n", - "loss bce\n", - "kernel_size (40, 20, 10)\n", - "auc 0.895236\n", - "Name: 877, dtype: object\n", - "--------------------------\n" - ] - } - ], - "source": [ - "for csv in os.listdir(\"./\"):\n", - " if csv.endswith(\".csv\"):\n", - " df = pd.read_csv(\"./\" + csv)\n", - " print(csv.split(\".\")[0].split(\"_\")[-1])\n", - " print(\"--------------------------\")\n", - " print(df.iloc[np.argmax(df[\"auc\"])])\n", - " print(\"--------------------------\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "81ece1f1", - "metadata": {}, - "outputs": [], - "source": [ - "for i in o" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a8d91785", - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_csv(\"gridsearch_score_all.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "92f45849", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "26" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.argmax(df[\"auc\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "71f92559", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "epochs 15.0\n", - "batch_size 16.0\n", - "init_lr 0.001\n", - "lr_red no\n", - "model_depth 9.0\n", - "loss bce\n", - "kernel_size (60, 30, 15)\n", - "auc 0.886827\n", - "Name: 26, dtype: object" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.iloc[np.argmax(df[\"auc\"])]" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "780d4a21", - "metadata": {}, - "outputs": [], - "source": [ - "df = pd.read_csv(\"gridsearch_score_superdiagnostic.csv\")" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "d889f59a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "116" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.argmax(df[\"auc\"])" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "c82717f6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "epochs 15.0\n", - "batch_size 32.0\n", - "init_lr 0.001\n", - "lr_red yes\n", - "model_depth 9.0\n", - "loss bce\n", - "kernel_size (60, 30, 15)\n", - "auc 0.893365\n", - "Name: 116, dtype: object" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df.iloc[np.argmax(df[\"auc\"])]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cb50b4a9", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/gridsearch/gridsearch_score_all.csv b/gridsearch/gridsearch_score_all.csv deleted file mode 100644 index f2b70eb..0000000 --- a/gridsearch/gridsearch_score_all.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7863824497763839 -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8190563386183406 -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8181363021190023 -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7505600991244599 -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7880336409036636 -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8154746947664506 -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7981098204390205 -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8182684852209815 -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8174119749072202 -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7890123426608397 -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8073211024960784 -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8105281862362795 -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8072044339995856 -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8219151971739483 -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8208769699952921 -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7719755568009264 -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7963853479794768 -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8154424500137895 -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8768665534973792 -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8791675756320112 -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8798512300498107 -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8736329134208086 -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8826748109348131 -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8783904742358435 -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8851802420850005 -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8794909066211236 -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8868267284537089 -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8720892311716879 -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8768724302770609 -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8657906232897035 -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8829005424082653 -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.877862457567971 -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8867896703502075 -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8817933019760736 -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.875135969581454 -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8852737124528103 -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6869485870861061 -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6859953311019841 -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7054089920513751 -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6518848364440409 -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6486175626736054 -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6577968506555688 -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6654973215739547 -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7080256701687905 -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7271849920857378 -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6479603632821332 -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6484840382802277 -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6808321261134389 -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6712329721227688 -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7089061664603089 -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7196343280172846 -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6412975761990555 -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6692676661462557 -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6876385702393074 -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8448316597285114 -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8520848949192796 -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8594390025702277 -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8444167468119025 -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8466116109630638 -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8579586153436192 -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8479804633880237 -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8519610484928174 -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8551974049349133 -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8421328911778838 -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8566126614638515 -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8480709831163861 -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8542952796098399 -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8498848112989781 -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8530529888363602 -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8502960582204198 -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8549513021121203 -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8559107717392435 -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6158878929511561 -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6170393069481367 -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6388780383634183 -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6233786934764958 -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6329134537439843 -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6433939035056323 -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6286700666522074 -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6190720415318154 -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6364573568733669 -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6269273609856506 -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6453472952110634 -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6397865311819916 -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6379974682639711 -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6517260313819101 -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6491441410777474 -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6402116155283398 -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6279473834484081 -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6377503518972311 -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6996213442700561 -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7340152552041156 -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7582376554451766 -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6750085414763319 -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7012601821547929 -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7175086571083499 -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7187149696887739 -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7414139674221544 -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7493855242195778 -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6869281187462303 -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7012103463225942 -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7239392500521621 -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.723190166564485 -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7455175137212287 -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7445141117333874 -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6890199214990949 -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7064793884317148 -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7357739094904451 -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7511865740558316 -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7887880011558916 -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7980297216029673 -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.726772103492262 -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7450511123313461 -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.751795803282998 -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7585125979250713 -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7952799064166635 -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7759131686590527 -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.718038210621882 -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7586863812065395 -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7682930537495384 -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7518726611529539 -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7771227391350388 -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7905491802137581 -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7249083216934298 -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7633663385879718 -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7579819959561193 -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8719549204737432 -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8508180095598455 -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8500123537483791 -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8288552568268299 -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8469452040459532 -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8482482317709327 -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8399603936148857 -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8387605429208178 -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8413338108376717 -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8529976317229937 -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8475304207208162 -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8338563337703269 -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8272548683933815 -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8300600796662638 -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8345514607799106 -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8199442845768664 -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8281858288419324 -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8342866833376098 -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6451610701932317 -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6617919295858323 -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6586255633404166 -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.639021459662669 -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6281941837841444 -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6650512902372606 -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6391838901519621 -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.650690056113775 -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6821710616389041 -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6539333358435034 -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.63946352095554 -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6486301711501866 -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6427111205425361 -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6542618338403733 -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7012550470129045 -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6444874962151951 -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6483783663755225 -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6477514465519212 -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8114127760926665 -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8242245841702269 -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8271563928644353 -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7698364678026612 -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8114735608196023 -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8115030850459983 -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.812440257667697 -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8315572005853284 -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8314427084974932 -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8133176398941196 -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8283540546098788 -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8340147255340925 -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8366032110991958 -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8319669012673804 -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8400247159797418 -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8076867919240048 -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8229580292197465 -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8290351965530353 -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6469448505194998 -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6345579662244503 -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6267564855610125 -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6344528121319281 -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6285940115617952 -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6428355735052529 -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6458462132595918 -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6347855306495432 -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6395785984980316 -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6186579404806848 -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.636837340223408 -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6354240553392455 -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6290327189447473 -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6275747085664362 -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6420863440405125 -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6155888330162042 -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6191794668514591 -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6313506240511645 -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6643059099231211 -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6987491711314643 -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7372184452340861 -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6397978560951069 -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6519183364467517 -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6857052015438593 -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.690134198656304 -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7196834681829684 -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7416479543014299 -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6772874090617763 -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6799111595862461 -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6959826468242577 -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7035785980920579 -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7171766820007298 -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7378101165279348 -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6630838043351668 -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.692294456686623 -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7078523268473007 -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7167194567529506 -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7482063732884646 -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7526225798376031 -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6752024846792682 -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7183648529900261 -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7350970217101894 -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7302294338092649 -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7455688698478182 -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.756282941504861 -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.698459354561965 -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7152430410433782 -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7165863057458411 -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7205504566635476 -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7083974594223071 -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.746835213404597 -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6864205593660583 -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6906931856628417 -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7166322740433863 -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.845451528447157 -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8433004316999674 -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8382519997948469 -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8316189412097419 -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.855961035379926 -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8364676031735426 -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8358277274780354 -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8197397248534571 -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8211265184220475 -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8430590730516343 -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8557993284203333 -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8223589134155144 -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8501301070718825 -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8299108859649622 -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7988463693715987 -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8516645424876724 -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8386336459777114 -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8105787241035505 -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6431945042677834 -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6374023512620753 -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6636785628211145 -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6221794311392745 -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6350266782138735 -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6375874307651209 -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6452005477988134 -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6615195568809634 -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6628764334841305 -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.651524353830275 -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6414605271938819 -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6464088980265097 -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6538245189113214 -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6690232926883688 -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6824522321283456 -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6461915631463547 -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6243200736727726 -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6460219447922969 -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7800042470284891 -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7969654505769673 -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8134961557277495 -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7350233242533154 -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7695800031195811 -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7842246226584172 -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7834545690049325 -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8051788767912278 -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8149917951502482 -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7287386198126814 -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7770036683025238 -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7730739495208995 -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.772500042295794 -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8111250728028149 -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8097008225936828 -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7306282639955398 -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7796631674741965 -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7707681554133453 -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6139870958098438 -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6245979844485444 -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.635685573268426 -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6150228554851713 -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6630896341478505 -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6359122597375805 -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6447353283199518 -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.640939425080871 -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6379384783061767 -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6267840451387919 -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.619974645637232 -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6177186488953851 -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6338613767869639 -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.639674672031401 -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6238578864985492 -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.632520951529565 -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6208562706661619 -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6107326405247689 -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.654449727447128 -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6850035541091858 -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6927074568159058 -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6318105055777733 -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6543040831820054 -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6507424175720687 -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6644111482139979 -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6835908351901075 -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7090803148781286 -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6372498634842012 -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6427895559489278 -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6657919080770146 -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6694639400423422 -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7027327461280825 -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6980428674915587 -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6493800232758405 -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6598169201114139 -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6829360272744293 -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7559199424651695 -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7953243707690586 -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.817403228048001 -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.734141801841688 -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7605180624758713 -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7786957054968803 -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7807386270474922 -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8082718983929316 -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8081626632031839 -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7293341202933715 -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7612580214301411 -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.790861735392168 -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7663835778755801 -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7999683460963801 -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8159158783050389 -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7391138099007323 -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7714395689834391 -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7781770059548717 -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8370724147406463 -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8385880235602992 -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.84340450343225 -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8285143835594195 -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8341664743794056 -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8327247163694457 -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8360875563444624 -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8283121457086341 -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.836005279105037 -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8223185702956451 -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8332597561534776 -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8175230851178927 -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.835678540943016 -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8172978133018433 -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8259021724887421 -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8240112347584155 -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8119112637656586 -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8177888928706664 -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.640223377641524 -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.667574310562251 -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6696713729003502 -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6118592944906363 -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.654386810131538 -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6493980183571167 -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6544687878020579 -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6642935913508229 -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.681788023737738 -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6256235499187345 -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6464291597733333 -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6701961229186101 -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6416575643705427 -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6821630433880971 -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7040052405812359 -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.634660310416236 -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6411164932687224 -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6839098885421873 -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8227303722334609 -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8269936284751336 -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8346567582947501 -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8132494858143571 -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8297676471171057 -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8396492916978948 -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8230793491948827 -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8240899698712916 -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8313144407683571 -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8206328869806846 -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8334193604094181 -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8309497406838409 -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8241657464838773 -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8235472737205044 -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8084220726338569 -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8196919159572208 -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8211023091240565 -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8258559759721109 -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6434506319783491 -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6209910448917643 -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6409503356917952 -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6437133130940608 -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6342417813047269 -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6346144971093156 -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6227739117509477 -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6221361664363464 -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6494264134360807 -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6239552217760432 -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6257817248686893 -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6224554935322972 -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6352475688971079 -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6284267618052486 -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6481803320130483 -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6342334057490094 -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6547705077250642 -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6496661714089191 -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6908573578051529 -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7140317365052606 -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.735219428472846 -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6501231874622658 -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6782761224602525 -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7042183879020519 -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6976108450402596 -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7220758911064232 -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7438507265548259 -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6409158291104275 -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6962029696063657 -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7123397090483268 -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6838971882718031 -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.732211078132882 -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7467190453072226 -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.644161474118948 -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7043864553929281 -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.703785476629078 -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7277209304108713 -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7727935653785886 -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7790353008024655 -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6956009079328216 -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7338728913978226 -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.732590993055521 -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7447332469785529 -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7549189017159154 -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7847121113136432 -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7276166427219067 -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.738529821828935 -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7531893025688324 -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7524907544629676 -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.771587991805896 -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7742588213871394 -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7006533578240354 -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7485967600862229 -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7372014907348424 -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8345267256103104 -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.834679783658538 -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8454779630623429 -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8483233849862032 -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8508378015091242 -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8449272341246302 -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8375997943452512 -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8376070586507885 -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8382136418016014 -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8366557604424033 -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8283505189138843 -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8308207285101611 -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8303592241185077 -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8361257334180793 -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8196055033197469 -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8233655710041144 -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8251374848679774 -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8263715661063893 -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6119481192461622 -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6644318622548916 -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6738970019400708 -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6167316050173329 -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6494775453037508 -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6496456552351982 -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.657199152707212 -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6619487477850171 -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.666494892884571 -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6328394521599728 -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6101283324369037 -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6528247435396607 -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6558881566937994 -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6857173758911718 -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6882326343851198 -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6411355673096031 -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6448624334260306 -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6402951461695029 -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8331715983814165 -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8344783943923835 -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8335872848304772 -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8021333466818902 -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8297803434572099 -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8382061253399179 -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8226111641584181 -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8293962044146642 -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8243137643740955 -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8109234559517525 -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8340008917119038 -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8377971075418774 -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8087890435513133 -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8162039121388865 -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8096806890823863 -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8145575997156577 -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8297902195001359 -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8198826960189177 -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6221365473225715 -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6272744880446495 -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6361611890319403 -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6380104017695855 -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6217203706997106 -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6406316682271184 -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6370704339486463 -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6294678236881976 -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6295470269867492 -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6274987307309927 -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6247391360431378 -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6342575873392634 -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6354839501337746 -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6387016559853494 -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6399215984498905 -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6220272449510733 -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.630954178262114 -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6384200832642588 -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.678783751498413 -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7114057268305336 -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7240262123066628 -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6733612343418529 -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6515492747526515 -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6858521227994464 -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6736155490486947 -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7087793608417848 -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7250396564118763 -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6743638673654253 -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6868541961671042 -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.692055741339654 -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6833419054086161 -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7135667668987519 -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7352314970080153 -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6390643497055407 -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6834250106047319 -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6938408328557332 -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7090988480592921 -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7264127520703211 -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7596296559609471 -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.677906319213096 -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6931147643239591 -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7188187865862359 -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7057182691340803 -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7590308519306371 -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7556001191909129 -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.685371539152266 -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7146128314409917 -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7158671274355685 -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7119553622633612 -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7356359225625769 -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7429620675160574 -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6948709554233785 -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7219927504702318 -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7229586429874678 -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8359664436523588 -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8387707452000971 -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8415101557299295 -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8410035712915236 -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.857396175331289 -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8439267963737227 -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8349848136329054 -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8213601832373926 -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8313780697662123 -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8391873113796278 -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8401943089620406 -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8127436935459563 -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8424170998023289 -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8296450426755774 -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8201985353177129 -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8445568714382133 -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8530386231178175 -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8047808263237132 -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6356707443741128 -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6364931922907986 -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6596813176365388 -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6076554151050068 -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6363943410484856 -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.636877788687552 -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6373454777719553 -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6795403439878486 -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6723261980289394 -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6350040012631656 -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6456772245024721 -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6458385299832691 -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6479504402687746 -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6800929133995085 -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6693905581205021 -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6421524730164999 -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6463441460243164 -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6461336474601787 -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7865712745444983 -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8228236778200545 -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8189129418464202 -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7746949713613523 -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7978419731439083 -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8082929818857937 -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7838393317370381 -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8136577754143642 -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8235368077386479 -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7645730809806263 -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7914723957555044 -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7913781462349938 -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7940131804196452 -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8081723268371834 -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8100759903200029 -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7798196458828341 -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7901773850785162 -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7970906687122895 -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6181297278910057 -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6362002974365961 -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6335222411206148 -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6246513039881827 -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.623586294729891 -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6160759942495703 -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6435749516983441 -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6243105474190237 -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6228535589735208 -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6346240754828484 -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6534005446429704 -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6263319989094546 -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6326425665198124 -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6419929988265544 -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6146923490721842 -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6120457125089089 -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6370196448783939 -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6213498817311248 -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6612583303530373 -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6891785692558506 -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7143958192927699 -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6404187111480414 -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6546442433561765 -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6926373814037818 -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6703490616972924 -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6942439421250791 -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7068202477141011 -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6527641931379575 -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6627631661313704 -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.67532813675395 -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6708763076446201 -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7005818041171737 -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7100761096584387 -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6676363932464299 -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6730989049856632 -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6852464889635698 -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7677640902647495 -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7960412748085214 -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8103106084948936 -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7383231914876704 -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7611823078725016 -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7780167938592246 -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7754560981686435 -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7942022572025945 -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8028403166187289 -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7344154831788258 -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7664508553962176 -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7923436364425488 -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7631058458302542 -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8008350727187651 -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8029313214267759 -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.719759919080983 -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7825009377343441 -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7854426427030979 -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8345852388308805 -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8438527436854176 -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8486966289480482 -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8267592888844878 -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8324543184148548 -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8324987451553193 -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8210480751610602 -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8354027124960265 -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8198006216555428 -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8220783867573983 -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8143731194112287 -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8212914014520406 -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8126498860230944 -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8272013466372998 -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8256237923060253 -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8145321197005875 -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8089400651511843 -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8242682069530899 -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6394291103157848 -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6478860260240554 -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6841962757314012 -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6439058377308754 -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6546964424188042 -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6556455610192624 -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6516871064107176 -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6669757766737127 -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7002827626303779 -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6428327117965283 -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6473609858929917 -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6769239074426929 -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6412881133026898 -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6829440311498821 -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6947580070969259 -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6395622369338464 -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6527349481012925 -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6582911242775417 -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8282637877865419 -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8342767472698923 -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8342926770338449 -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8252861361811941 -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8254039572752278 -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8283229414889833 -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8289361008615049 -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8420458167272029 -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8316434344479205 -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8190213308869642 -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8369920478939398 -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8247243260759425 -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8209556951405514 -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8192277276647699 -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8353714579822112 -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.824150883934534 -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8392572880934389 -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8225041008133759 -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6119128103442631 -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6403831422837113 -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6229837651424476 -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6275405141105682 -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6396147795695118 -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.641328448570799 -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6280047237001981 -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6437021119131044 -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6500650346834156 -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6421182417111746 -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6373871574525927 -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6408382693925744 -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6396782704816877 -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6339079102733848 -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6238803773862172 -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6221184218014506 -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6291667591400126 -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6520951806341184 -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7038131407727288 -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7262781059478726 -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7459732595989598 -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6707729753900215 -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6849106602364067 -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7123230753392923 -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7253202707904522 -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7459577685379406 -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7693571816939051 -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6741605125535859 -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7048888717418097 -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7269227949112539 -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6988088542787553 -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7395687509161396 -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7714062765200013 -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6777687803100342 -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7041655558788085 -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7293709719603668 -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7401065797388675 -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7606728632497218 -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7849618642053652 -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6970330202154192 -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7356881513605286 -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7397524784506083 -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7505252327247766 -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7834229873071238 -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7929259145721783 -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6958668457270277 -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7310057761511182 -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7622286666567076 -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7469421138058503 -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.784701329893012 -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7717410695887784 -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7125685141552217 -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7194103706091574 -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7277289475256249 -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8379278286022358 -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8396737347439015 -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8443765754015908 -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8294756653999765 -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8328426538656197 -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8317386748157004 -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8345543726476201 -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8456109701594618 -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8393304062897009 -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8242713614464128 -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.83124559040162 -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8180250624491346 -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8249917868447966 -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8334768872222912 -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8289201779325529 -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8388974194422132 -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8281137799526667 -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8337212628540286 -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6289251750994866 -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6547971401718331 -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6810902294502362 -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6230190889662265 -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6537328272187471 -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6429087640652237 -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6453841506916244 -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6545602859817374 -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.693583005765852 -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6281413918065226 -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6416312690513327 -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6559758533304337 -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6446058695951286 -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6846411285246861 -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6906088400374549 -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6408019876024468 -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6416137822459987 -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6439109237647768 -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8111551717823874 -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8342659066009802 -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8277905224981765 -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8219089459564278 -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8398829279443026 -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8432532055316261 -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.834493164558307 -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.825820001025495 -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8248701378787829 -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8318555628497574 -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8323541564741234 -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8329003017774799 -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8202769964117861 -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8208225616523915 -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8242950490562991 -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8362120569902814 -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8287503572355003 -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8233471128976745 -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.621721974771217 -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6434559585606309 -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6444394571371436 -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.635643153813689 -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6401118993838182 -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6333040269976163 -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6375226949873586 -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6398257829781436 -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6336959421525712 -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6185105660368698 -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6358714568262952 -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6317066479947328 -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.614119337827678 -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6178732409594377 -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6255688515808621 -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6225939737551079 -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.636626173037525 -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.637715328123244 -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6951603281769202 -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7070830285520291 -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7434382049622276 -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6350470364743751 -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6838911141614404 -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7010790710763942 -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6919388338305058 -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7265148854475733 -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7535487511356594 -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.660111056376413 -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6904378362616047 -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7133153466602505 -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7029777853925601 -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7330335778767632 -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.726228517877689 -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6676776999336895 -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6883587094815882 -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6983349723061522 -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7030724703602013 -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7208149884155262 -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7489274179816924 -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6917422838741887 -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7046902019041502 -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7287451385549547 -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.734408300474562 -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7308020501973074 -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7585614647136523 -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6818432519345907 -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7105017354389482 -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7363186519218573 -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.719715928057942 -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7266615597032008 -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7461401457599123 -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6793832012453929 -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6925191556550229 -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7051486488882371 -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8445285233982447 -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8435720597924171 -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8254115719722153 -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.836378419600324 -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8368671282469057 -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8321122759357591 -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8521450700204237 -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8298067988470983 -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8235703755072726 -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8229649458508131 -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8202107795297521 -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8310890277644051 -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8408726650798256 -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8266716202388175 -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8345195167441228 -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8325129540994297 -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8145243891587922 -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8242244886146523 -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6523916599611871 -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.656462986773982 -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6627719707482004 -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6189836543603386 -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6290845859641211 -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6532185859901594 -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6491422160677859 -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6692630171368591 -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6770308103228105 -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6171795231477254 -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6413249633313308 -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6374238902705649 -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6512908458062358 -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6639511434955533 -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.670413771021625 -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6509929412015018 -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6250434503016119 -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6332139886348194 -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8054234027328103 -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8343347722790648 -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8239268476982226 -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7911927260854467 -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8075158533875731 -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8131828686523476 -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8143731730421279 -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8289234336968591 -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.799275530697375 -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7946300106316128 -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8134747974026073 -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8201858049519087 -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8058423993832758 -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8192038107656522 -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8058102685375267 -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7752265491324176 -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8092472397685362 -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7992786999034478 -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6317483636349666 -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6301045368823048 -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6394049401114651 -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6129550744903659 -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6266665551531779 -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6287132239772258 -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6212921690190637 -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.619562212560397 -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6490082056597446 -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6272594680861222 -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6273602688131535 -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6262672826813557 -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6391859596582666 -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6250120115602794 -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6334937088109288 -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.613772577633935 -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6281276700981523 -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6098928675059503 -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.657200010119767 -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.708972114885872 -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7283789387042231 -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6588892025751499 -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.681337933929458 -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6878619172290638 -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6790786037774258 -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7082908793712227 -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7264362413248932 -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.636570397368367 -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.67821830535122 -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6763692060317711 -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6781072788729495 -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7023352395317651 -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7217055588226723 -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6719753426605788 -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6798010679945964 -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6979701524714482 diff --git a/gridsearch/gridsearch_score_diagnostic.csv b/gridsearch/gridsearch_score_diagnostic.csv deleted file mode 100644 index d0c7caa..0000000 --- a/gridsearch/gridsearch_score_diagnostic.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7722236585456198 -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8091926515880186 -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8145831159804523 -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7360905085544135 -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7808003658296991 -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7914176961030076 -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.795159757975477 -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8070248881095899 -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8158954608214765 -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7633790911564153 -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7958860868011772 -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.793317040310503 -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7841049828718467 -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8261557686089217 -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8050293509403529 -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7598284168007963 -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7853155369187251 -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7745264097374226 -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8450734380629777 -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8477453355881591 -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.856750057839689 -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8313281728753935 -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8459541014104267 -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8358238586300989 -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8235986829971079 -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8414018104712438 -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8308804999253588 -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.82886864775353 -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8308400805034616 -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8346083793501435 -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8273421361862111 -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8402253151325073 -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.840361125785465 -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8242793443532271 -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.832698340065298 -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8330229118647597 -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6506607488124502 -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6522395375957902 -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6952049463484024 -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6300674716038083 -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6482654249889651 -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6495419316553147 -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6358426478218919 -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6625606419243181 -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7181659480605019 -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6362524443078763 -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6387411231040213 -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6588010600154983 -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6470330578811921 -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6811940659937125 -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6767543058403978 -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6334683454247925 -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6685811988494837 -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6766093607456828 -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8297841201336912 -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8323754402727223 -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8357231368602162 -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8052457820445037 -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8295706473882015 -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8409475184254998 -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8324144777064831 -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8349183324640954 -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8343611825408761 -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8302551226957235 -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8551413409017673 -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8550110527897951 -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8398105153724412 -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8439956870054042 -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8462793290908422 -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.818654206132812 -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8499670446818172 -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.839014353793441 -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6364332676877122 -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6191182198001437 -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6443952962007441 -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6123347508139134 -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6319630352855066 -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6501443817108856 -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6271923426288857 -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6078315857443853 -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6451460464906448 -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6332510751175261 -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6201097051075525 -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6339082084345434 -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6294170439043234 -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.636084047314497 -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6495692529036736 -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6118555660517643 -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6260788405988001 -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6068817766342122 -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6751008569396136 -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7000095039506089 -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7100044639051363 -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6441031248271488 -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6742590143111143 -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6872369730720326 -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6801902251996047 -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7178809846521824 -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7380885840615465 -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6524905838771379 -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7057063209308757 -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7135700939242572 -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6869209437395201 -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7407874566368745 -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.73295599643583 -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6792492600413448 -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.689430991993441 -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7118310594261633 -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7502654209186143 -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7737314791350517 -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7857634011703897 -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7254357800355754 -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7527348412909949 -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7502198826381473 -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.756995943332415 -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7892645660729164 -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7851475371837949 -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7168615394965 -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7285680306112178 -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7520953532994762 -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7546416540491508 -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7920770531570649 -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7708921696203729 -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7241325908967983 -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7594476998990277 -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7472805879798617 -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8600041620525527 -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8635649866123671 -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8616439561914001 -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8430581977435779 -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8442747299579524 -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8392219787148613 -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8578102429266784 -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8542099398338268 -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8389713860995793 -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8411563645034604 -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8436586636596707 -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8456841352128368 -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8453048419456355 -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8541716242245214 -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.852821999411077 -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8568704390789817 -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.84746780596751 -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8250182496044519 -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6329339579193853 -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6958273499191554 -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6695871307419258 -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6395700953082142 -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.656217032503556 -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.657168500145816 -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6600000170641839 -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6886976653712376 -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6800600573086154 -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6513038222602462 -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6533946983626467 -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6465388779270963 -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6624506395054836 -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6625922064741592 -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6942803234166117 -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6302332148135943 -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6655574495669906 -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6651174589951218 -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8208651366105246 -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8450219624169986 -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8413137579179352 -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7910833939850038 -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8356304372969955 -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8345310803810563 -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8153322506294632 -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8415615101411782 -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8449167359671085 -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7998036072521889 -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8300938732954347 -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8328854944190924 -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8214745434775007 -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8386253282570406 -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8296751167859523 -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8055279515110384 -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8296066051828784 -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.832622666905754 -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6243291231013154 -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6248790028715931 -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6182039243302784 -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6141684647363982 -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6221228176871264 -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6189115364987375 -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.610235553775938 -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6136108983568526 -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6302240451186555 -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6399595445343785 -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6214580894116353 -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6263543360353508 -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6425676675267823 -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.628461975147853 -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6325313234265778 -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6137196666734057 -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6266038705016653 -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6410717137063991 -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6820799412136211 -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7176710797044641 -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7290676959493405 -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6427296518900804 -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6838280206670682 -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6771025688158671 -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7005241326604469 -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7041227625336418 -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7429686369983363 -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6442421903533432 -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6862649630417531 -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6986773855401908 -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7049842883794261 -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7160639447374034 -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6979764261516737 -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6536274477239875 -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6743667727386393 -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6877588337638866 -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7270266321553273 -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7488436499404664 -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7634590882203107 -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6742037347776259 -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6953465202409822 -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7118231681510864 -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7495685394453186 -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7519935802981049 -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7633986144968343 -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7126629386317331 -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7058404365650993 -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7463298112817004 -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7173162080827042 -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7416868996272535 -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7635156272833145 -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7129236193092119 -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7009851191358595 -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7301816160539824 -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8545238852752323 -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.847962450340033 -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8464175794585881 -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8543512490261956 -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8641754907304079 -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8413805627158512 -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8476135691632173 -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8442037197020514 -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8226386186054513 -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8549521599839663 -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8647585558769615 -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8574271998861369 -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8603227960291818 -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.841256009143763 -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8254861973895937 -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8628903381657377 -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8465621005455701 -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8324086989193642 -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6416430767580467 -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.661079407048624 -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6486451207008582 -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6263415689243955 -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.635590910401623 -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6224453067841793 -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6549591879141277 -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6802283178503582 -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6912504070984857 -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.634485614888267 -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6186927157161327 -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6618402366652568 -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6382849425316346 -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.667682135526135 -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6715183834192467 -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6461399011162522 -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6244916879072732 -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6241752911348427 -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7657646865283353 -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8209938765813862 -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8151904111268973 -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7577071088608748 -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7659119759464965 -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7906511062453984 -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.786592594577412 -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8193406215151747 -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8203450592796581 -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7594538855371543 -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7961055505757737 -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7926307371840853 -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7681050102904914 -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7808438670139336 -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8095227727471705 -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7624924486433935 -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7858148451742523 -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7921631460998905 -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6281941147909991 -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6163620674117216 -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6439573210018835 -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6165349536022467 -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6060054091924107 -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5991817802405567 -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6136015876727992 -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6296985416853348 -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6505532440335124 -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6239037278408959 -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6302205321963498 -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6340589108678863 -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6250490107788739 -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6119095155492641 -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6249947528220952 -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6161478041207278 -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6314671452037598 -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.634691011528149 -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6601124679143067 -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7046762146260767 -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6893076062430912 -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6435054399806629 -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6726290133317381 -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6794274624020747 -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6742156338786581 -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.695424844416602 -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6949693981415134 -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6575209578566067 -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6737653903324933 -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.689295576355201 -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6815327732678823 -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7258612943749787 -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7198226919057276 -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6580525318705646 -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6622946891589011 -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6977489078168433 -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7655453887276957 -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8158181131131311 -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8112037776033193 -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7458928170118225 -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7712296430915995 -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7793462867878653 -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7915380339240307 -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8035723224760959 -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8063897719051517 -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.765867014399455 -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7922734968126445 -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7890183924921771 -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7899063363989357 -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8167097963666708 -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8002598180931199 -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.765543423187239 -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7751521415502758 -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7877944463775298 -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8425509973227866 -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8474498829431457 -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8434919251750816 -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.824557923530222 -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8354484691024284 -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8362328400456652 -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8344164545532676 -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8494248946578281 -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8361324501644759 -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8226310635465977 -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8196426704315013 -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8259607108790042 -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8335426242313408 -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8395626422232839 -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8454371340271245 -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8199098517284256 -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8391396642508498 -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.831995204540633 -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6308363450905471 -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6825938225375513 -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6723980599570843 -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6235431379359078 -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.639994736876136 -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6598942049323463 -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6372745550178988 -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6823058242036765 -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.698923079866392 -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6358957099631674 -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6567740962061696 -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6661886517570412 -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6481340096242155 -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.653257993730065 -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.710809216976206 -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6556226714676004 -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6544194294022211 -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6696112066564344 -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8275829160561746 -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.850211757075733 -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.845740672501872 -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8267776949683467 -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8424375851541209 -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8528350573688726 -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8376281167414529 -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8446299282132284 -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8446777256409054 -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8277303013952926 -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.863615265471 -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.853531941031663 -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8390682223829855 -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8327154633638122 -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8246480275980629 -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8305840214588486 -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8478887946271838 -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8371926204221274 -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6199018520272821 -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.623498769046706 -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.612494575804892 -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6114290161134667 -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6222575929894737 -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6383560423270143 -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6332442992659165 -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6445208594151138 -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6311475382503118 -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6407475144957093 -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6336045717246076 -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6254712344801264 -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6256572004530483 -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.646111789996255 -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.646893946953439 -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6165171282917132 -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6202029571585476 -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.62887229171663 -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.695370084266921 -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7287769888280405 -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7427510791953688 -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6601259002034809 -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6906818105636118 -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7131581409540743 -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7200614551318071 -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7295255215170582 -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7475919796195457 -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6770899585510768 -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7220649696499112 -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7182216533842603 -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7176285338556974 -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7400709734422378 -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7553436254098364 -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.674966775212298 -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7007252076317285 -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7280900456783672 -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7330601332039114 -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7620410984112859 -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7846149121279163 -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6871086506122687 -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7267326123922304 -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7600269078669503 -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7510846497356406 -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7923849813174152 -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7940111413344514 -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7060735476936738 -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7588881410991529 -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7549246154888422 -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7506191075052451 -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7746586077984534 -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8060596471299948 -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7239092331750117 -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7403729439327692 -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7286944277264839 -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8541108911865162 -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8610381794494817 -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8578149674472062 -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8446150402917446 -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8333703518189007 -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8420122519621612 -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8429582645743574 -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8497495439701767 -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.857076161545829 -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8385257441966351 -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8387023307164195 -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.830871304116673 -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8574837827292043 -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8553930794218174 -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.844204061349667 -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8365172400442141 -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8333557783884434 -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8399684884310097 -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6532955816138432 -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6931351361032481 -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6982058789200812 -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6178366681818731 -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6433178050924242 -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6574578007331957 -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6533316264372251 -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6798267953999112 -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6800741685692993 -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6506187460185825 -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6353110048055387 -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6639670442961249 -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6354360355310456 -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6523541758546503 -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.693107143410713 -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6307128181988467 -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6614988145535147 -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6801202129313179 -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8253511736915802 -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.857860161060545 -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8581778382767524 -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8125985764728005 -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8392645669455594 -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8478098533192039 -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8446942264178386 -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8479366726364986 -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8525224652559239 -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8233268155351894 -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8384164288560624 -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.848470100974663 -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8410253229952156 -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8428384500974953 -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.841762290161554 -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8323378657126049 -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8268948935584822 -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.834425246947042 -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.619423311686715 -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6253695511119095 -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6413517145731927 -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6262943631053736 -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6079423293757595 -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6153058460133138 -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.599654238550965 -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.627163527158773 -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6486836502571882 -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6326615844026247 -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6165087341347307 -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6188308220224011 -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6331055289795872 -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6266683949420756 -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6561817257468708 -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.610481800136836 -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6272150125996192 -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6306923718812717 -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6822833327060674 -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7245288190917698 -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7400490141005194 -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.666373427418544 -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6939650542809072 -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7005274655228604 -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6997849365718268 -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7273660944042457 -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7523101605461279 -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6817302921107489 -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7133722950972429 -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7263796293221283 -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7266834519955309 -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7244501057991742 -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7294209312066963 -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6877157866276598 -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.706746340008742 -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7083629549855877 -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7259018844639297 -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7265133783875136 -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.744092920484762 -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6630466931757706 -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7234946718977017 -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7415858596782069 -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.729515035958435 -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7322593918526451 -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7793977768794805 -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6730438890690372 -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7024073623639744 -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7177840085841357 -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7285868539549804 -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.735982381906504 -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7295622559859152 -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7229653617857065 -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6959556937715298 -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7265264558762055 -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8501743188462122 -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8634070533200946 -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.830733784320302 -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8520125367551143 -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8414652683330105 -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8373642289024511 -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8521647229866306 -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8581841755049368 -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8168685834172336 -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8541875984844433 -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8447462153583606 -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8343938746164209 -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8444422019108336 -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.841763003004198 -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8332180028308352 -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8347149171459854 -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8283853003232036 -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8367224779822052 -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6438249239712738 -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6510312002599158 -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6641281645368057 -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.647138016728109 -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6193487509393409 -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6575401204087418 -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6202268213894128 -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6657390765116306 -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6697029093540433 -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6371894308335008 -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6461703454635762 -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6471793153817935 -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6541903219905046 -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6820354449418325 -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6886456079419628 -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6295321154717305 -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6633651929792622 -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6538859930322282 -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.817343623493616 -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8205989864719548 -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8331059020248913 -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7754582929144953 -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8115682720113866 -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8213600673534361 -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7948101600983563 -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8176213952598593 -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8295371088461829 -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7840646087198349 -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8242591214505796 -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7992074486529946 -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8045398480119085 -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8196143725307382 -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8213532259031523 -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7689003216464382 -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8013314391044282 -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8032224326802706 -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6387639046903064 -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6262915349112337 -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6363800449062106 -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6086640746048174 -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6155843725941715 -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.608868401982782 -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6183990779580145 -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6310145669176105 -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6361102364522505 -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6373146178731575 -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6131411346574107 -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6348531116077294 -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6413217334854814 -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6378616546041305 -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6352113898462395 -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6068367723876045 -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6199298892580174 -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6211963060347997 -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6780354533598082 -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7036408094544281 -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.722104801839491 -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6644161971009691 -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6660529077671381 -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6979254820998527 -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6847119488698731 -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7057409586792603 -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7223390810723448 -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6531223372965238 -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6804089546396969 -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6824016407704399 -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6808503224117041 -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7111485461840035 -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7154936890919602 -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6447623065337059 -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6696952510781417 -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6836151808881835 -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.774578174708706 -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8103548417359576 -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8056097295981507 -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7498989072079709 -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7725125973340368 -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7883251888226418 -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7977966065773511 -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8013210539198637 -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8095878611175745 -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7625559926333402 -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.774613293970518 -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7870292935382223 -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7748450304021159 -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7961243112033657 -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8160178981758173 -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7653066686639853 -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.772747021673811 -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7896094075738179 -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8413270776519943 -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8474889257890436 -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8369910886868775 -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8172241723972323 -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8287115504158352 -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8408846156027043 -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.839086080608896 -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8479902091534885 -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.851396592560539 -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8436042487739871 -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8155891544278028 -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8475175646316299 -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8447292994031441 -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8393827547903677 -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8452821342925848 -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.846908896781959 -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8343762058724545 -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8473488816257554 -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6385135921242716 -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6739121049467296 -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6946236281118816 -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6295172989171725 -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.634314074883645 -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6584687920158792 -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6331172411332989 -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6685706105896423 -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7148169982397187 -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6467588048733717 -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6407511936465621 -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.666270003992938 -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6605864883715835 -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6880699360332797 -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7054005277277641 -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6541369308863381 -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6605883276061125 -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6665010312636777 -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8399850678009692 -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.848302030396523 -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.837204095296323 -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8311397303855438 -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8491588413226717 -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.844578995024139 -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.841319391544288 -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8395523050780117 -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8488595129843265 -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8303535064837259 -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8536807746887792 -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8366142282496277 -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8222463764930475 -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8358176904872564 -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8332016064681325 -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8274110691972041 -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8398685513225765 -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.822332639258535 -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6069586566848503 -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6170254080284638 -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6292084715632059 -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6116860676221998 -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6362166252311297 -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6348383850185336 -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.619875409291451 -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.62611388718717 -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6589961809042901 -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6212452532019683 -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.621992545904804 -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6100984540151829 -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6164528090827194 -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6282160111279677 -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.640055591537439 -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6389901989680195 -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.650849219763845 -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6229926463859883 -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7084430700779096 -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7373117313437131 -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.762756920470113 -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6725652930739313 -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7021932524312585 -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7211526448302389 -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7230714671915242 -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7637584509396881 -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7677930230608673 -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6886994123528885 -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7226317158998228 -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7507511388618022 -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7192997067402107 -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7290039726318648 -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.762710135961241 -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6871926514120296 -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.733486442057965 -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7368674068694262 -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7539297669719551 -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7830213671688343 -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7840859607415616 -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.701998117745357 -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7298655509989823 -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7718272677673231 -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7544093307819738 -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7905402852325318 -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.785771276371563 -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7146906901164751 -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7587271308008829 -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7742604845661338 -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7645978716674939 -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7753376767830873 -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7995743876048301 -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7276800160436769 -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7534301192781371 -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7692864636193013 -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.850686534311461 -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8560805211160512 -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8705203372555985 -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.85009464146072 -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8465727793713054 -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8537846384695728 -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8442482586983374 -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8434399648145728 -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8451884024073362 -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8408853544837364 -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8424803775982883 -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8513239316401968 -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8413363597578846 -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8403235124033953 -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8489940323345425 -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8359642053231151 -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8250463603332655 -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.820540883364845 -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6626508276423699 -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6536518664564617 -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6886202023581912 -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6491148835714317 -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6621305001380872 -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6669979638371671 -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6596325347730659 -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6778488795391615 -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7016336198644462 -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6320255917357819 -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6458102287954569 -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6656560339595884 -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6539298050073574 -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.70097310880655 -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6967794247259387 -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6321751791565055 -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6562136525427995 -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6603001748673529 -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8457449730404396 -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8629425381204975 -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8411052636821124 -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8356465310923635 -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8615942614725453 -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8568315008914426 -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8482334026051536 -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8452424692808633 -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8258562337578015 -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8561649386921765 -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8574999364309105 -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8501114045816379 -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8190942014422825 -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8303170435161586 -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8239210650588281 -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8426486617047249 -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8475942439176248 -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8498649104157324 -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.625898361658079 -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6297607877355517 -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6385945796422613 -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6161835682207909 -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6131157759917537 -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6335413630524341 -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6399697748962199 -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6325317229489928 -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6212391375362835 -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6372647164699083 -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6139758337004576 -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6214359962091794 -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6169406515673727 -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6441563361359645 -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6403418083402521 -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6139648773699006 -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6153050504737047 -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.622325353222084 -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7054843596255763 -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7448210726457981 -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7657611357721271 -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6742528396496651 -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7011589753247193 -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7138794518697669 -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.719440206837842 -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7381012377110786 -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7526820833119245 -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6752530019379307 -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6858168503323162 -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.730575126848137 -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7142629088742726 -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7688376579158475 -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7252666123196997 -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6841689587633293 -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6925099278347796 -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7239657102798054 -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.708969477240735 -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7326169752460627 -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7557367655202004 -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6817450276444893 -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7132667894381203 -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7284604793476387 -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7346547382675853 -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7542268707441983 -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7451193944035402 -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6903862636314239 -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7336111930374115 -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7389306454899969 -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.733677626662201 -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7644851302999239 -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7384559744675046 -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6886573714351741 -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7274144595700957 -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.717504454874522 -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8604266344288884 -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8498953168324789 -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.837765296795661 -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8508959471599561 -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8463876296250411 -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8365525628015549 -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8480848938815261 -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8376681102525979 -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8472892245956144 -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8369249824761112 -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8228667222687859 -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8372908741730193 -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8490980750968276 -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8387969767868645 -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8447451272345065 -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8357762272586613 -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8184207993568582 -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8143404171248892 -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6218731161650831 -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6463461287751998 -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6636881010974937 -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6377028119988081 -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6116266059115981 -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6386971987429416 -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6475528357075505 -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6763949717706234 -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.662915895816553 -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6332928810763404 -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.655264412269886 -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6543952532265319 -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6526278980224682 -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6551474782317952 -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6630143829458957 -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6312956862629818 -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6476740659461261 -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6446016168407006 -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8190877839770287 -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8350906983533029 -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8261130467912697 -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7901723520312135 -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8125138020975031 -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8295808339227184 -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8239678828578881 -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8180104754793242 -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8398616568763585 -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8368704075520008 -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.823661078136551 -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8367794901142558 -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8099428613480466 -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8260437645821916 -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8273082284386142 -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8031815409166896 -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8231076503860525 -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.806270693175647 -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6170983272479946 -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6322430095614017 -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.624019540158033 -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6107348264232637 -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6280439292037734 -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.635249118389477 -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6315824455535424 -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6035016777246555 -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6490821374804958 -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.61675666786601 -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6462352425839181 -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6186893538472845 -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6332567745653854 -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6280780717928026 -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.640995272442451 -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6174161416857412 -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6271880904869019 -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6207033694731554 -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6701183027582859 -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7094835976257476 -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.72393349424181 -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6697388143095518 -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.652240613822512 -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6922694982257654 -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7008790554534895 -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7049958238868639 -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7481354498406088 -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6484036981970913 -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6915381549487277 -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7012133276848628 -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6849299446714195 -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7292457746778477 -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7162998285111021 -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6596425226802988 -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6729637011851445 -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6985594954475526 diff --git a/gridsearch/gridsearch_score_form.csv b/gridsearch/gridsearch_score_form.csv deleted file mode 100644 index ad0faeb..0000000 --- a/gridsearch/gridsearch_score_form.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7160387950580872 -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7144788277230424 -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7299305547923088 -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.703111626173614 -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7146517412933583 -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7228458154752623 -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7163011257820728 -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.737570339125584 -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7394453900717924 -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6954147848463883 -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7204760464503567 -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7212486276501034 -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.703053140142894 -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7226220629547323 -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7103744088723009 -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7071765463310385 -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7215614019305564 -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7127601148014676 -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7558305513476992 -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7564449596744863 -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7672228945840186 -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7509187164192715 -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7661874445789488 -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7571355239133518 -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7756448306301601 -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.768445975966749 -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7574650192530444 -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7718464579812792 -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7638889418309538 -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7391723004701806 -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7566955163359316 -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7437789169352108 -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7602376661952507 -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7488406536453255 -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.753180155749717 -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7655449799284133 -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6487960147974497 -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6436177167449721 -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6762632135070482 -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6379234175710824 -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6285276186187928 -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6472131268737238 -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6483304269741791 -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6375063245371936 -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6562166656350847 -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6120442932590046 -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6351322741296026 -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6590284781991179 -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.634584933415101 -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6669115339610764 -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.677572718675099 -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6058128313392466 -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6312311937689855 -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6787999799504284 -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7655583575639403 -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7580444242567373 -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7640188734498441 -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.76081766258558 -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7672324816556957 -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7674119183651116 -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7676945532727938 -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7672833759575859 -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.754827223154232 -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7358401090687882 -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7687781385100182 -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7576726781644497 -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7548615942157544 -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7590523389510505 -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7416226505596115 -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7470269640158919 -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7526527993215631 -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7479642119309456 -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6068437772784668 -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6026471767623797 -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6240853146716069 -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.629363725085479 -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5787990319214243 -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5959522021540171 -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5964494261035104 -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6395864058914462 -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5962725549227254 -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6078568944294828 -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6070626317224673 -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6152501390845817 -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6291500189005409 -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5972752897354127 -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.600319317681044 -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5952597946670883 -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.605383815657354 -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6124337065957047 -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6882747859970099 -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6963294879303882 -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6965356674151276 -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6410631619358592 -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6552406876869387 -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.654952575429482 -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6534001890572241 -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6933746538294431 -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7062963293197674 -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6689497664172083 -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6695025497615165 -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6807515678631862 -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6733261472413584 -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6970907185793099 -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6932425324641632 -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6557974660229081 -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6479181117828735 -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6351737729985921 -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7019764420967749 -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7305452903260886 -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7384794390351401 -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6756240434999118 -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7066393700074519 -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7092547551066958 -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7095398995060714 -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7190115071175862 -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7344836412933091 -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6881061486700187 -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7221315664716202 -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7321037533722773 -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7136139445162781 -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7109234420909125 -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7217525290861447 -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6992300765418841 -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7059187595469005 -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6785993791662919 -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7786696710148906 -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7785322314543236 -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7770998601573513 -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.78670487506534 -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.773452757110579 -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7739285794955787 -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7801450201369272 -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7837513626017211 -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7755646716211572 -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7753195045053761 -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.77067950715408 -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7435233817857142 -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.770644034665175 -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7565015380540965 -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7535181966948782 -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.765800363305682 -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7657827114228635 -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.749156580691165 -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6527842730173239 -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6618692538559602 -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6754637895948568 -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6028601236939637 -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6283626866643379 -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.661428341980027 -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.5976215988792323 -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6835220823742807 -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6718915607146778 -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6231120281096749 -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6441151360456068 -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6376792217119948 -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6450468761880113 -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6665466052274437 -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6951305536729907 -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6418657360196639 -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6476857352684928 -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6480578891987511 -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7522931150825972 -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7623802877633574 -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7774891581643764 -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7346677209758313 -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7613846494618342 -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7398521810326756 -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7578649578390397 -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7522294216729204 -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.774077110796124 -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7220479446541824 -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.777382961696246 -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7509936910515459 -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7628232046595506 -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7525075908432278 -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.757873203979111 -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7194320882599569 -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7333689536991366 -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7372527613631993 -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5834789580176408 -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5990807109563424 -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6340293401072593 -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6365124614663092 -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5940914627160931 -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5995730979038502 -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5824941031227236 -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.611054417746321 -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.593732169295296 -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6102962424648715 -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5860931438213725 -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6364356117518694 -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5825620073219792 -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.610948135772343 -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6133579594958313 -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6123311610405925 -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6109244390646932 -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.634354447834824 -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6625669297517577 -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6781418968484756 -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7025314342968206 -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6387037741593651 -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6568792176009125 -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6672335549020008 -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6725585135230426 -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7049317421476986 -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6951952434594578 -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6419979763603703 -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6537043912031972 -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6677731937862661 -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6709720112246131 -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6760068293783821 -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6835140181110191 -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6623589160825732 -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6689159263072133 -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.648745572144844 -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6901929485509787 -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7117703278386466 -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7203994400972761 -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6432736373545418 -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7042027954099602 -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.6852238106633052 -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.706091161958169 -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.6967461982786033 -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.716901517689858 -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6625949396245437 -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6656574473096724 -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.6751882423357616 -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7073797618300924 -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.6806245766157225 -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7108384094156882 -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6568439199759862 -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6719613021674246 -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6952091195902824 -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7917804906622331 -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7691115298632821 -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7509647760509875 -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7839632379609766 -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7896384864890056 -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.775868564626375 -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7692688677215028 -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7648493229799159 -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7463004305198225 -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.775787639585832 -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7531658445897776 -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7558397838270569 -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7689089825009168 -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7601425414178559 -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7066350860084626 -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7847153656042455 -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7417856932947151 -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7330894345117306 -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5960969360936202 -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6131217312972851 -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6504672374776054 -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6593552252901995 -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6479868969246829 -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.663889787806803 -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.5975575555506076 -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6210226061707651 -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6542573275809811 -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5980902621930171 -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6446453445393793 -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6380808223630782 -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6166773586378037 -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6532363827168168 -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6579555164847019 -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6081461523033914 -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6328146021852963 -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6548293617959718 -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.731772228925066 -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7328297849802192 -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7550059517061446 -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.737661188829518 -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7282577924608301 -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7351204443851436 -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7372966006559173 -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7431425156950672 -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7267174524537374 -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7107584059790212 -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7099295191171557 -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7053944390393362 -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.6962443364270579 -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7292079815155065 -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7423791393836314 -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.6969873587753059 -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.6956786193321894 -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7121210726431193 -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6007105998877028 -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6301974516441536 -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6072985436120111 -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5985686807674563 -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6112649989024245 -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6032569213348621 -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6043248836231999 -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5940331141624484 -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5941236955187894 -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5901195279626251 -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5968927767380149 -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5825041094416749 -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6078769291013137 -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.61491224728874 -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.621559612018931 -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6266648396272045 -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.622525370033679 -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6377026606234623 -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6268597028936176 -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6727537494363983 -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6950370983702882 -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6053880837720257 -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.631288729960092 -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.638639183569825 -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6483292146480423 -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6868436142783995 -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6735347804580796 -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6396243181142749 -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6402750102547504 -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6239984358210742 -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6620857687414589 -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7131295873450866 -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6611033070870264 -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6420719791544385 -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6100463369482333 -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.608640289899495 -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.713881957902123 -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7291853776213593 -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7341335704119857 -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6840462231024782 -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7020661327164969 -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7238869074307074 -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7228247447584364 -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7311214282886986 -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7569700252093137 -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7175153047611924 -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7105867499947506 -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7391966665810511 -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7317623491493391 -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7293664423287268 -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7410342266815565 -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7265941534259243 -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7187491413615713 -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7220228904868159 -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7630364007208436 -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.769697472335699 -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.753424618023625 -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7465145427713792 -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7619443043444694 -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7637565473474514 -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7392055365083343 -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7505762662713037 -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7623140749212259 -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.750061138652669 -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7617632386565533 -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7774812264054168 -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7680724395596391 -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7682674521905919 -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7741887427501476 -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7595226424887144 -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7764248267696527 -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7642953485352993 -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6616161176870574 -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6740819527711069 -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6681382116551108 -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6172232826228674 -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6201203464586746 -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6451946121203934 -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6352623693686014 -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6736937636109387 -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6701666467302748 -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6218599114309832 -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6356862676809668 -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6484201562133175 -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6661470242989663 -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6791772784098752 -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6870442351638607 -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.609498854947861 -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6334879112762825 -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6563788710447747 -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7798814972577298 -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7665151805609757 -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7580437045857956 -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7628225973531642 -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7726336141541718 -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7749436842785986 -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.76083284095087 -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7762346188840104 -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7654342261814868 -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7654629146391709 -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7709134181615497 -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7566253306519282 -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7647524453659912 -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7531847191656394 -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7721564227188473 -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7658057262359937 -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7662907080550577 -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7483461641859707 -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5972459243376171 -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6384142105116318 -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6198395427143067 -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6272122401436079 -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6363255954238624 -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6279299526232411 -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5861692467500413 -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.604013920026239 -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6353301881114436 -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6029380586062892 -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6316611595289997 -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.62747869128029 -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5929152518004382 -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6188694282900321 -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6258667203923037 -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5916306951966656 -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6015053526842687 -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6243049751933835 -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6719169180937842 -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7124403941707783 -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7179912441441126 -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6720588949698385 -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6775651950223853 -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6892975859435088 -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6668297530233306 -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6903956547680986 -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7083838324171494 -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6532555367827332 -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6782284318377236 -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6844827883616146 -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6603024375798138 -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6982595783140301 -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6954196573033938 -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6483746581868645 -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6706304290490163 -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6781410614025525 -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6962142453007107 -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7154292003037446 -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7270757758069802 -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6676049305814789 -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7033268518296651 -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7219303856308947 -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.6929358830807969 -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7073917444430324 -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7254762923148261 -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6903935426354476 -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6977831156062647 -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.691939230846331 -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7188918056102344 -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7408666396670432 -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.731623562644769 -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6813212780405585 -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7152089215588756 -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6841872494940051 -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7587481780881561 -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.782371550275176 -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.787233501525454 -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.768804649600973 -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7769245400503145 -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7700262163084867 -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7794674328855683 -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7714558097196728 -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7709660074513418 -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.760368081519064 -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7675577620136798 -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7516545940673004 -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7591117360737899 -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7815121265942636 -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7832262885813113 -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7585392876445539 -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7613361596714118 -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7463168563368333 -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6376322445345638 -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6439968310245899 -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6702137305581561 -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5954127841756255 -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.636428786980087 -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6280769597091999 -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6541976638354261 -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6460893689959241 -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6631797026865714 -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6029640129719033 -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6162033202025018 -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6366674595998102 -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6384762264640851 -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6840330074344232 -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6717237341757128 -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.630709358118415 -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6354456533940271 -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6740285135804633 -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7624559129012737 -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7849017762145406 -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.762429416714092 -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7681188552515277 -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7558351472092695 -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7739021702894796 -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7671158976081257 -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7607981536685827 -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.778662684979194 -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7571316728140625 -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7468376790008578 -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.769500918021443 -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7650541204979705 -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7626468023265058 -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7457795959343722 -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7713882002523196 -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.748017573830985 -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7326944526640732 -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6036527441833667 -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6227144676937909 -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6449934498246425 -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6269609262164444 -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6042618984519755 -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5983172694024631 -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.580997133138477 -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6103580253107855 -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5977935373971685 -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5866755188642157 -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6074068518770415 -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6046510048864753 -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.60569965432137 -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6333345072215099 -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6227953712421116 -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6046653408284838 -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6061351916107101 -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5874284940277771 -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6453536311815826 -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6585322970270294 -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7031312579363963 -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6560839843680776 -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6533041615614921 -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6675906583302199 -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6853518260095348 -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6954857766180668 -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7118126707367723 -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.647101570058691 -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6400096655289658 -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6655928480662547 -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7129748836103637 -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6862450338310792 -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.688019451020938 -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6334245513984468 -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6508931560695207 -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6569038631843845 -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6726168629037903 -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7269387173001932 -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7202004386129928 -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6664941912258467 -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7063745234780959 -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7146887296764199 -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7099971410923264 -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7088040586401362 -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7250072540095944 -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6766325376235848 -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6551934842094655 -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.6857779601757343 -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.6794199897189007 -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7232558898496414 -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.692243502932307 -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6749015010254391 -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6792127793144482 -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6856289492115378 -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7824598523030475 -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7892133006362685 -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7809512786239132 -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7832008185522735 -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7843754412110956 -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7750172842811387 -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.762032949776538 -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7584190497582535 -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7418287602238713 -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7685138034186823 -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7593394675778792 -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7239108346888502 -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7578349975748967 -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7700677223909406 -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7428565982615477 -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7658316587646871 -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.743387678368905 -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7578691972899874 -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6208000577301124 -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6452671350675422 -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6528032081795612 -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6293685768694773 -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6338540866680132 -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6203777900173107 -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6278263944431175 -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6652776392761521 -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.651975171623159 -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6251258959415721 -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6431572865420767 -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6230940443613571 -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6231937403064587 -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6268050592741558 -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6950228835929804 -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6360991005008699 -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6266215385278396 -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6398817517092666 -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7539880600603953 -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.761303668206787 -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7466475283371196 -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7163104448688382 -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7415657609936631 -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7397086766031263 -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7278564923387819 -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7355072941522335 -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7599781197618191 -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7354848905921125 -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7300247190912535 -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7447777809984507 -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7275901300089327 -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7445277173183239 -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7587549869628992 -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7300144536957486 -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7358682618275635 -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7433209423473791 -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.622357482247499 -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6167602252668973 -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.595287588416264 -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6172953646429112 -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6109509148699307 -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.590210783067786 -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5945005813237186 -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5905126667681514 -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5761336558954512 -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6070706615360225 -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6080216456013341 -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6057466623967931 -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5987155963955466 -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6086642843091297 -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6164416978717507 -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6079976727357674 -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6163296340445953 -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.600955288942841 -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.663058624386878 -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6747215398721357 -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6904657191291376 -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6338888812332594 -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6664954285372452 -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6726323331573555 -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6767645044036535 -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7045904195038868 -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7130831259336948 -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6215883852175376 -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6663845201059374 -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6763382965529784 -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6874701574728532 -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7034326884802828 -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.682773456177666 -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6443306922927149 -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6447314693873789 -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6563110680534657 -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6989392444858757 -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7114378178609249 -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7399642001809742 -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6801500399688103 -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7192016259557015 -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.702151837189214 -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7065956411635468 -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7264798408455322 -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7424460555032869 -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6981241351803381 -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7202936096019185 -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7236437815386741 -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7255855127238195 -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7388665696388244 -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7433600709738782 -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6833816584724653 -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7407441102248885 -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.694876974297343 -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7638589434472703 -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7797464364385815 -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7672332896961538 -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7541623641884166 -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7727556842481612 -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7535124935553359 -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7508145484344403 -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7585653047569737 -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7783421718046254 -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7440651943237366 -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7528399220563764 -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7774830053190183 -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7474061776941925 -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7699271286785913 -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7692980547639611 -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7514637901809315 -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7494837473072432 -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7627781758163291 -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6152469399057409 -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6681600196067059 -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6546449161114548 -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6105500772401317 -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6305655406206084 -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6466743304148604 -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6575057859979497 -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6543220030441855 -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6977337002282789 -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6274627963636701 -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.675459923244881 -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6685088771978207 -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6606104285528067 -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6524361540692376 -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6795547261771876 -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.640134224026894 -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6420777912121639 -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6406322848684954 -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7705554179946201 -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7699575288567083 -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7697321694213456 -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7860191068792027 -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7734911245340218 -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7549765026682985 -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7653236076693316 -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7520969313261067 -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7575304339642907 -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7731756200607739 -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7646680028805131 -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7735439694609282 -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7654387325726617 -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7652204905903034 -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7489646814549963 -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7610852540818008 -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7489159113947665 -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7666026688943921 -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.611136501439689 -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6317915599189958 -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6080737492248065 -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5755738751124019 -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6252522146580638 -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6153909366675886 -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6092390411254147 -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6405412555049333 -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6317734300342926 -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6097374790221998 -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.625473746664901 -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6214480216623672 -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6237397985308882 -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6251820459745995 -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6036436235921497 -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6024839552901343 -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6141276056269264 -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6165135533522544 -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6833377935347212 -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7042488780933575 -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7007044882945506 -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6451108597505072 -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6751116085256027 -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6752433418903602 -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6739642584408349 -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7028532631060691 -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7194738013697344 -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6360729841121381 -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.671531568294116 -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7019532805588383 -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6865848153180979 -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7034617778475921 -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7047031465127809 -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6541128926397259 -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6978994069034662 -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6760979614550839 -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.6889825165236464 -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7276373193802782 -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7304517843639955 -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6659428885601905 -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6943399622062992 -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.6994323118600496 -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7090930138124684 -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7196696619675166 -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7325139856014703 -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7031657567165798 -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7140253391939942 -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.692446133116739 -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7045591730847206 -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7251742483981928 -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7302255825396594 -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.702573077454355 -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7026943130538966 -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7021354886541844 -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.7771461277529988 -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7732281572395413 -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.7766233803390413 -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7670252325477244 -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7653588688167394 -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7711149787602737 -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7767508701633336 -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7919576571790162 -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7900522476609058 -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7650844904506608 -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.7551121611140824 -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7704189399816732 -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.781613352294387 -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.770746708098729 -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7821048241118819 -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7826915038702659 -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7700793718312303 -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.766376415360733 -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6230985549105131 -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6631306776773781 -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6727209137131074 -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6012249661382305 -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6241188496548956 -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6229062114741204 -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.628163629289887 -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6671231663988005 -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6806265554201986 -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6157650137045115 -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6475345245508768 -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6664580070473324 -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6501266785391672 -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.666490512218409 -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6767203205949698 -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6395765337155305 -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6369714108387481 -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.655210287215309 -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7837145772394601 -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.7908885427414377 -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7742193519457619 -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.765380597612412 -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7801503307653178 -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.7696243004008024 -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7738445413581556 -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7656344339900184 -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7629113440737125 -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7734787287341088 -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7859099985566566 -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7753734661286256 -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7425502985912912 -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.751299261866138 -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.7594082261896192 -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7585122595098822 -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7564960856706372 -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7557743794967681 -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6021543204780669 -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6129621165241054 -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6026706801506915 -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5780914649914792 -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5878861798143616 -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6119985256059941 -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5885078813012133 -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5937945538093897 -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6064194880609164 -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6124196630556722 -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5809115627373574 -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6388232539268471 -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6152934931074614 -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6007913074751602 -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.580138951589643 -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5621168102757288 -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6386553326230912 -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6188160782952971 -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.709402004225096 -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7041772363609985 -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7201708519849044 -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6418624681262202 -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6564477867986551 -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6707579971452163 -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6805331502267613 -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6969335411878657 -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7254520807839602 -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6617706824794158 -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6883984374878805 -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6561280496548613 -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7087285662187474 -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6944781373932857 -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6987543888248626 -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6956571571738054 -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6610043462585674 -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6684232860516331 -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7087306598776427 -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7187818007279961 -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7368210093540876 -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.670663909894893 -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.6672002501809832 -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7125630359886995 -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.6848216000209186 -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7285198621417903 -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7114427978991905 -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.6701419538642277 -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.6980277808681837 -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.6831857160915562 -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7057847441145854 -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.703768702045438 -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.720887314953432 -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.6835906070294001 -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.6882038653856116 -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.6899958138877776 -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8005517340684901 -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.7828009722308332 -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.777744312200018 -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.7564489657755339 -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.7825244759314044 -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.7734471189926496 -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.7659890369520834 -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.7662538988480491 -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.7560930006279426 -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.7765611854987329 -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.767995730618067 -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.7713985421820606 -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.7796760344940922 -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.7531556140299817 -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.7659121254513245 -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.7652375158874983 -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.7665641280139806 -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.7557553286276185 -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6191821105744296 -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.64175623762525 -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6465916130806427 -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6157149684288811 -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6100354863503598 -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6492269369234279 -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6322740199710243 -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6662715302500286 -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6682220487390578 -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6123629378855638 -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6300246951402806 -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6376222473717581 -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6305750666066671 -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6546768327285358 -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.656761435686018 -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6282708713111655 -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6478274657283151 -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6219532413900822 -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7459347031560618 -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.777803397533262 -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.7716117150246982 -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7687089073027001 -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.7477581309418238 -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.766283493073173 -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.7517569434291707 -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.7843514444005177 -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.7839033612189504 -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.7459009575525922 -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.7336755986546359 -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.7459339345645041 -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.7646245551622476 -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.7597205615488017 -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.774994163557527 -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7173227575223539 -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.7250767649755424 -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.7504682210140542 -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.596490332237134 -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6111729739158015 -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6045143603808628 -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6330952128837386 -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5837493849673268 -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5948693505839235 -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6037749737877843 -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.645200652465172 -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6080855385706464 -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5778315508618856 -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6052498426545445 -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5826580820322591 -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.594955470759711 -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6222231002546545 -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.605302549716682 -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6142340607754707 -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6021923684796936 -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6184414191841404 -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6591824984113274 -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.706010944343396 -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.6917038866563713 -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6013182985185579 -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.65212889929398 -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6601198154479038 -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6953706997751273 -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.6953604944691851 -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.6946713252782925 -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6573488298003891 -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6799652192429845 -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6798617447504678 -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6726686864390149 -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.6561872718863349 -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.6892479394935159 -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6459947390623334 -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6810167493646558 -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6463971786650515 diff --git a/gridsearch/gridsearch_score_rhythm.csv b/gridsearch/gridsearch_score_rhythm.csv deleted file mode 100644 index ab9566d..0000000 --- a/gridsearch/gridsearch_score_rhythm.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8266728401334588 -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8539871598117351 -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8704825466035099 -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7663183739957345 -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8503065381880203 -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8637991313810315 -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8345407299160946 -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8554800638138529 -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8890243214994102 -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7926455277561589 -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8789147031813259 -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8894655353870277 -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8485005702161897 -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8743572057477396 -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8774772927724843 -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8414478263662364 -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8729208700809017 -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8950384587484885 -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.881192886651784 -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8648103266529374 -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8730502760336726 -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8403958479852215 -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.873627824705018 -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8847454411513191 -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8754054201785103 -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.887429631741241 -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8769903645206342 -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8816089370030474 -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8905082089144395 -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8975545482860241 -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.874380169514745 -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.9066267956925876 -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.873568855162373 -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8773689156851697 -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.885535610353588 -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8777212287934937 -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6704134720893576 -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7125223896168823 -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7583064671024909 -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6419942743866476 -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7258000778841232 -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7596346563242956 -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7078933697934082 -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7680808394266548 -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7784954891148071 -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6730908877208129 -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7382730157041987 -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7565360588995862 -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7272546045550049 -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7773356250705635 -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8001725604081757 -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7102925150043441 -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7639752614017649 -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7408655581829943 -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.821918074012088 -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8675601514470869 -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8706476171840162 -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8333517184788981 -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8430680349070663 -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8751543008770019 -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8615141429612226 -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8667997901080797 -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.858925837986256 -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8672177772284709 -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8871018799220897 -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.873143324193633 -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8453000823665905 -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.828939574671903 -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8929420978555885 -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8511136643983163 -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8565245294479497 -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8792392261613168 -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6730918140780799 -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6497582924308718 -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6841394375733447 -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.650533149771106 -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6806060091309375 -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6933064147005293 -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.658440381664271 -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6414879577595931 -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.7162040001890212 -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6598180103332373 -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6764351811981091 -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6358740040620927 -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6228405210146195 -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6314136570215991 -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6974838469332997 -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6540387728340195 -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6905445175032896 -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6678250017718473 -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6941549285170755 -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8119221513210936 -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8058446872197068 -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6836564836810598 -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7426270438700352 -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8000506031815492 -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.724601334788777 -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.810637506523863 -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.863951035895086 -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7053847532012849 -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7877573968614172 -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8228684290859345 -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7539060432407033 -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8322067445889044 -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8689482102882174 -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.740618071085713 -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8479862527844234 -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8490469323540227 -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7803629088523794 -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.834674210430113 -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8719943782554246 -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7394525486832969 -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8498518129049982 -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8502708017141706 -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8128365223516522 -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8762175656291807 -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.899636960843853 -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7359695737875659 -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8663245161346418 -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.843030223170082 -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8130494636951392 -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8484066358283386 -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8549085969367534 -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7916605137931146 -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8693037117222934 -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8544366368065336 -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8770190096946059 -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8582598133220686 -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8693521542960997 -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8747621567042555 -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8565709738056907 -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8500528089506386 -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8717867031130343 -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8845813412112458 -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8815188559927041 -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8438824088831797 -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8725233095543571 -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8626164438355817 -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8388156546210418 -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8710856155233978 -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8617355987012195 -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8617313415463329 -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8674953097945158 -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8371985467443416 -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7065695046448132 -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.742575217612656 -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7646651401397601 -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6501062105719884 -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6964370211497424 -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7465180030091386 -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7336025608791642 -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7318642379051394 -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7772939188987839 -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6958935707996199 -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6910376119649501 -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7487454750832535 -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7029104043096869 -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7677231163229434 -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.765363607903725 -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6587530538615392 -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7169493227541287 -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7556101826645397 -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8041626887602621 -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8760409385172946 -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8781858990473409 -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7976519650087935 -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8417950636478685 -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8590866198030325 -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8611608809355963 -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8584978413567771 -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8537246849472698 -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8493290968499001 -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.868972478091 -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8527631798038874 -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8574615322020609 -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8714000003834698 -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8596627268415166 -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8407461100953784 -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8742901899215555 -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8466797419154499 -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6730282607540663 -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6527772719666376 -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6833986494055746 -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6484350228904973 -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.7025122701024723 -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6165897038997831 -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6508971208087618 -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6881577915974817 -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6581244239202976 -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6475510615234014 -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6749102936843504 -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6796762027028752 -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6335305795180921 -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.674297044200365 -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6836000728157926 -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6649758480839724 -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6911744880414835 -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6695366221099569 -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7014373436292641 -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7617201578648191 -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7902362610042398 -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6637347672283352 -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7330214349116205 -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7611677845025634 -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7284320955403958 -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.78936766826493 -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8380861213637787 -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6862464986574359 -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7301043702122666 -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8333354519559228 -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7336316099155176 -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8007951048336092 -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8100514249633194 -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7226884337793144 -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7790155834600204 -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7850950466890486 -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7495758556397871 -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8315753862271041 -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8710055127271756 -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7364576670481578 -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.787672598923249 -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8217612721350912 -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8078801098622016 -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8530087063487457 -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8732578183137761 -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7315452720399928 -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7932894656816929 -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.867402887859106 -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7994359764145967 -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8452146827877197 -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8559008446423562 -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7760259045040621 -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8277374452654213 -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8539592000179564 -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8769205029052003 -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8809930544784161 -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8604459342254404 -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8381307737817356 -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8489315426117653 -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8868635518220214 -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8895091162891887 -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8776826410523578 -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8683784074381743 -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8873249911098829 -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8809382174002659 -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8291130969313669 -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8857606105544996 -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8561188827110603 -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8610793041595873 -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8640878843425885 -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.883161719247803 -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8548038763789768 -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7092343562363858 -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7304042248841339 -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7286558973649949 -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6663103206444968 -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.697617849300233 -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6983599795527718 -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6835177246500965 -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7484720911245689 -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7701504957712126 -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7044240267619813 -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7012506222466697 -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7413704961879942 -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7091668781053918 -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7370649546346968 -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7575233706539258 -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6711943291487925 -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7192008846846197 -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7262523497850387 -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.7918577448374879 -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8785857108690371 -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.84945918552559 -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7871401288280993 -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8711614714892214 -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8756107100524755 -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8295667141496298 -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8698579646889945 -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8711080264750057 -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8154081438586381 -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8888228382527837 -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8242159885808079 -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8218261427235 -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8732793846724117 -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.859804837238419 -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8445538719494959 -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8820428168136165 -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8697736263418103 -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6382276781755061 -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.701856619508638 -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.72827843648473 -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6197896262849681 -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6896782494754947 -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6331992465523415 -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.722028485823388 -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6562084036278721 -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6677275048437529 -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6993083122219796 -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6846687955759689 -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6536963043014793 -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6449451357006475 -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6802202001399089 -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6713357410709997 -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6973441029681512 -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6616828284740918 -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6772565729898008 -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7048766722607295 -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7682615428652713 -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7935412373756033 -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6362366921437329 -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7262728158859416 -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7895667089530374 -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7126633846914329 -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7735764704125768 -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7812861013241958 -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6873966590096853 -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7507692552109096 -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7730818775363698 -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7671583073027769 -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8122203080863525 -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.792901592059242 -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7353745624299989 -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7444094582398573 -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.782857378856515 -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7634373589058195 -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.874871191460138 -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8607870618228417 -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7842764616701897 -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7921938490362873 -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8616930696777972 -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8308453685304076 -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8691570365309839 -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8709173870135897 -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7920687515424034 -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8522811626614389 -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8855480677170949 -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.826437387701623 -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8737282324572914 -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8469615666337577 -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8302225630675414 -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8696909882231091 -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8809570324269274 -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8704692898080991 -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8787158715679007 -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.9019086599517372 -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8461797127666614 -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8836570165451422 -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8861467143190631 -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8818734499099149 -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8760372095847232 -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8772910620647488 -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8531983767624202 -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8649050911487327 -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8682634887311268 -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8658246929290255 -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8790765365347665 -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8759197933806991 -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8837715210972649 -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8876975803262209 -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.874765959801302 -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6949970330765121 -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7000901590553882 -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7769795867876326 -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6605842569653313 -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7006538799961274 -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6991591663726843 -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6885996434702578 -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7899192667009437 -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7907329527841784 -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6606154191769916 -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7504500012155696 -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7616345462557295 -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6970522813160648 -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7886989630676138 -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8109184430445276 -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7132962744118124 -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7497806861421403 -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7766066221289679 -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8506573323396891 -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8522237654805661 -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8656210504192758 -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8318372591911571 -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8695931403478494 -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8568193472030655 -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8210614911572095 -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8501900307212419 -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8728487996048883 -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8575590042096559 -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8763390419082452 -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8877908944377623 -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.832676401194221 -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8576414067238235 -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8757160051393873 -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8651336041855694 -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8738497787797965 -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.907573470031358 -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6851633757775032 -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6875933248380416 -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.7010224547373268 -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6654449049388829 -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6489796908960134 -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.683018010280057 -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6753542365324082 -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6703915824138589 -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.7103811089960287 -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6471732368000885 -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6494832775946341 -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.685704776736295 -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6881995812011552 -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6711793954911763 -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6890320651761178 -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6883699913531753 -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6238329350078083 -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6833578416403733 -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7231455511462198 -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8017327571266882 -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8422690555541145 -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6653556178123029 -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7612582906289195 -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8499711470469782 -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7904567364937884 -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8445358708072538 -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8638411339665493 -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7326254326414025 -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7987906047132602 -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8384666780548781 -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8044234663450927 -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8484010262079856 -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8604404090940679 -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7334323345247822 -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7908386051405768 -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8614383995330842 -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7717964365209316 -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8529296210019387 -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8832485554678029 -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7600575450035173 -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8217500137836081 -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8523739224847167 -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7855540153124205 -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8666404077981866 -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8946326003224713 -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7872540427042738 -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8364155015438652 -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8756946435032806 -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8044195071539947 -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8225541740071313 -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8361367645598143 -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.811710020247964 -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8681793323922734 -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8623949640476428 -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8596922528379819 -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8779244978092721 -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8853390676602008 -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8153907563570001 -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.836262540308821 -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8359731178839572 -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8668121189015672 -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8873227615031923 -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8878836678890645 -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8566182771902394 -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8541839455729524 -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8696330029482232 -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8637562320155352 -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.864424764607453 -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8702030339646912 -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8704035156920026 -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8861012377014542 -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8624578019893749 -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6877841733723153 -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.72619685865901 -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7426886948990766 -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6685164648945041 -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6758142470124032 -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.717020949983799 -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6938418793630228 -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7332146869183079 -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7663743056138851 -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6752413618281238 -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7108589659517063 -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.751965455315676 -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7343655448921368 -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7716391335852119 -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8063332812843163 -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6891794568611523 -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7499852518916873 -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7188626088377902 -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8308926263198012 -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8452213340875786 -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8789290230026038 -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8153383490581388 -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8684107053881407 -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8771605986787346 -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8348120190485292 -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8369153469927829 -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.857238556886495 -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8407951015192506 -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.889226287856035 -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8619748305309015 -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8435536403562033 -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8546485454940687 -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8608527820751165 -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8464769866690717 -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8520136374297803 -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8379446614484327 -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6766281367859229 -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6442028310089319 -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6469934348459844 -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.7176744109941967 -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6574140654925343 -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6401571648040592 -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6669178649549785 -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6524980912635968 -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6796390463982425 -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6859627712913254 -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6764399035973666 -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6841659318643704 -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.7021507279096882 -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6647774838012612 -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6731549642832139 -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6706003019323186 -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6548299042391253 -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6841506057941742 -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7269517495432565 -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7805064562353999 -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8235671176482399 -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6882498353016514 -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7422778863268703 -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8150502897187449 -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7412450009067477 -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8070476251367565 -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8570789273807223 -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7172206925483585 -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7672145998938781 -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7704804162085733 -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7529008707059875 -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8412284762273279 -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8313608905852082 -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7383052676347178 -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8556238644258171 -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7797152721795556 -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7786521135907581 -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8394557304606778 -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8491489507244386 -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7404958477509415 -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8153835205481056 -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8335809234696319 -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7694638672284974 -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8521929792888091 -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8557823207309906 -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7598121116176665 -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8374316208041491 -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8224289749223619 -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.822560433451379 -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.874899267851637 -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8245034618799915 -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7804071741518722 -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8094142353462993 -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8193451846882246 -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8655243958338273 -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8685273755418567 -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.851393865580791 -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8571937250192153 -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8649207740373531 -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8779249661811529 -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8740491878940743 -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8874547540701397 -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8656455778326052 -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8581007106326904 -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8777884690809356 -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8758791566885841 -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8607213583646532 -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8657438986999823 -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8775619586738931 -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.860314873454083 -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8592809235161109 -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8596817345748645 -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6505095934613113 -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.724704748176745 -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7611028352943902 -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6567843471526157 -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6888772136637362 -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.696417118104455 -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6424728441568024 -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7686101073468491 -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.737324567454762 -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6820289836602642 -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.702664049280855 -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6816729423145637 -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6708016446938467 -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7474731782513554 -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7417413669715555 -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6652164665640933 -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7089274267082054 -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7101594176577956 -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8290080189670556 -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8615025407046737 -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8712328915989581 -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8270322612854861 -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8409997587551096 -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8899619681953251 -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8398061533829839 -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8781750816322264 -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8886115801073154 -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8456106239460451 -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8759656502025609 -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8728770578327297 -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8600550638638428 -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8670003707168416 -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8609180267204346 -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.872045606268603 -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8770104648325168 -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8663862412663542 -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6302437248481007 -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6544150693704119 -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6975794831072863 -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6825022744534591 -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6686771668277153 -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6331156144448961 -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6995950815875053 -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6344769248854122 -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6673618196611714 -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6173900343874585 -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6790325092539726 -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6284780242214021 -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6939759642238146 -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.667328164638901 -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.670825060357921 -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6872859334536635 -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6826727987954024 -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6651646873244692 -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7272614533957699 -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7752914191616371 -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8338883475562205 -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6931168278817283 -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7543950641307097 -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7503506021021839 -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7677546390404798 -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7930714448136619 -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8473097399628654 -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7268759106315247 -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.733417876945527 -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7587976264263485 -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7431438413940176 -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8110270701159058 -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8222599451450856 -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7532287276763557 -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8014539445786717 -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7637923021127749 -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8007055107712636 -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8111401599655931 -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8597424720962404 -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7854718254998171 -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.841298160283973 -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8569062125289238 -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8444463499829498 -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8985908220262266 -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8906803024185869 -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7923255256422563 -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8840164772363587 -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8831632808455501 -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8557519072375833 -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8625377757673646 -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8662416952966182 -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8351990130131114 -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8583289669518526 -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8650823747566654 -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8787861647384538 -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8674765741380281 -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.897217200731229 -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8493300749024613 -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8823291864225623 -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8777203482276624 -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8639670343864226 -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8900825698910758 -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8925883728249936 -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8646087917988963 -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.9149398333298526 -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8965267524781245 -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8746831784813768 -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8945902052054003 -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.9092855925935228 -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.868590824120158 -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8932163510231644 -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8836782618251551 -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.664486969190714 -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7023876350220378 -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7697879620997284 -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6434109651594578 -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6967503057470735 -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7757552180232888 -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6895166073141715 -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7719674535997548 -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8097421539589115 -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6453439426376325 -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7228676777850845 -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7182140190615319 -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.710758505573526 -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7592896872609559 -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7731948502738915 -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7103908878778974 -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7269971907379631 -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7651542045350886 -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8372217870410982 -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8400676627689716 -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8608631005781984 -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8331263958869136 -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8978382980758693 -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.872673438257732 -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8416484747475729 -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8752562609604758 -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8527940894919911 -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.854893910789882 -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8966862059151781 -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8585905205607863 -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8562677140525671 -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8832181013087436 -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8893650575699491 -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.850997291333361 -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8926256506112907 -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8795116110710278 -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6822841560530887 -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.676363392433883 -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6842833347264129 -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6511014762284463 -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6645874060582871 -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6676649891815117 -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.650970649757562 -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6889934448277687 -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.658647373675532 -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6616161969294524 -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.652259778067566 -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6752723241623036 -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.668506438799774 -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6863957285392326 -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.7080359427387389 -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6561245280457473 -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6881094195435812 -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6688108062579254 -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7265511944652491 -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8093563469252514 -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8286366768558135 -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.702287436413742 -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.825505655629115 -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8221346742681486 -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7833876509520402 -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8744418763461469 -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8558845062469013 -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7488575902947613 -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8181731268182156 -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8600061330684333 -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7944799017873599 -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8629281098723668 -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8832870868728762 -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7618664969399952 -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8545462950393775 -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8282674969783025 -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7722901849779714 -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.830706163047167 -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8610376740193507 -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7384183563724213 -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8060371927246807 -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8535915441643217 -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8448954256905857 -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8609792466491446 -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8533169985648689 -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.793869697360042 -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8470878763356989 -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8668449239718882 -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8298641228258856 -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8710962632721463 -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8796233328879431 -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8220414416238482 -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8441335891852894 -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8657850216363915 -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8335056473609792 -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.875697329827659 -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8848684416684138 -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.841633216849684 -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8606737717521736 -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8552290875856579 -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8477065360109016 -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8501955349103844 -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8655722956924924 -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8632801140069842 -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8696768824079553 -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8554730632116377 -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8681355914894672 -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8725773455246678 -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8706001702804088 -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8669292377576734 -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8516059302651452 -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8401136651973448 -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6653253590201039 -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7084177485559066 -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7530453093147202 -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6503093646537615 -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6517599899088483 -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7076052575710658 -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7130154118774946 -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7092219842604078 -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7914548612194255 -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6666365199981601 -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.741547068062047 -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7329425084538288 -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7233710766830334 -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.794247050993422 -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8144680018129465 -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6827242777123078 -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7446465630163019 -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7640478310863162 -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8239020139463887 -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.833619821901821 -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8385453165331013 -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8153582534436318 -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8622558399445784 -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8292803552350044 -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.818344523962951 -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.842614170978608 -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8464663961040596 -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.838555782931162 -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8789934580826645 -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8317881420705634 -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8329904132396041 -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.861024994828354 -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8881072135486109 -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8468707010333719 -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8777144536555784 -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8412822633976003 -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6522423743624256 -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6804179907624408 -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6914528099629328 -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6572398273839625 -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6740682303033093 -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6830056509975502 -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6881683984212033 -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6522926859160109 -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.675124646133774 -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6639583660098837 -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6801989123674693 -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6465195374952937 -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6228458782651703 -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6851850489809582 -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.7064532740834283 -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6913435859323488 -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.653059175237721 -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6863385344352597 -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7235331477868554 -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8001643641459902 -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8531407006553321 -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6988662398070252 -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7684683852787879 -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8667321300409107 -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8491311762471595 -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8782826946995783 -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.881402823548281 -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8205174071551223 -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8496250271591119 -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8658380410649543 -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8650910186302406 -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8802016825701425 -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8714652473663532 -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8489617213265016 -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8669316289482651 -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8479963549461643 -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8512849521340634 -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8840000648519092 -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8863098826724766 -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8541620935304399 -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8649063428853943 -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8652465663600796 -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.867422370023406 -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8847697441435193 -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8944396244488004 -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.864920358702648 -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8730585927170919 -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8687541929811061 -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8824281896551233 -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8896552725995935 -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8868693672058622 -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8812635140045364 -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8862012190648233 -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8723601171746639 -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8749756571388415 -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8659526684073876 -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8611508454588236 -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8694072682769605 -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8506458453021515 -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8585341711793633 -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.868475275260684 -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8763822978001237 -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8648387347769958 -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8693424593925498 -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8770503652130149 -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8515659490410908 -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8746048512885825 -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8706678410301371 -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.84267819639796 -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8657892458071138 -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8716246037993205 -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8596337123943997 -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7205194374194583 -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7756294640482585 -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7928793259390664 -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.615639848801533 -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6909757516106204 -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7505621569623234 -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.746077333799375 -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7908567407965957 -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8134813415836764 -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6851686315669926 -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7479672671744305 -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7722691344476136 -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7793448734243421 -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8063971212366695 -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8140976187612493 -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7509653217007214 -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7557991054173278 -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.805232361831628 -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8898872996320395 -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8854160580480291 -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8801011762468276 -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8847426200907952 -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.883121789474472 -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8730684994926476 -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8740467897901333 -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8650242748556295 -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8584014401126119 -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8766577934457974 -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8726551056821354 -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8662955940082512 -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8334142977841275 -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8571222401971701 -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8749997680371676 -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8560250508804326 -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8287497164286348 -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8575565529526248 -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.6871033950674293 -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6600854239356059 -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6347933200458628 -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.6600976304232719 -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.6847331124074031 -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.6204278582341622 -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.6864067305105612 -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6848880204578304 -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6528612453597834 -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.6457615777530995 -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.6312192414180592 -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6757628998342057 -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6520006623962669 -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6998564346531085 -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6736209530744569 -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.6718484554051894 -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6608898003251579 -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.664665882644688 -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7004816607043006 -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7960721976760453 -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.84341668127814 -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6876301527893499 -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.760504448718021 -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8346388560597316 -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7387031050479931 -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8030303091778203 -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8329734208821958 -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7367955142215531 -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7767884350360746 -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7570581105598676 -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7750688011369106 -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8332764211725016 -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8204372486030659 -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7301139098181518 -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7538368283614756 -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7812894492635043 diff --git a/gridsearch/gridsearch_score_subdiagnostic.csv b/gridsearch/gridsearch_score_subdiagnostic.csv deleted file mode 100644 index a572488..0000000 --- a/gridsearch/gridsearch_score_subdiagnostic.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7807615847292481 -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8273952199909033 -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.816541219601261 -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7874201089571099 -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.80491790634053 -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.79446558418359 -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8024633186571609 -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8131053894212582 -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8281741192788802 -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7918973619414748 -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8125810424718188 -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8168480526853527 -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8117336707241325 -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8260458391099362 -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8352476726847465 -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7959396282459656 -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8181648074779426 -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8071386637304306 -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8598723932821173 -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8657245657808886 -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8606214797638106 -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8526375997876302 -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8593280384341743 -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8560152603047843 -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8523981067618447 -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8549795638014307 -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8606635181861345 -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8441291657421318 -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8376733689352083 -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8390691374221341 -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8390784191065433 -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8611338854822966 -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8533065490609472 -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8374706322877019 -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8400341070075231 -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.831473379012796 -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5793598661801691 -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6436127354420278 -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7037732608666553 -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5579997356949605 -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.5888678896856064 -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6219933433243594 -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6189323335853237 -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6777140814663801 -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7100222307822494 -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5968250701882761 -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6295038140350557 -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6263172590657694 -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6516977999062417 -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6866884175203523 -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6926483556008375 -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5885607412825307 -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6319401431861237 -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6486045017129186 -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8214592081074837 -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8404617651211844 -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8619680203660393 -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8413205391237689 -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8618286558332011 -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8612145619809836 -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.824439584381394 -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8604240715267147 -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8414242084300488 -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8475583082319353 -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8616367321384244 -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8548681858750588 -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8456429963557043 -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8470266371147193 -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8392796754499966 -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8361825149865837 -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8405448452426433 -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8461362160700862 -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5524363483743371 -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5469750099020755 -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5794427741684406 -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5590583793496537 -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.554269604967374 -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5641351604799479 -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5822744332250328 -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5925917875671735 -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5894573827020865 -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5648424427370101 -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5699094727726988 -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6030675412320762 -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5770587859174233 -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6183171607550709 -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6005490366134332 -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5773984113932286 -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5648651939183158 -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5771858483843473 -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6520480997270486 -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.729150451568023 -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7615223667261425 -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6146100802532813 -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6799540794278988 -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6857641724705538 -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7003470662477992 -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.757811391082908 -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7443929644605402 -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6545720592199546 -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7323167560749227 -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7319451225664788 -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7194377643167412 -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7402690454267985 -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7742557186061778 -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6795878808803589 -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6963516575190729 -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7200648414233993 -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7644182816357681 -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8082300837490305 -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8118689824960686 -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.70842692226199 -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7804287212791837 -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.778008573833812 -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.786212819705352 -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8320260684657322 -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8001840795322405 -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7542512095186744 -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7755790613878064 -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7892825832205747 -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7998429116017952 -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7899674555354531 -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8180066940013914 -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.765429533083655 -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7895385484069211 -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7547080097260476 -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.871906710179764 -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.862811273005121 -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8686688771787909 -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.86835782572691 -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8528335372482855 -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8424245424850584 -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8565873654573554 -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8393234996013433 -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8358846068050342 -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8430294037887288 -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8543278315457496 -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8312659456750647 -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8483907454368153 -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8340548203043644 -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8282639822547774 -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8412916118043979 -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.844681002833035 -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8368952899108647 -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.613553523936743 -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6806153369218576 -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6849583989020737 -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5955299375593763 -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6204548102941806 -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6537679322231845 -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6133530503419247 -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6930930795912863 -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7098146959780692 -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5996845880451497 -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6101080351310417 -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6408856464919733 -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6437011066671524 -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6945588702499839 -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7104043575484714 -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6079116615635868 -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6167509769705654 -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.653058263792088 -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8434313997523496 -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.849239592733609 -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8443361967666746 -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8238308817123504 -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8484952947548265 -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8560745405724509 -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8294750198210794 -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.841700722661345 -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8514268589907162 -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8465079014914384 -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8723314786852088 -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8577323770276554 -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8278834907027499 -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8423968967366524 -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8446636932787301 -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8256056011952362 -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8545002664714548 -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8309669781544428 -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5575560991484205 -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5692992202085477 -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5825603334685345 -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5666354354274156 -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5501367463099327 -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5644967802799276 -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5459553499021301 -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5903577743213032 -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.610135969190151 -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5774073532559462 -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5484628282243033 -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5726143993930021 -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5623048933509728 -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5747156033001612 -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.575624794368773 -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.559829775503138 -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5841227048564407 -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5793632226523883 -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6674018627640491 -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7029214642375315 -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7547416393684062 -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6014696446639243 -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6820200183263845 -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6885127690247556 -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6941458545369047 -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7245381672708792 -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.742185068991911 -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6133594585446309 -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6877474423336754 -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7175189378775761 -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7268455384858271 -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7398895494495362 -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7713003470766354 -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.658946117726908 -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6698487013363402 -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7101512346154101 -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7227585964527458 -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7791241794883913 -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7906991558923462 -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6773615115878101 -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7054695057248446 -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7762794443481119 -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7723066937154868 -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7985492434125594 -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7785030844858118 -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.736230288945125 -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7722103437938831 -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7511329642725205 -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7757877198275421 -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7622249943398384 -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7989290031548472 -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7141057769837493 -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7567773794926076 -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7527663930525543 -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8608623041186182 -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8700635522563279 -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8636903711230574 -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8776509739249669 -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8728923216108976 -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.851983490241468 -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8553652782737884 -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8413681414950601 -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.843099137424812 -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8563888151187058 -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8366816425007689 -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8560090653608725 -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8420332587258104 -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.850064266989516 -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8238749466558937 -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8706673327368634 -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8680745672320915 -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8471967473661924 -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.592748511453077 -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6603572623993715 -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6673797570165223 -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5722609346948656 -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.5970269336493744 -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.622228695805879 -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6265829956669838 -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6523381993866294 -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6885214162133654 -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5968860320337743 -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.5963967151511571 -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6231158230887489 -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6391116870946928 -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6811508400109029 -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6717884017075155 -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5953983683430742 -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6308376297480127 -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6227393302417955 -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8152049675692301 -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8355069622097712 -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8405197867652189 -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.7888964841661936 -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8223808730532225 -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8483980447435974 -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8135334635088979 -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8423915128656811 -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8474169174484517 -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.809242290614709 -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8317763143795328 -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8293774912418307 -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.827995389034294 -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8105922841471697 -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8307207728585851 -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.7847098546111934 -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8346753290681234 -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8210544950354413 -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5658208932187813 -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5807321740366146 -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6014833525677522 -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5679959354032148 -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5487808449810435 -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5642759321676243 -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5659274023279539 -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5589082221017168 -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5693422069438321 -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5413737593390845 -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5722452065940034 -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5772512220827918 -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5696094816695666 -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5666125666204898 -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5697913950398755 -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5867568503763511 -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.56488733023698 -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5571889325353144 -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6462564602147699 -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.6984448455009483 -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7259345508895372 -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6055823777398887 -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6568380315072554 -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6591861063775132 -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.6608741159443118 -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7366091248392111 -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7390901905173163 -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6363809122811754 -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.6789142040375711 -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6999073748308858 -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.6843185955435396 -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7111152330513163 -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7119707137265084 -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6145747273707568 -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6648772376365341 -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6341196737916814 -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8012601253358916 -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.806824974558059 -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8223548211999904 -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7585075971084084 -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8181535105312802 -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8145348552426342 -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7980541590476817 -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8162932397946475 -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.829246963681547 -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7908829871093378 -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8224570796499364 -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8092746263137086 -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8121352304806662 -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8150779939279511 -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8276691054119848 -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7824921617917276 -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.811520577947062 -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8256182833656968 -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8528926078257357 -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.867343862039519 -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8615528002311397 -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8503303965707004 -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.852832623691821 -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8530207305847236 -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8420307362283316 -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8620730760349918 -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.85003987648309 -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8492242774654931 -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8514640716272971 -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8562960623740072 -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8476226220737407 -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8544742834881203 -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8587753808855635 -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8330724460756005 -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.860402863688161 -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8494724240987482 -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5897534416684068 -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6340899717776195 -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6492702908951197 -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5694875410303426 -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6094635084353407 -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6644945871483625 -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6338436630902863 -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6638374345546433 -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.699850413274192 -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5814950070258688 -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6190318904503294 -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6251988652120873 -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6424154006478325 -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.69691627593905 -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6872586068635131 -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5817773798164146 -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6412679584534937 -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6429827711033974 -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.835352353840721 -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8688790163559258 -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8411638017071575 -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8267071046165556 -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8583828755312873 -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.845224216257149 -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8437657966114068 -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8484755995894216 -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8594171649955468 -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8453214997846326 -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8572771076216306 -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8408252395830679 -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8358087897369724 -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8186416423593471 -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8310606404905783 -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8305348808636365 -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8508909088523122 -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8377255604448791 -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5732894668538423 -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.582556001061074 -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5872903526999326 -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.54915616104225 -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5814238629509513 -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5929722140502037 -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5700421859020666 -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.604544677736434 -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5932717734145031 -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5842956073035998 -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5701318561903005 -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5797570194720901 -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5813359794672879 -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5727054629889211 -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6144151946142021 -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5833722185787638 -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5659146726684421 -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6123922682910868 -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6958529641365826 -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7423335063286025 -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7952145906523514 -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6758350930191241 -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7266475029635435 -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7231048918622806 -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7206129590732789 -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.767126835604818 -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7957535639711294 -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.674050868176165 -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.722669855599955 -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7289605332772705 -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7106760140554512 -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.759306187518504 -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7862437846475174 -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7097038924079709 -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.71898882711722 -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7277459262253242 -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7651766193968695 -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7785928502665117 -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8185939377446253 -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7321659362585459 -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7762989521373896 -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7678581786866796 -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8020768223983644 -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7897413357352638 -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8336774822191746 -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7384370523392333 -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.787567158803102 -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7986536586479271 -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7910926649813786 -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8011913901647508 -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8113363819594502 -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7783934480957271 -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7992452049290165 -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7824379097963022 -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8677136227297856 -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8613864844286286 -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8703992596214372 -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8593858721979458 -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8642463333363378 -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8747837660829378 -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8418593505483395 -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8474351967418164 -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8459002327469506 -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.852107168025292 -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8458568239845287 -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8439062600118404 -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8418061925423816 -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8423659989073166 -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8493569840280434 -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8402309564173577 -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8401484225486996 -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8541185446068488 -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6198899573880374 -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6727587732462984 -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6814822685756021 -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5791874130942049 -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6363875301763376 -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6485723040947519 -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6418282256649618 -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6877092187700836 -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7219933520818409 -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5927570487158923 -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6422296775977167 -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6652765952033698 -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6207815168392771 -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7041087843165795 -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6941885615594998 -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5807143620756333 -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.633798854664285 -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6517900817889606 -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8411948268255361 -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8702210401563254 -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8506899878281127 -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8330671828425129 -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8537265358219729 -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8670467829295149 -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8547007147477742 -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8528756595768403 -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8056448482642885 -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8590960225976532 -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8616188365198965 -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8570530808299028 -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8237216398019593 -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8242779335763272 -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.809610531251141 -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8343889652226558 -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8503591334603545 -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8557961594072356 -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5725813046509874 -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5605548028349282 -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5672058973460543 -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5896242083645005 -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5822124251762533 -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5662748252603889 -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.566478533923616 -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5883861842675855 -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5748201293509047 -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5760920485170883 -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5699642994874559 -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5590338986085913 -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5859477878738697 -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5762113599292725 -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5878533424602564 -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5806214421114433 -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5451151899328895 -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.562614246920703 -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6554523062363583 -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7416918811324155 -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7670641447466083 -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6361475821254089 -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6568246545564174 -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7162049279538257 -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7106338575771237 -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7183715953389447 -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.783952865740709 -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6402545701774421 -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7154274900102845 -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.731018556985802 -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7212077910697152 -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7475808744300236 -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7738625869659325 -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6782108436996847 -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7225626316011425 -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6981313083537248 -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7395123681440738 -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7780351454831257 -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7958990830009648 -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6929861564652636 -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7272100201726258 -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.739116528216054 -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7428157095572862 -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7714874693403894 -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7541021128284185 -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7177719447639171 -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7399499462447908 -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.738966191843203 -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7485682645673286 -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7811877742073089 -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7626110520961107 -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7128952645012085 -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7306476544323065 -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7304826614036509 -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8586261824335337 -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8576109573830778 -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8582477460792832 -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8607863926735754 -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8505031687238348 -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8570355255271421 -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8524109531462661 -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.842211052731891 -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8355786005868538 -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8554667537787436 -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8652376774006312 -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8494918651589942 -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8690479057251843 -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8429027070167194 -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8406985606217202 -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8626185789903555 -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8357713423592047 -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8173065196919117 -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6001645418890544 -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6730051017016864 -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6583558543543444 -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5590440078761879 -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6052029938066602 -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6015211303882305 -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6112523986963891 -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6455492484192669 -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7085808043637064 -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6024053828178696 -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6123571876118225 -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6327212833107947 -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6385958633521712 -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6780683976113532 -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6804075169318389 -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5960114684088472 -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6118482419656184 -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6240020395317788 -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8114792337930687 -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8495367376558303 -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.832790630553578 -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.802659475352025 -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8270713376380504 -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8380338035155774 -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8351930975506408 -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8411981633843196 -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8421813276689843 -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8199442791837143 -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8433687908897856 -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8577630405357963 -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8359859251743845 -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8273824011812492 -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8361599817353146 -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8329557820796927 -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8466949664588294 -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.824150242484451 -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5621320627370554 -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5563168955421093 -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.545081830079103 -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5339905270448071 -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5856231373709095 -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5453941636561469 -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5521729546849204 -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6068921557204114 -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5791789803315307 -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5614577284575996 -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.551570364846471 -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5646073537045094 -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5758318115701773 -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5442578432864673 -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5522136405577976 -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5338975490962096 -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5555189733430811 -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5699785459527696 -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6589760997181475 -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7308541905413176 -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7488504332363232 -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6296752474937598 -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6552183582920056 -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7177342682864226 -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.715332321072923 -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.738684178007088 -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7251538908051126 -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6513564335468566 -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7135614183314417 -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.6828426838407555 -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7090206088399379 -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7221467721347657 -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7616674414479969 -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6539799737751874 -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6735535738512789 -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.6756070790495629 -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7832398705853283 -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8234582164408749 -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8310647472505127 -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7576382533558074 -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8128836377346372 -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8300367062283843 -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8074468351298245 -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8143774081979203 -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8362535013549638 -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7734156132478877 -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8069627869945308 -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8331835845975079 -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8090068202996061 -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8052211198837215 -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.842251790003257 -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7771813619365143 -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8364979816123536 -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8302825309464721 -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8455974259165839 -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.85811801260274 -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8572774062171112 -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8284541034066537 -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.862430666394106 -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8623918024047801 -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8353745632709991 -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8680855733797186 -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8555263259956267 -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8336301749611358 -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8704020193063409 -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8531792261894312 -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.83011340690706 -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8747276522539028 -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8715373607872495 -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8333958058889706 -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8655905895532042 -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8761596919043434 -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6373996198402004 -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6441974981530211 -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6697182296141558 -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5924216162618928 -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6059560578347051 -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.6344053031223705 -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6239126917575942 -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6361298854549549 -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6823745013628559 -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5900014221072256 -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6306056097632524 -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6222080561569346 -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6442163247222609 -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6766287779138264 -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6977252992216343 -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6036557035347001 -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6312490928146522 -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6445867658620412 -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.838106655436882 -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8682758662386001 -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8458884107444926 -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8553501702533802 -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8655351121703855 -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8440974942060268 -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8629477638181328 -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8396073891198438 -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8412979985387944 -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8378986503756645 -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8524378640405884 -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8477592551648824 -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8260162244067342 -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8322549365322409 -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8463156478156978 -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8330537902299652 -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8390387411341664 -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8337158650865905 -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5591128313272938 -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5334900392913972 -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5898916864205149 -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5360646550711018 -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.546609175094851 -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5764417076232662 -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5818013938347155 -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5659253809239505 -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.61557528513525 -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.57995041488938 -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5698006124051679 -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5717393626314234 -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5591948966293951 -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5858984827135902 -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6036418344458864 -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5358805618325806 -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5610619641017912 -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5529499617051673 -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7171192221182965 -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7557693957925121 -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7754883136272528 -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.662752679209631 -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7174267269686257 -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7388051726886146 -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.758313484542072 -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7753281788907218 -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7982847023050471 -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.707293076100297 -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7583527188472426 -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7847293600229962 -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.752001970160452 -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8111640916052508 -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7837562610514687 -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7154965225703177 -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7743997188741405 -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7531796843249289 -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7671972181906234 -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8106707759434459 -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8075447817968485 -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.7350668743014804 -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.7538554599055446 -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.778350521863667 -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7877654647553168 -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7859726031179401 -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8212348119527687 -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7581958748775989 -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7667655101536769 -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7887718995414793 -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7985901137931658 -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8137762805528745 -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8027257852882065 -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.739722612390988 -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.80281505526514 -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7691165472231326 -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8522911599147053 -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8776465008326796 -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8683689576640141 -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8465593910193574 -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8557996602729898 -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8570972019786183 -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8513402864727974 -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8586628234861154 -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8406618575510877 -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8621747853536231 -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.861794978948946 -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8600929756464315 -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8504418111921058 -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8469336466700662 -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.844996973837106 -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8652586900135097 -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8546580518087924 -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8555924646928214 -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5950311018711365 -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6531234008995005 -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6680221975270814 -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5874242365815406 -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.6209589965969771 -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.644606440352427 -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.6249200830404741 -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6890049956124108 -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.7073929221372856 -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5945762499578847 -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6422573878912582 -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6330675818532431 -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.6378386968204909 -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6677687891619982 -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6938764733828576 -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6256164412547931 -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6009138767352619 -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.6585209011489012 -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8403929900300838 -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8590389117260141 -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8423298904149829 -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8421765001459365 -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8721205913389212 -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8420229991003124 -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8546881596167631 -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8331373341244223 -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.835182160563492 -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8457774687785204 -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8478478184819802 -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8474223128195809 -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8125213870089286 -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8387178141902846 -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8162217220199838 -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8529226000551389 -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.842526325314302 -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8347068485932976 -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5810432513326697 -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5727786235971828 -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5885314622364128 -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5583729515058885 -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5457395697657493 -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5774819266416836 -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5957877833305008 -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6167916246072758 -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6045733921552093 -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5357251181662347 -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5885418523476487 -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5825876239378851 -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5814884195484928 -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5926396752980879 -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5938917111583984 -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5649443056974834 -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5596126693569157 -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5549161855700947 -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7014846112811487 -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.7331127142455832 -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7583898183495482 -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6636947664112886 -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.7023239567555155 -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.7211538015727227 -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7309047656307065 -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7678922446933857 -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7869522393653319 -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6581481730932565 -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7471623172251437 -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.742551205265687 -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7414214792935581 -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7653009194887398 -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7728622608624617 -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.7000127339791883 -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.7242941270985416 -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7113141302212943 -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.7233597487957857 -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.7619692719294395 -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.7787207407159182 -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.6969543177118321 -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.724495281068955 -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.7472664857520307 -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.7393837234754153 -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.7783849207174489 -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.7707680020641062 -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.7199460504950065 -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.7583697948124956 -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.7744849081157762 -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.7565652120475063 -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.7891836763229342 -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.7930296848758037 -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.7161553040497166 -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.7042120607817847 -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.7945062449395318 -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8478977662855477 -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8559902714335271 -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8486502842950556 -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8549858191889538 -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.855401323632904 -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8398174450739493 -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8418345136163791 -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8654959331869866 -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8434816440734005 -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8429654164230581 -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8434297153490918 -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8333145434017957 -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8578354325379299 -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8454612901127515 -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8480906617922771 -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.842071267914128 -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8547954391050863 -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8426815226632026 -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.5898490849045693 -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.6416209680910205 -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.6569735816760003 -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.5706720027138628 -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.5919357506234306 -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.590940994033472 -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.5911138396193722 -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.6746963664503548 -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.6983244438547785 -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.5986649793796605 -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.6098436442944902 -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.6074612627380411 -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.5999844584716164 -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.6586438243588825 -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.6801966142341639 -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.5892984056771313 -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.6080927174152099 -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.630545907516866 -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8443095193168914 -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8524456533174223 -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8560765678239791 -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8283598417495335 -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8613541914737587 -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8559980508592245 -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8284594279465328 -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8441353867607985 -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8394146055014176 -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8329123445249925 -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8501923621943991 -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.833858806905171 -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8299647529689985 -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8175124096041358 -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8169811456956699 -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8375974984520133 -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8242673663862887 -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8292300700363153 -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.564972614079232 -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5553555409883263 -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5972921527507876 -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5596629238341896 -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5602956506912936 -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5720865049386453 -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.583774904366308 -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5734661152163635 -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5653306236209694 -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5394860258386148 -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5756300945413382 -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5696598719423195 -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5995169875328019 -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6121975687213909 -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5935843655019252 -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5688430107825356 -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5676939106418968 -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.580848316154564 -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.6842945329335691 -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.722977748373112 -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.7516413993862553 -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.6211898441196773 -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.6722812796574367 -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.6991480982979793 -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.7274782330595125 -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.7397232209362364 -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.7502568413543883 -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.6219066341076476 -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7118183170815784 -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.7174754373738156 -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.7144897043409094 -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.7373045485784617 -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.7808075001195302 -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.6493145006766172 -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.6909914658486659 -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.7048347885571795 diff --git a/gridsearch/gridsearch_score_superdiagnostic.csv b/gridsearch/gridsearch_score_superdiagnostic.csv deleted file mode 100644 index 516a35c..0000000 --- a/gridsearch/gridsearch_score_superdiagnostic.csv +++ /dev/null @@ -1,973 +0,0 @@ -epochs,batch_size,init_lr,lr_red,model_depth,loss,kernel_size,auc -15.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8635507453453629 -15.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8822205602426204 -15.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8830497028394327 -15.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8580690599710122 -15.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8777740062526068 -15.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8759406446041019 -15.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8773875315914273 -15.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8890570347018402 -15.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8847244326337185 -15.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.872621836169249 -15.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8825745206218821 -15.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.88433734131227 -15.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8833659282006776 -15.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8883648862352462 -15.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8855242408365355 -15.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8712253822225713 -15.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8821730609255996 -15.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8833827655486409 -15.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8532545651491518 -15.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8501066113516434 -15.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.842981872125122 -15.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8427946031618133 -15.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8462891828077375 -15.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8306827951389352 -15.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8445513882781107 -15.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8417550455164053 -15.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8523287822483977 -15.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8474248955860227 -15.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8475281237180039 -15.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8542359578418242 -15.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8600713602397146 -15.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8478317392194276 -15.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8472825335687381 -15.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8441565270710994 -15.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8433880533927534 -15.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8382085022175004 -15.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7614187339748035 -15.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.8030171690344918 -15.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8208190048442624 -15.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.7150674896422121 -15.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7752628038046613 -15.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.8044359488961023 -15.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7735721323860937 -15.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8103430442567946 -15.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8342874023951947 -15.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7379950216624459 -15.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7930345364905494 -15.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.8225446741731748 -15.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7647416798209475 -15.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8141257930314941 -15.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8322835992932743 -15.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7429136823344095 -15.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7628708475737738 -15.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7939554026497317 -15.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.883218243628272 -15.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8790352136279876 -15.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.867052817500442 -15.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.869739173635808 -15.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8773540989760308 -15.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.857907960484226 -15.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8759796688964298 -15.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8645895618366053 -15.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8600878573586078 -15.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8734119270559494 -15.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8570880637462465 -15.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8523470019827868 -15.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8510559150379463 -15.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8753859599134367 -15.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8666610944712847 -15.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8391795631562332 -15.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8560207623796963 -15.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8618978782939054 -15.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.516674549626693 -15.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6217725829446129 -15.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6639465609967791 -15.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5427336926436351 -15.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5571048644855805 -15.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5919208143513317 -15.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5358281704048925 -15.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6265641841323444 -15.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6813177873753063 -15.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5386541913450515 -15.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5967077850960022 -15.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6187480358804407 -15.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5484892827455368 -15.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5977705629044351 -15.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6209309402470965 -15.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5278871619992659 -15.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6211823516182161 -15.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5872587195671896 -15.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8218515277912785 -15.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8451554816269318 -15.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8616213139422019 -15.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8003699309259531 -15.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8283531731678205 -15.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8463662655178504 -15.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8260208954298683 -15.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8607189744678466 -15.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.869306734053357 -15.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8251920948481679 -15.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8449073117612299 -15.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8555137121691208 -15.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8449614732658682 -15.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.868621279024036 -15.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8718883047949885 -15.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8249448946258312 -15.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8496216974799146 -15.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8540044390657296 -15.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8721997501143951 -15.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8875044157324555 -15.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8905391530208657 -15.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8508549703263425 -15.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8843157312175984 -15.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8827435814182598 -15.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8785590639854268 -15.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8896458878478727 -15.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8933648078269852 -15.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8814217079421511 -15.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8857985830609847 -15.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8812652096375793 -15.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8883962904174192 -15.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8929986488354572 -15.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8866708325316816 -15.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8786198724853388 -15.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8867765608634421 -15.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8847369892056473 -15.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8681369895585588 -15.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8684641014452098 -15.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8687299546393433 -15.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.866401357417898 -15.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8502979019561491 -15.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8532634914804319 -15.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8616042787364423 -15.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.85905604213674 -15.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8598795628973003 -15.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8493777184875467 -15.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.843957288797383 -15.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8491003444221533 -15.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8677218834843518 -15.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.873416721536543 -15.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8588610995477381 -15.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8473682649573003 -15.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8620305755404472 -15.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8591760041728346 -15.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7360442701089247 -15.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7965255100780434 -15.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8181727387310973 -15.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6623736651031805 -15.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7553870008955258 -15.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7913077432016603 -15.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7734342627550879 -15.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8161531638120012 -15.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8199253513970199 -15.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7543512190211098 -15.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.8080358473659071 -15.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7821976862901948 -15.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7771349346785831 -15.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8089873721707274 -15.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8210698928314799 -15.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6786979972599824 -15.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7608773055120657 -15.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7914832022942903 -15.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8837564555394963 -15.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8879909364126467 -15.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8611557506135665 -15.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8847635428892682 -15.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8823401769214131 -15.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8711451282624276 -15.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8804895974847241 -15.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8710094514387919 -15.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8808096998294727 -15.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8721177354760327 -15.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8730130529555921 -15.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.869396229379246 -15.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8657263864717221 -15.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8660572110028334 -15.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8731359709900479 -15.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8683244922098962 -15.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8580153750517164 -15.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8671492465287999 -15.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5239685097055199 -15.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5909390527241682 -15.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5753787119470891 -15.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5425488830830031 -15.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5738301798105298 -15.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.4890679650189568 -15.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5756458516467188 -15.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5913946875631081 -15.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5651174914035435 -15.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5253564055602679 -15.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5521947148992575 -15.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6269554963577425 -15.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.6162743189974952 -15.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6298757984043589 -15.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6278358681885488 -15.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5461515922120329 -15.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5572403074187009 -15.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.571978287067164 -15.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8015887708314119 -15.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.835716594586765 -15.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.861536322938652 -15.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8064820737841623 -15.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8147541989758963 -15.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8316385431213863 -15.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8297660978336904 -15.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8639547524830183 -15.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8706109006413038 -15.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8137247461516907 -15.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8403361996508764 -15.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8595436902309229 -15.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8399398223007388 -15.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8626025102531392 -15.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8587376080187051 -15.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8391850809403021 -15.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8557932950655798 -15.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8480242523073805 -15.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8489273369487322 -15.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8786668877959142 -15.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8847698256834212 -15.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8263071576280009 -15.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8564733071379461 -15.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8689545334650631 -15.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8642728521809099 -15.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8861590476279982 -15.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8906009512571482 -15.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8594771649059462 -15.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8595319472590628 -15.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8708294636009623 -15.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8780186839421399 -15.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8874003021194561 -15.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8893539136875791 -15.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8749028318546316 -15.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8694510548645195 -15.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8812659811002442 -15.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8744803420039678 -15.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8753181937973055 -15.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8483329922503288 -15.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8632348971165195 -15.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8730532050422776 -15.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8466525226191018 -15.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8525779065074343 -15.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8398727763303726 -15.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8343028974192777 -15.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8666397465006174 -15.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8430772657381156 -15.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8449230035580557 -15.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8525445459474087 -15.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8275962196047351 -15.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8208690759137302 -15.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8509603353223257 -15.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8336307329952181 -15.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8332833258575477 -15.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6637211576530545 -15.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.776348504134202 -15.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7968748430453734 -15.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6520798853555139 -15.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7506737973921026 -15.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7579067884235867 -15.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7374091103669996 -15.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7810200559064926 -15.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8022774128211309 -15.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6905454505681554 -15.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7441197838213132 -15.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7881739804382925 -15.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7516108283760236 -15.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8074896205139824 -15.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.818332599405185 -15.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.6822956273084956 -15.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7981946129123592 -15.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.732772419658643 -15.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8842322950628567 -15.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8884776586835356 -15.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8796687465360368 -15.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.880483338427528 -15.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.884879211812892 -15.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8648185070802792 -15.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8887292712475533 -15.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8774176298509856 -15.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8592101260153561 -15.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8879686945776258 -15.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8777065619900363 -15.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8706215146881983 -15.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8843540060742988 -15.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8713986696917003 -15.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8357380655090743 -15.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.875681537954376 -15.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8778967035472262 -15.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8667717558229374 -15.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.530382058286479 -15.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5849637551318967 -15.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5989284665626066 -15.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5855948148412321 -15.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5265904329654676 -15.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.587851972971349 -15.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5465757067301951 -15.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.548251486898229 -15.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.541613543903151 -15.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5024787068443165 -15.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.537536475601708 -15.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5784159739964272 -15.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5580977367597698 -15.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5668969865208346 -15.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6230681652069091 -15.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5141277467009419 -15.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5397983140983077 -15.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5726356247792952 -15.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.7931552066125724 -15.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8322403727979352 -15.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8514898168202811 -15.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.7664210972735184 -15.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8202605832203567 -15.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8276818446879736 -15.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8173180718697709 -15.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8342719841203777 -15.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.856322147156296 -15.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.7916215697202055 -15.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.7909390013615315 -15.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.812403841586116 -15.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8224769509089397 -15.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8514823242274542 -15.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8612483451545733 -15.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8148189781014147 -15.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8062126304047471 -15.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.782353477403516 -20.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8654911213760851 -20.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8825115925049265 -20.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8861780173954655 -20.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8520992811134144 -20.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8744414246831363 -20.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8786558606281266 -20.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8770649717157933 -20.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8894404478601873 -20.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.889569942377233 -20.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8715065621944529 -20.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8793998299150109 -20.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8891001519503963 -20.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8784929293713857 -20.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8858108995481379 -20.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8856727257761795 -20.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8764150125688625 -20.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8831603973786507 -20.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8714821059288077 -20.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8535619994638376 -20.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8517365134013821 -20.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8586093033594921 -20.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8463900933984014 -20.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8577196022208143 -20.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8538382731212257 -20.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8511982267092167 -20.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8511215928499118 -20.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8651609565270236 -20.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8450370318493077 -20.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.858450433073395 -20.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8524030426246753 -20.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8294316712963923 -20.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8430887398180914 -20.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8477613863676323 -20.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8470017764087262 -20.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8680881579390838 -20.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8564693027438227 -20.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7678051730080008 -20.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7774449479492517 -20.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8035401500289453 -20.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6988765743350118 -20.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7126808220446051 -20.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7651477037675543 -20.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7863795242030157 -20.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7953405782892821 -20.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8352111768417917 -20.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7480483330130844 -20.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7482445307695539 -20.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.8065296379863272 -20.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7815631444861372 -20.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8262683154127752 -20.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8388800035574681 -20.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7360764411376962 -20.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.8041153310461023 -20.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7936149697239964 -20.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8789086986752485 -20.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8746866135908561 -20.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8667991408120158 -20.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.872387074865887 -20.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8502108368508919 -20.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8401191368536042 -20.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.87569290678225 -20.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8642636444553625 -20.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8667848066840653 -20.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8539682323367321 -20.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8641263877382769 -20.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8682882684026957 -20.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8710380522891182 -20.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8597158170312763 -20.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8630165916618973 -20.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8519370572867967 -20.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8626505837361638 -20.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8731463477908319 -20.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.4806919045598271 -20.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5624166518607286 -20.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6415217476508008 -20.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4654723733164812 -20.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5418794935503718 -20.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5881563093180459 -20.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5285801925665846 -20.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6153778860484113 -20.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6148907987988106 -20.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5930098263919373 -20.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5738136039907662 -20.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5976615689328185 -20.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.536838727633924 -20.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5960618109585014 -20.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6865127461248433 -20.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5626387761115069 -20.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5917564451324532 -20.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6192947676975297 -20.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8405884685777613 -20.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8645850708785988 -20.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8712394763518471 -20.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.7929404598529194 -20.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8312283444616974 -20.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8662289259107663 -20.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8389849229221574 -20.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8702894576481618 -20.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.87318611647524 -20.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8302392517991111 -20.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8607695269028927 -20.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8660079647914376 -20.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.854183247303718 -20.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8713742939120133 -20.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8718807172840685 -20.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8513911193429898 -20.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8685050602981201 -20.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8680055325473802 -20.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8737556840572553 -20.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8841526755214332 -20.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8888065379535872 -20.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.852701259917897 -20.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8837830878032994 -20.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.885816567037968 -20.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8787283623149201 -20.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8917284636240392 -20.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8906356560516376 -20.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8779985423897004 -20.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8880542842704391 -20.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8823444076115033 -20.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8861267071362202 -20.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8903365601137553 -20.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8890990821469466 -20.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8796973560335398 -20.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8883858064760392 -20.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8780707714732131 -20.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8584318755497753 -20.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8547200776893197 -20.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8689391528476788 -20.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8657492876887302 -20.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8665984896775468 -20.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8670716568334941 -20.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8669849502009046 -20.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8669213504146495 -20.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8513987284951616 -20.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8613553081599469 -20.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8643802822696024 -20.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.850061110459477 -20.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8649890060805004 -20.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.864664536558461 -20.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.87499061468443 -20.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8617987991694275 -20.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8556029113974181 -20.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.836253087370685 -20.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7301582578523442 -20.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7966664001250571 -20.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8192383650946446 -20.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6843812631328858 -20.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.765024790877448 -20.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.795656001887858 -20.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7701854165373856 -20.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8096673884540383 -20.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8188169283504791 -20.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7105467505684645 -20.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.783353078439375 -20.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7782772263224064 -20.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7852474706411633 -20.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8160217019471087 -20.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8155007938311992 -20.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7490345626204942 -20.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.739864605966215 -20.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7697459810627348 -20.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8899160878145259 -20.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8805935037962547 -20.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8742165051107476 -20.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8785453081120776 -20.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.868034843649661 -20.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8689655344236765 -20.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.871577822543261 -20.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8633066667882496 -20.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8772899928453862 -20.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8665374293994789 -20.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8621465983511758 -20.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8615707808672314 -20.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8666142298062537 -20.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8715622792709952 -20.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8572585704008985 -20.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8662918114203869 -20.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8674643121881878 -20.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8598524076895272 -20.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5498489814390383 -20.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5157704198675442 -20.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6294814803439372 -20.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4735899868020016 -20.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5251547622346807 -20.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5966354746395138 -20.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5483085080274038 -20.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6114451283105824 -20.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6402537104327802 -20.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5184627537159879 -20.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5613578289453632 -20.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5950424719077719 -20.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5817387422853509 -20.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5670131371630888 -20.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6493057570347315 -20.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5695065788095982 -20.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5813936965210703 -20.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5899249706772173 -20.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8259970752893565 -20.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.858381715245641 -20.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8675019645173832 -20.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8054797253834948 -20.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8607613018453389 -20.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8516548287850534 -20.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8540060030398751 -20.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.867341187379584 -20.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8792765470740959 -20.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8465553071268127 -20.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8609189594062755 -20.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8617065988599807 -20.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8594804989480028 -20.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8784823618643904 -20.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8634406609171211 -20.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8446007474927965 -20.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.861299990126875 -20.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8589400435390498 -20.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8561992508197512 -20.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.87555993869972 -20.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8836365893996513 -20.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.860822786271946 -20.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8715385469639246 -20.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8775399130859786 -20.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8742921664333824 -20.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8836365288146316 -20.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8892733220736804 -20.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8664811797256972 -20.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8695930474945411 -20.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8754384908613974 -20.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8775468563414336 -20.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.892761735779104 -20.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8884170688120799 -20.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.87116405521003 -20.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8787148401311126 -20.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8791686439075189 -20.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8655304846337724 -20.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8553539472952941 -20.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8391481268905387 -20.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8735082106110585 -20.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.870548783381682 -20.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.856994105135844 -20.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8667091825862968 -20.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.855329073421993 -20.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8492945962400754 -20.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8697147511450535 -20.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8403955742315375 -20.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8432261588306927 -20.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8522076275102717 -20.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8494295515700746 -20.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8540298191892463 -20.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8582243251649517 -20.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.825422465203849 -20.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8416939697246559 -20.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6952495606397182 -20.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7530702024037019 -20.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7652535796492083 -20.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6496391028283236 -20.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.734216854760021 -20.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7172834175043877 -20.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7562330878121553 -20.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.791776803653914 -20.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8127985840760522 -20.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6644139771526311 -20.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7517192236077518 -20.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.768330386244136 -20.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7694404315292803 -20.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.7991416287974137 -20.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7913976215892403 -20.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7185004798537138 -20.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7831725929696628 -20.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7240620850331512 -20.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8915164842623713 -20.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8897755569654725 -20.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8680205618555169 -20.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8834992075005544 -20.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8846894358285672 -20.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8499986757067887 -20.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8818561098123627 -20.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8518823800774147 -20.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.859754242274243 -20.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8839244686481734 -20.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8668025246325449 -20.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8683446535115865 -20.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.873207807864186 -20.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8654723250715738 -20.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8668390545977522 -20.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8759948093063977 -20.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8630941525241899 -20.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8463581634906184 -20.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5215819994251621 -20.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5440332196269413 -20.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5125337879887183 -20.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4510956044056313 -20.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5172391251722862 -20.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5048816763264378 -20.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5399463256521333 -20.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5276851164890177 -20.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.5877430026666363 -20.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5484673072007328 -20.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.4938254579361662 -20.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.580972016705556 -20.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5452910095752914 -20.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6122407505352867 -20.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.5902117369731129 -20.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5062903971339048 -20.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.535559416226597 -20.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6077003369589623 -20.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.8039704987787148 -20.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8342584945514114 -20.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8623349412482656 -20.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.7628438365266939 -20.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.795774510742837 -20.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.840098307901715 -20.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8254729519527725 -20.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8627311407955313 -20.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8677142002875881 -20.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8116614075087506 -20.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8396535516035891 -20.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8419995568632858 -20.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8412225550438558 -20.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8656865127742878 -20.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8601881752353103 -20.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8043802059036173 -20.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8568457187758008 -20.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8348143373973232 -25.0,16.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8705600777962981 -25.0,16.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8807276210731628 -25.0,16.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8867087118861829 -25.0,16.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8616437980719732 -25.0,16.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8788467599486823 -25.0,16.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8817164444381467 -25.0,16.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8748379164827251 -25.0,16.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8885359702695691 -25.0,16.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.88812870604022 -25.0,16.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.868681736654787 -25.0,16.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8832920509054066 -25.0,16.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8800618724612149 -25.0,16.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8785960197506735 -25.0,16.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.888531363686703 -25.0,16.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8883397116683488 -25.0,16.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8750338019364152 -25.0,16.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8852031411070493 -25.0,16.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.882025275301395 -25.0,16.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8528207186935243 -25.0,16.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8644853332886487 -25.0,16.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8576433683053778 -25.0,16.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8493919254378963 -25.0,16.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8593238306554506 -25.0,16.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.874938841949397 -25.0,16.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8771251705527602 -25.0,16.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8635270396627007 -25.0,16.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8569853843133278 -25.0,16.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8500328013032604 -25.0,16.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8657036368385326 -25.0,16.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8690299827399027 -25.0,16.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8638455266361572 -25.0,16.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8584953506324703 -25.0,16.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8635322669476045 -25.0,16.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8349581741367297 -25.0,16.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8747721354606682 -25.0,16.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8769821911504555 -25.0,16.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6873512594178631 -25.0,16.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.8008945808618124 -25.0,16.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8211317462944018 -25.0,16.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6712825860790131 -25.0,16.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7392226232576062 -25.0,16.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.742144324192061 -25.0,16.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.790932562256092 -25.0,16.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.809785308389196 -25.0,16.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8314455157201949 -25.0,16.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.7177304403560215 -25.0,16.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7739268460591545 -25.0,16.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7955266417632291 -25.0,16.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.802152692268148 -25.0,16.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8200496742803861 -25.0,16.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8275062810102067 -25.0,16.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7438397641959898 -25.0,16.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7567684172262442 -25.0,16.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.71667929331858 -25.0,16.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8812222847723244 -25.0,16.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8703454019661772 -25.0,16.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8741599419882596 -25.0,16.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8681256474229778 -25.0,16.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8585557128646006 -25.0,16.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8636672229431989 -25.0,16.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8670758988725371 -25.0,16.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8592008249443523 -25.0,16.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8690135194639423 -25.0,16.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8551413711476142 -25.0,16.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8554555704107721 -25.0,16.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8810709586705495 -25.0,16.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8658574320777409 -25.0,16.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8739763100550557 -25.0,16.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8755441154874551 -25.0,16.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8652487227630475 -25.0,16.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8750612431399194 -25.0,16.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8780097330750865 -25.0,16.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5007829828914216 -25.0,16.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.6026027860607975 -25.0,16.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.5941344305322006 -25.0,16.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.541540162245731 -25.0,16.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.5637660827332058 -25.0,16.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5422177528960505 -25.0,16.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5019051722058944 -25.0,16.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6379386619195689 -25.0,16.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6511389775680027 -25.0,16.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5666860137091804 -25.0,16.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.615066575051899 -25.0,16.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.6280707264308051 -25.0,16.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5720961674711474 -25.0,16.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.583290014125741 -25.0,16.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6909651250982275 -25.0,16.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5979899059442434 -25.0,16.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.6019522157140068 -25.0,16.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5797216146908508 -25.0,16.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.833834468644891 -25.0,16.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8642090491695525 -25.0,16.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8737332780873465 -25.0,16.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8319471451065586 -25.0,16.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8545014681369899 -25.0,16.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8679930801953487 -25.0,16.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8558880391210991 -25.0,16.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8778510139784169 -25.0,16.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8761969509165706 -25.0,16.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8433758261001003 -25.0,16.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8775257109200432 -25.0,16.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8723464220608151 -25.0,16.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.863025895520293 -25.0,16.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8806869695798873 -25.0,16.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8678422670128363 -25.0,16.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8570766312071999 -25.0,16.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8676569943032956 -25.0,16.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8696970103299956 -25.0,32.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8678837425787126 -25.0,32.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8870004776013332 -25.0,32.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8913261946968145 -25.0,32.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8514816545784658 -25.0,32.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8788184697911358 -25.0,32.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8857877354480755 -25.0,32.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8844846691730894 -25.0,32.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.891487626757025 -25.0,32.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8934349984979141 -25.0,32.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8754471098831663 -25.0,32.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8897101469455476 -25.0,32.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8856854211808504 -25.0,32.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.889490758035831 -25.0,32.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.8938053882664171 -25.0,32.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8936142842882481 -25.0,32.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.8774543467922933 -25.0,32.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.888797693727604 -25.0,32.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8828539277487168 -25.0,32.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8643893819963956 -25.0,32.0,0.001,no,6.0,bce,"(40, 20, 10)",0.882731877232549 -25.0,32.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8610347205843256 -25.0,32.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8795558881248285 -25.0,32.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8741111605234702 -25.0,32.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.8755490328851717 -25.0,32.0,0.001,no,9.0,bce,"(20, 10, 5)",0.868798809748363 -25.0,32.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8644994356555401 -25.0,32.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8688991459251758 -25.0,32.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8686487912782038 -25.0,32.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8702112063898838 -25.0,32.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8733064364634829 -25.0,32.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8704849516438706 -25.0,32.0,0.001,no,12.0,bce,"(40, 20, 10)",0.8790218625625634 -25.0,32.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8768751313981668 -25.0,32.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8760331200341978 -25.0,32.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8720768396589368 -25.0,32.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8702354978678825 -25.0,32.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.7204237510299971 -25.0,32.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7930189734712157 -25.0,32.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.8157789596615473 -25.0,32.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6589006177744096 -25.0,32.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.763023641376524 -25.0,32.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7742505345918268 -25.0,32.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7632698860264536 -25.0,32.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.8090750892793728 -25.0,32.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8184980792949675 -25.0,32.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.670301023253662 -25.0,32.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.7670156400353124 -25.0,32.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7613051074189757 -25.0,32.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7857691897714142 -25.0,32.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.8158575814766422 -25.0,32.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.8470144472636024 -25.0,32.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7598429219683611 -25.0,32.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7657885123422119 -25.0,32.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7766812032640394 -25.0,32.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8846370511321663 -25.0,32.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.8694754913339326 -25.0,32.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.8699190104050661 -25.0,32.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8782957279150433 -25.0,32.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8668863191163156 -25.0,32.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8601808626551173 -25.0,32.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8726920164792241 -25.0,32.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8802340795459426 -25.0,32.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8553271091368796 -25.0,32.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8677019984029317 -25.0,32.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8664939060513829 -25.0,32.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.8725441654926763 -25.0,32.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8658931830917488 -25.0,32.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8719229413976294 -25.0,32.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8659472913253136 -25.0,32.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.86061863304328 -25.0,32.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8591557843374327 -25.0,32.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8693964480497683 -25.0,32.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.5481870748591208 -25.0,32.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5721380490883424 -25.0,32.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.6401662685795467 -25.0,32.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.5571145708138173 -25.0,32.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.546973437815082 -25.0,32.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5511368212184262 -25.0,32.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5034226955049844 -25.0,32.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.6024735028636816 -25.0,32.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6104750796771374 -25.0,32.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5527321316961837 -25.0,32.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5824103427140811 -25.0,32.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5885045067847653 -25.0,32.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5540976705463233 -25.0,32.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.6034667834923698 -25.0,32.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6027943882076117 -25.0,32.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.48395170352425493 -25.0,32.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5551197952120444 -25.0,32.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.6153152519484267 -25.0,32.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.840673825148437 -25.0,32.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8696342544189327 -25.0,32.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8783661978892265 -25.0,32.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.8297332788964699 -25.0,32.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8400470349335425 -25.0,32.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8635157378168087 -25.0,32.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8618288414640647 -25.0,32.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.874989502746209 -25.0,32.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8788793589760964 -25.0,32.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.851014255487862 -25.0,32.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.859155207532503 -25.0,32.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.876975548884099 -25.0,32.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8691954578809722 -25.0,32.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8780484625005647 -25.0,32.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8758404775462904 -25.0,32.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8464514609605879 -25.0,32.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.8641106669728952 -25.0,32.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8670416780830195 -25.0,64.0,0.001,yes,6.0,bce,"(20, 10, 5)",0.8554461890047024 -25.0,64.0,0.001,yes,6.0,bce,"(40, 20, 10)",0.8775723591820287 -25.0,64.0,0.001,yes,6.0,bce,"(60, 30, 15)",0.8840691270680137 -25.0,64.0,0.001,yes,6.0,wbce,"(20, 10, 5)",0.8505314076467584 -25.0,64.0,0.001,yes,6.0,wbce,"(40, 20, 10)",0.8661911698596062 -25.0,64.0,0.001,yes,6.0,wbce,"(60, 30, 15)",0.8755690344316337 -25.0,64.0,0.001,yes,9.0,bce,"(20, 10, 5)",0.8727361945406894 -25.0,64.0,0.001,yes,9.0,bce,"(40, 20, 10)",0.8865321106352665 -25.0,64.0,0.001,yes,9.0,bce,"(60, 30, 15)",0.8841424126440849 -25.0,64.0,0.001,yes,9.0,wbce,"(20, 10, 5)",0.8613520725914605 -25.0,64.0,0.001,yes,9.0,wbce,"(40, 20, 10)",0.8766609007532987 -25.0,64.0,0.001,yes,9.0,wbce,"(60, 30, 15)",0.8753927595595629 -25.0,64.0,0.001,yes,12.0,bce,"(20, 10, 5)",0.8863907985804863 -25.0,64.0,0.001,yes,12.0,bce,"(40, 20, 10)",0.895236025505298 -25.0,64.0,0.001,yes,12.0,bce,"(60, 30, 15)",0.8827233459976874 -25.0,64.0,0.001,yes,12.0,wbce,"(20, 10, 5)",0.878864894655373 -25.0,64.0,0.001,yes,12.0,wbce,"(40, 20, 10)",0.8752439000201221 -25.0,64.0,0.001,yes,12.0,wbce,"(60, 30, 15)",0.8594502083227641 -25.0,64.0,0.001,no,6.0,bce,"(20, 10, 5)",0.8774732419006562 -25.0,64.0,0.001,no,6.0,bce,"(40, 20, 10)",0.8644025747630684 -25.0,64.0,0.001,no,6.0,bce,"(60, 30, 15)",0.8759919349570184 -25.0,64.0,0.001,no,6.0,wbce,"(20, 10, 5)",0.8561048784246036 -25.0,64.0,0.001,no,6.0,wbce,"(40, 20, 10)",0.8787967309586587 -25.0,64.0,0.001,no,6.0,wbce,"(60, 30, 15)",0.858335936492774 -25.0,64.0,0.001,no,9.0,bce,"(20, 10, 5)",0.8778772587027249 -25.0,64.0,0.001,no,9.0,bce,"(40, 20, 10)",0.8728556641976205 -25.0,64.0,0.001,no,9.0,bce,"(60, 30, 15)",0.8576039747774183 -25.0,64.0,0.001,no,9.0,wbce,"(20, 10, 5)",0.8641024611507243 -25.0,64.0,0.001,no,9.0,wbce,"(40, 20, 10)",0.8576521743408385 -25.0,64.0,0.001,no,9.0,wbce,"(60, 30, 15)",0.8606407934200151 -25.0,64.0,0.001,no,12.0,bce,"(20, 10, 5)",0.8600030555178776 -25.0,64.0,0.001,no,12.0,bce,"(40, 20, 10)",0.876813632367312 -25.0,64.0,0.001,no,12.0,bce,"(60, 30, 15)",0.8703362391002442 -25.0,64.0,0.001,no,12.0,wbce,"(20, 10, 5)",0.8597133019198226 -25.0,64.0,0.001,no,12.0,wbce,"(40, 20, 10)",0.8705856030721163 -25.0,64.0,0.001,no,12.0,wbce,"(60, 30, 15)",0.8512571730079056 -25.0,64.0,0.0001,yes,6.0,bce,"(20, 10, 5)",0.6961502191042457 -25.0,64.0,0.0001,yes,6.0,bce,"(40, 20, 10)",0.7567479628895347 -25.0,64.0,0.0001,yes,6.0,bce,"(60, 30, 15)",0.7882625123334739 -25.0,64.0,0.0001,yes,6.0,wbce,"(20, 10, 5)",0.6719149889228911 -25.0,64.0,0.0001,yes,6.0,wbce,"(40, 20, 10)",0.7275172932752817 -25.0,64.0,0.0001,yes,6.0,wbce,"(60, 30, 15)",0.7408399616040205 -25.0,64.0,0.0001,yes,9.0,bce,"(20, 10, 5)",0.7247184966006724 -25.0,64.0,0.0001,yes,9.0,bce,"(40, 20, 10)",0.7850949399655698 -25.0,64.0,0.0001,yes,9.0,bce,"(60, 30, 15)",0.8007075248537502 -25.0,64.0,0.0001,yes,9.0,wbce,"(20, 10, 5)",0.6671701595647188 -25.0,64.0,0.0001,yes,9.0,wbce,"(40, 20, 10)",0.755222454989021 -25.0,64.0,0.0001,yes,9.0,wbce,"(60, 30, 15)",0.7478477482478438 -25.0,64.0,0.0001,yes,12.0,bce,"(20, 10, 5)",0.7758222356445058 -25.0,64.0,0.0001,yes,12.0,bce,"(40, 20, 10)",0.808277418395959 -25.0,64.0,0.0001,yes,12.0,bce,"(60, 30, 15)",0.7903743318736757 -25.0,64.0,0.0001,yes,12.0,wbce,"(20, 10, 5)",0.7332209191107433 -25.0,64.0,0.0001,yes,12.0,wbce,"(40, 20, 10)",0.7749929995236924 -25.0,64.0,0.0001,yes,12.0,wbce,"(60, 30, 15)",0.7685238429402848 -25.0,64.0,0.0001,no,6.0,bce,"(20, 10, 5)",0.8871024098706393 -25.0,64.0,0.0001,no,6.0,bce,"(40, 20, 10)",0.88039869351744 -25.0,64.0,0.0001,no,6.0,bce,"(60, 30, 15)",0.878170771671415 -25.0,64.0,0.0001,no,6.0,wbce,"(20, 10, 5)",0.8889747629197796 -25.0,64.0,0.0001,no,6.0,wbce,"(40, 20, 10)",0.8694068468875976 -25.0,64.0,0.0001,no,6.0,wbce,"(60, 30, 15)",0.8771433919224041 -25.0,64.0,0.0001,no,9.0,bce,"(20, 10, 5)",0.8795928126921203 -25.0,64.0,0.0001,no,9.0,bce,"(40, 20, 10)",0.8791474456430522 -25.0,64.0,0.0001,no,9.0,bce,"(60, 30, 15)",0.8737093989304144 -25.0,64.0,0.0001,no,9.0,wbce,"(20, 10, 5)",0.8620441469632883 -25.0,64.0,0.0001,no,9.0,wbce,"(40, 20, 10)",0.8586183791535179 -25.0,64.0,0.0001,no,9.0,wbce,"(60, 30, 15)",0.864173045734069 -25.0,64.0,0.0001,no,12.0,bce,"(20, 10, 5)",0.8747766379459477 -25.0,64.0,0.0001,no,12.0,bce,"(40, 20, 10)",0.8641467395831066 -25.0,64.0,0.0001,no,12.0,bce,"(60, 30, 15)",0.8629609602962226 -25.0,64.0,0.0001,no,12.0,wbce,"(20, 10, 5)",0.8745756162211968 -25.0,64.0,0.0001,no,12.0,wbce,"(40, 20, 10)",0.8676856675131203 -25.0,64.0,0.0001,no,12.0,wbce,"(60, 30, 15)",0.8517314698326777 -25.0,64.0,1e-05,yes,6.0,bce,"(20, 10, 5)",0.481878383195655 -25.0,64.0,1e-05,yes,6.0,bce,"(40, 20, 10)",0.5015053381029205 -25.0,64.0,1e-05,yes,6.0,bce,"(60, 30, 15)",0.595397168630999 -25.0,64.0,1e-05,yes,6.0,wbce,"(20, 10, 5)",0.4934465332127778 -25.0,64.0,1e-05,yes,6.0,wbce,"(40, 20, 10)",0.45409516335542194 -25.0,64.0,1e-05,yes,6.0,wbce,"(60, 30, 15)",0.5288352697706356 -25.0,64.0,1e-05,yes,9.0,bce,"(20, 10, 5)",0.5347059348582631 -25.0,64.0,1e-05,yes,9.0,bce,"(40, 20, 10)",0.5994188885452673 -25.0,64.0,1e-05,yes,9.0,bce,"(60, 30, 15)",0.6210030424177285 -25.0,64.0,1e-05,yes,9.0,wbce,"(20, 10, 5)",0.5814690159056558 -25.0,64.0,1e-05,yes,9.0,wbce,"(40, 20, 10)",0.5271694384278849 -25.0,64.0,1e-05,yes,9.0,wbce,"(60, 30, 15)",0.5422599706165315 -25.0,64.0,1e-05,yes,12.0,bce,"(20, 10, 5)",0.5832189231065013 -25.0,64.0,1e-05,yes,12.0,bce,"(40, 20, 10)",0.5545881651792254 -25.0,64.0,1e-05,yes,12.0,bce,"(60, 30, 15)",0.6147815721116969 -25.0,64.0,1e-05,yes,12.0,wbce,"(20, 10, 5)",0.5308178929771052 -25.0,64.0,1e-05,yes,12.0,wbce,"(40, 20, 10)",0.5824050483161242 -25.0,64.0,1e-05,yes,12.0,wbce,"(60, 30, 15)",0.5632200171786267 -25.0,64.0,1e-05,no,6.0,bce,"(20, 10, 5)",0.830688030462528 -25.0,64.0,1e-05,no,6.0,bce,"(40, 20, 10)",0.8456143986499801 -25.0,64.0,1e-05,no,6.0,bce,"(60, 30, 15)",0.8648928730411439 -25.0,64.0,1e-05,no,6.0,wbce,"(20, 10, 5)",0.816206128803409 -25.0,64.0,1e-05,no,6.0,wbce,"(40, 20, 10)",0.8345539151616946 -25.0,64.0,1e-05,no,6.0,wbce,"(60, 30, 15)",0.8419568212891749 -25.0,64.0,1e-05,no,9.0,bce,"(20, 10, 5)",0.8327057658123405 -25.0,64.0,1e-05,no,9.0,bce,"(40, 20, 10)",0.8702939713278633 -25.0,64.0,1e-05,no,9.0,bce,"(60, 30, 15)",0.8693881704672347 -25.0,64.0,1e-05,no,9.0,wbce,"(20, 10, 5)",0.8330297653103395 -25.0,64.0,1e-05,no,9.0,wbce,"(40, 20, 10)",0.8434740275221663 -25.0,64.0,1e-05,no,9.0,wbce,"(60, 30, 15)",0.8617234262560896 -25.0,64.0,1e-05,no,12.0,bce,"(20, 10, 5)",0.8544036818545003 -25.0,64.0,1e-05,no,12.0,bce,"(40, 20, 10)",0.8733016775881398 -25.0,64.0,1e-05,no,12.0,bce,"(60, 30, 15)",0.8716798922089254 -25.0,64.0,1e-05,no,12.0,wbce,"(20, 10, 5)",0.8320684144597892 -25.0,64.0,1e-05,no,12.0,wbce,"(40, 20, 10)",0.859393226877159 -25.0,64.0,1e-05,no,12.0,wbce,"(60, 30, 15)",0.8663156344336939 From 7a06985b2e960b8fe97fd0cb5ba20e317d96c748 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 31 Jul 2024 10:09:48 +0200 Subject: [PATCH 46/51] PR Update Here I have updated the pull request according to the requirments from the repository owner --- code/configs/tf_inception_time_config.py | 22 ++++ code/configs/your_configs.py | 24 +--- code/experiments/scp_experiment.py | 2 +- code/models/inception_time.py | 120 ++++++++++++++++++ code/models/your_model.py | 119 +---------------- ...py => reproduce_inception_time_results.py} | 2 +- 6 files changed, 153 insertions(+), 136 deletions(-) create mode 100644 code/configs/tf_inception_time_config.py create mode 100644 code/models/inception_time.py rename code/{reproduce_results.py => reproduce_inception_time_results.py} (97%) diff --git a/code/configs/tf_inception_time_config.py b/code/configs/tf_inception_time_config.py new file mode 100644 index 0000000..21c8a68 --- /dev/null +++ b/code/configs/tf_inception_time_config.py @@ -0,0 +1,22 @@ +conf_tf_inception = {'modelname':'tf_inception', 'modeltype':'inception_time_model', + 'parameters':dict()} + + +conf_tf_inception_all = {'modelname':'tf_inception_all', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=15, batch_size=16, lr_init=0.001, lr_red="no", model_depth=9 , loss="bce" , kernel_size=60)} + +conf_tf_inception_diagnostic = {'modelname':'tf_inception_diagnostic', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=32, lr_init=0.001 ,lr_red="no", model_depth=6 , loss="bce" , kernel_size=60)} + +conf_tf_inception_form = {'modelname':'tf_inception_form', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=64, lr_init=0.001 ,lr_red="no", model_depth=6 , loss="bce" , kernel_size=20)} + +conf_tf_inception_rhythm = {'modelname':'tf_inception_rhythm', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=16, lr_init=0.001, lr_red="no", model_depth=9 , loss="wbce" , kernel_size=40)} + +conf_tf_inception_subdiagnostic = {'modelname':'tf_inception_subdiagnostic', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=15, batch_size=64, lr_init=0.001 , lr_red="no", model_depth=6 , loss="wbce" , kernel_size=20)} + +conf_tf_inception_superdiagnostic = {'modelname':'tf_inception_superdiagnostic', 'modeltype':'inception_time_model', + 'parameters':dict(epoch=25, batch_size=64, lr_init=0.001 ,lr_red="yes", model_depth=12 , loss="bce" , kernel_size=40)} + diff --git a/code/configs/your_configs.py b/code/configs/your_configs.py index 21c8a68..708e59d 100644 --- a/code/configs/your_configs.py +++ b/code/configs/your_configs.py @@ -1,22 +1,2 @@ -conf_tf_inception = {'modelname':'tf_inception', 'modeltype':'inception_time_model', - 'parameters':dict()} - - -conf_tf_inception_all = {'modelname':'tf_inception_all', 'modeltype':'inception_time_model', - 'parameters':dict(epoch=15, batch_size=16, lr_init=0.001, lr_red="no", model_depth=9 , loss="bce" , kernel_size=60)} - -conf_tf_inception_diagnostic = {'modelname':'tf_inception_diagnostic', 'modeltype':'inception_time_model', - 'parameters':dict(epoch=25, batch_size=32, lr_init=0.001 ,lr_red="no", model_depth=6 , loss="bce" , kernel_size=60)} - -conf_tf_inception_form = {'modelname':'tf_inception_form', 'modeltype':'inception_time_model', - 'parameters':dict(epoch=25, batch_size=64, lr_init=0.001 ,lr_red="no", model_depth=6 , loss="bce" , kernel_size=20)} - -conf_tf_inception_rhythm = {'modelname':'tf_inception_rhythm', 'modeltype':'inception_time_model', - 'parameters':dict(epoch=25, batch_size=16, lr_init=0.001, lr_red="no", model_depth=9 , loss="wbce" , kernel_size=40)} - -conf_tf_inception_subdiagnostic = {'modelname':'tf_inception_subdiagnostic', 'modeltype':'inception_time_model', - 'parameters':dict(epoch=15, batch_size=64, lr_init=0.001 , lr_red="no", model_depth=6 , loss="wbce" , kernel_size=20)} - -conf_tf_inception_superdiagnostic = {'modelname':'tf_inception_superdiagnostic', 'modeltype':'inception_time_model', - 'parameters':dict(epoch=25, batch_size=64, lr_init=0.001 ,lr_red="yes", model_depth=12 , loss="bce" , kernel_size=40)} - +your_custom_config = {'modelname':'YOUR_MODEL', 'modeltype':'YOUR_MODEL_TYPE', + 'parameters':dict()} \ No newline at end of file diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 1e20f54..95453bf 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -110,7 +110,7 @@ def perform(self): model = fastai_model(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) elif modeltype == "inception_time_model": # YOUR MODEL GOES HERE! - from models.your_model import inception_time_model + from code.models.inception_time import inception_time_model model = inception_time_model(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) else: assert(True) diff --git a/code/models/inception_time.py b/code/models/inception_time.py new file mode 100644 index 0000000..84ab706 --- /dev/null +++ b/code/models/inception_time.py @@ -0,0 +1,120 @@ +from models.base_model import ClassificationModel +import tensorflow as tf +import numpy as np +import tensorflow_addons as tfa + +class inception_time_model(ClassificationModel): + def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red="yes", model_depth=6, loss="bce", kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary", verbose=1): + super(inception_time_model, self).__init__() + self.name = name + self.n_classes = n_classes + self.sampling_frequency = sampling_frequency + self.outputfolder = outputfolder + self.input_shape = input_shape + self.epoch = epoch + self.batch_size = batch_size + self.lr_red = lr_red + if loss == "bce": + self.loss = tf.keras.losses.BinaryCrossentropy() + elif loss == "wbce": + self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce + self.verbose = verbose + self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss = self.loss) + + + def fit(self, X_train, y_train, X_val, y_val): + if self.lr_red == "no": + self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, + validation_data=(X_val, y_val), verbose=self.verbose) + elif self.lr_red == "yes": + self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, + validation_data=(X_val, y_val), verbose=self.verbose, + callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)]) + else: + print("Error: wrong lr_red argument") + def predict(self, X): + return self.model.predict(X) + + +def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32): + + if use_bottleneck and int(input_tensor.shape[-1]) > 1: + input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1, + padding='same', activation=activation, use_bias=False)(input_tensor) + else: + input_inception = input_tensor + + # kernel_size_s = [3, 5, 8, 11, 17] + kernel_size_s = [kernel_size // (2 ** i) for i in range(3)] + + conv_list = [] + + for i in range(len(kernel_size_s)): + conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i], + strides=stride, padding='same', activation=activation, use_bias=False)( + input_inception)) + + max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor) + + conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1, + padding='same', activation=activation, use_bias=False)(max_pool_1) + + conv_list.append(conv_6) + + x = tf.keras.layers.Concatenate(axis=2)(conv_list) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation(activation='relu')(x) + return x + +def _shortcut_layer(input_tensor, out_tensor): + shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1, + padding='same', use_bias=False)(input_tensor) + shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y) + + x = tf.keras.layers.Add()([shortcut_y, out_tensor]) + x = tf.keras.layers.Activation('relu')(x) + return x + +def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary", loss= tf.keras.losses.BinaryCrossentropy()): + input_layer = tf.keras.layers.Input(input_shape) + + x = input_layer + input_res = input_layer + + for d in range(depth): + + x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters) + + if use_residual and d % 3 == 2: + x = _shortcut_layer(input_res, x) + input_res = x + + gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x) + + output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) + model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer) + model.compile(loss=loss, optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), + metrics=[tf.keras.metrics.BinaryAccuracy(), + tf.keras.metrics.AUC( + num_thresholds=200, + curve='ROC', + summation_method='interpolation', + name="ROC", + multi_label=True, + ), + tf.keras.metrics.AUC( + num_thresholds=200, + curve='PR', + summation_method='interpolation', + name="PRC", + multi_label=True, + ) + ]) + print("Inception model built.") + return model + +def scheduler(epoch, lr): + if epoch % 5 == 0: + return lr*0.1 + else: + return lr diff --git a/code/models/your_model.py b/code/models/your_model.py index 84ab706..b94158e 100644 --- a/code/models/your_model.py +++ b/code/models/your_model.py @@ -1,120 +1,15 @@ from models.base_model import ClassificationModel -import tensorflow as tf -import numpy as np -import tensorflow_addons as tfa - -class inception_time_model(ClassificationModel): - def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape, epoch=30, batch_size=32, lr_init = 0.001, lr_red="yes", model_depth=6, loss="bce", kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary", verbose=1): - super(inception_time_model, self).__init__() + +class YourModel(ClassificationModel): + def __init__(self, name, n_classes, sampling_frequency, outputfolder, input_shape): self.name = name self.n_classes = n_classes self.sampling_frequency = sampling_frequency self.outputfolder = outputfolder - self.input_shape = input_shape - self.epoch = epoch - self.batch_size = batch_size - self.lr_red = lr_red - if loss == "bce": - self.loss = tf.keras.losses.BinaryCrossentropy() - elif loss == "wbce": - self.loss = tfa.losses.SigmoidFocalCrossEntropy() #focal instead of weighted bce - self.verbose = verbose - self.model = build_model((self.sampling_frequency*10,12),self.n_classes,lr_init = lr_init, depth=model_depth, kernel_size=kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters,clf=clf, loss = self.loss) - + self.input_shape = input_shape def fit(self, X_train, y_train, X_val, y_val): - if self.lr_red == "no": - self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, - validation_data=(X_val, y_val), verbose=self.verbose) - elif self.lr_red == "yes": - self.model.fit(X_train, y_train, epochs=self.epoch, batch_size=self.batch_size, - validation_data=(X_val, y_val), verbose=self.verbose, - callbacks = [tf.keras.callbacks.LearningRateScheduler(scheduler, verbose=0)]) - else: - print("Error: wrong lr_red argument") - def predict(self, X): - return self.model.predict(X) - - -def _inception_module(input_tensor, stride=1, activation='linear', use_bottleneck=True, kernel_size=40, bottleneck_size=32, nb_filters=32): - - if use_bottleneck and int(input_tensor.shape[-1]) > 1: - input_inception = tf.keras.layers.Conv1D(filters=bottleneck_size, kernel_size=1, - padding='same', activation=activation, use_bias=False)(input_tensor) - else: - input_inception = input_tensor - - # kernel_size_s = [3, 5, 8, 11, 17] - kernel_size_s = [kernel_size // (2 ** i) for i in range(3)] - - conv_list = [] - - for i in range(len(kernel_size_s)): - conv_list.append(tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=kernel_size_s[i], - strides=stride, padding='same', activation=activation, use_bias=False)( - input_inception)) - - max_pool_1 = tf.keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor) - - conv_6 = tf.keras.layers.Conv1D(filters=nb_filters, kernel_size=1, - padding='same', activation=activation, use_bias=False)(max_pool_1) - - conv_list.append(conv_6) + pass - x = tf.keras.layers.Concatenate(axis=2)(conv_list) - x = tf.keras.layers.BatchNormalization()(x) - x = tf.keras.layers.Activation(activation='relu')(x) - return x - -def _shortcut_layer(input_tensor, out_tensor): - shortcut_y = tf.keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1, - padding='same', use_bias=False)(input_tensor) - shortcut_y = tf.keras.layers.BatchNormalization()(shortcut_y) - - x = tf.keras.layers.Add()([shortcut_y, out_tensor]) - x = tf.keras.layers.Activation('relu')(x) - return x - -def build_model(input_shape, nb_classes, depth=6, use_residual=True, lr_init = 0.001, kernel_size=40, bottleneck_size=32, nb_filters=32, clf="binary", loss= tf.keras.losses.BinaryCrossentropy()): - input_layer = tf.keras.layers.Input(input_shape) - - x = input_layer - input_res = input_layer - - for d in range(depth): - - x = _inception_module(x,kernel_size = kernel_size, bottleneck_size=bottleneck_size, nb_filters=nb_filters) - - if use_residual and d % 3 == 2: - x = _shortcut_layer(input_res, x) - input_res = x - - gap_layer = tf.keras.layers.GlobalAveragePooling1D()(x) - - output_layer = tf.keras.layers.Dense(units=nb_classes,activation='sigmoid')(gap_layer) - model = tf.keras.models.Model(inputs=input_layer, outputs=output_layer) - model.compile(loss=loss, optimizer=tf.keras.optimizers.Adam(learning_rate=lr_init), - metrics=[tf.keras.metrics.BinaryAccuracy(), - tf.keras.metrics.AUC( - num_thresholds=200, - curve='ROC', - summation_method='interpolation', - name="ROC", - multi_label=True, - ), - tf.keras.metrics.AUC( - num_thresholds=200, - curve='PR', - summation_method='interpolation', - name="PRC", - multi_label=True, - ) - ]) - print("Inception model built.") - return model - -def scheduler(epoch, lr): - if epoch % 5 == 0: - return lr*0.1 - else: - return lr + def predict(self, X): + pass \ No newline at end of file diff --git a/code/reproduce_results.py b/code/reproduce_inception_time_results.py similarity index 97% rename from code/reproduce_results.py rename to code/reproduce_inception_time_results.py index 0030d31..140e24b 100644 --- a/code/reproduce_results.py +++ b/code/reproduce_inception_time_results.py @@ -3,7 +3,7 @@ # model configs from configs.fastai_configs import * from configs.wavelet_configs import * -from configs.your_configs import * +from code.configs.tf_inception_time_config import * import sys def main(datafolder, datafolder_icbeb, outputfolder): From f06fc9faded6bfa16900b66d935e9315b74671a3 Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Wed, 31 Jul 2024 10:23:50 +0200 Subject: [PATCH 47/51] add template to scp_experiment.py --- code/experiments/scp_experiment.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 95453bf..1fbad72 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -109,9 +109,12 @@ def perform(self): from models.fastai_model import fastai_model model = fastai_model(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) elif modeltype == "inception_time_model": - # YOUR MODEL GOES HERE! from code.models.inception_time import inception_time_model model = inception_time_model(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) + elif modeltype == "YOUR_MODEL_TYPE": + # YOUR MODEL GOES HERE! + from models.your_model import YourModel + model = YourModel(modelname, n_classes, self.sampling_frequency, mpath, self.input_shape, **modelparams) else: assert(True) break From 222a8d74795f997c1b965ebdbcfe33df9ed13bc8 Mon Sep 17 00:00:00 2001 From: helme Date: Thu, 1 Aug 2024 09:22:49 +0200 Subject: [PATCH 48/51] Update scp_experiment.py removed matplotlib and debugging stuff --- code/experiments/scp_experiment.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/code/experiments/scp_experiment.py b/code/experiments/scp_experiment.py index 1fbad72..162cb30 100644 --- a/code/experiments/scp_experiment.py +++ b/code/experiments/scp_experiment.py @@ -5,7 +5,6 @@ import numpy as np import multiprocessing from itertools import repeat -import matplotlib.pyplot as plt class SCP_Experiment(): ''' @@ -124,8 +123,6 @@ def perform(self): # predict and dump model.predict(self.X_train).dump(mpath+'y_train_pred.npy') model.predict(self.X_val).dump(mpath+'y_val_pred.npy') - plt.plot(self.X_test[0,:,0]) - plt.show() model.predict(self.X_test).dump(mpath+'y_test_pred.npy') modelname = 'ensemble' From 7994737977f78dafbe5761950542225840b476d3 Mon Sep 17 00:00:00 2001 From: helme Date: Thu, 1 Aug 2024 09:27:02 +0200 Subject: [PATCH 49/51] Update utils.py did the changes according to my comments --- code/utils/utils.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/code/utils/utils.py b/code/utils/utils.py index d8bb613..c6d1f45 100644 --- a/code/utils/utils.py +++ b/code/utils/utils.py @@ -114,7 +114,7 @@ def apply_thresholds(preds, thresholds): # DATA PROCESSING STUFF def load_dataset(path, sampling_rate, release=False): - if path.split('/')[-2] == 'ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1': + if path.split('/')[-2] == 'ptbxl': # load and convert annotation data Y = pd.read_csv(path+'ptbxl_database.csv', index_col='ecg_id') Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x)) @@ -335,7 +335,7 @@ def apply_standardizer(X, ss): # DOCUMENTATION STUFF -def generate_ptbxl_summary_table(selection=None, folder: str="./your/path/to/ptbxl/"): +def generate_ptbxl_summary_table(selection=None, folder: str="../output/"): exps = ['exp0', 'exp1', 'exp1.1', 'exp1.1.1', 'exp2', 'exp3'] metric1 = 'macro_auc' @@ -405,7 +405,7 @@ def generate_ptbxl_summary_table(selection=None, folder: str="./your/path/to/ptb md_source += '| ' + row[0].replace('fastai_', '') + ' | ' + row[1] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \n' print(md_source) -def ICBEBE_table(selection=None, folder:str="./your/path/to/icbeb/"): +def ICBEBE_table(selection=None, folder:str="../output/"): cols = ['macro_auc', 'F_beta_macro', 'G_beta_macro'] if selection is None: From b9708e36503ebc91af1392cb0655992e0694aa2a Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sun, 4 Aug 2024 19:46:04 +0200 Subject: [PATCH 50/51] Requested changes --- code/reproduce_inception_time_results.py | 82 ++++++++---------------- code/reproduce_results.py | 59 +++++++++++++++++ code/utils/utils.py | 2 +- 3 files changed, 88 insertions(+), 55 deletions(-) create mode 100644 code/reproduce_results.py diff --git a/code/reproduce_inception_time_results.py b/code/reproduce_inception_time_results.py index 140e24b..4af0c1d 100644 --- a/code/reproduce_inception_time_results.py +++ b/code/reproduce_inception_time_results.py @@ -1,69 +1,43 @@ from experiments.scp_experiment import SCP_Experiment from utils import utils -# model configs -from configs.fastai_configs import * -from configs.wavelet_configs import * -from code.configs.tf_inception_time_config import * -import sys +from code.configs.tf_inception_time_config import conf_tf_inception_all, conf_tf_inception_diagnostic, conf_tf_inception_form, conf_tf_inception_rhythm, conf_tf_inception_subdiagnostic, conf_tf_inception_superdiagnostic -def main(datafolder, datafolder_icbeb, outputfolder): +def main(): + datafolder = '../data/ptbxl/' + datafolder_icbeb = '../data/ICBEB/' + outputfolder = '../output/' - models = [ - #conf_fastai_xresnet1d101, - #conf_fastai_resnet1d_wang, - #conf_fastai_lstm, - #conf_fastai_lstm_bidir, - #conf_fastai_fcn_wang, - #conf_fastai_inception1d, - #conf_wavelet_standard_nn, - conf_tf_inception, - conf_tf_inception_all, - conf_tf_inception_diagnostic, - conf_tf_inception_form, - conf_tf_inception_rhythm, - conf_tf_inception_subdiagnostic, - conf_tf_inception_superdiagnostic - ] - - ########################################## - # STANDARD SCP EXPERIMENTS ON PTBXL - ########################################## - - experiments = [ - ('exp0', 'all'), - ('exp1', 'diagnostic'), - ('exp1.1', 'subdiagnostic'), - ('exp1.1.1', 'superdiagnostic'), - ('exp2', 'form'), - ('exp3', 'rhythm') - ] + # perform each experiment one after another + e = SCP_Experiment('custom_exp_name_1', 'all', datafolder, outputfolder, [conf_tf_inception_all]) + e.prepare() + e.perform() + e.evaluate() - for name, task in experiments: - print(name) - print(task) - e = SCP_Experiment(name, task, datafolder, outputfolder, models) - e.prepare() - e.perform() - e.evaluate(n_bootstraping_samples=100, bootstrap_eval=True, dumped_bootstraps=False) + e = SCP_Experiment('custom_exp_name_2', 'diagnostic', datafolder, outputfolder, [conf_tf_inception_diagnostic]) + e.prepare() + e.perform() + e.evaluate() - # generate greate summary table - utils.generate_ptbxl_summary_table(folder = outputfolder) + e = SCP_Experiment('custom_exp_name_3', 'subdiagnostic', datafolder, outputfolder, [conf_tf_inception_subdiagnostic]) + e.prepare() + e.perform() + e.evaluate() - ########################################## - # EXPERIMENT BASED ICBEB DATA - ########################################## + e = SCP_Experiment('custom_exp_name_4', 'superdiagnostic', datafolder, outputfolder, [conf_tf_inception_superdiagnostic]) + e.prepare() + e.perform() + e.evaluate() - e = SCP_Experiment('exp_ICBEB', 'all', datafolder_icbeb, outputfolder, models) + e = SCP_Experiment('custom_exp_name_5', 'form', datafolder, outputfolder, [conf_tf_inception_form]) e.prepare() e.perform() e.evaluate() - # generate greate summary table - utils.ICBEBE_table(folder=outputfolder) + e = SCP_Experiment('custom_exp_name_6', 'rhythm', datafolder, outputfolder, [conf_tf_inception_rhythm]) + e.prepare() + e.perform() + e.evaluate() if __name__ == "__main__": - if not (len(sys.argv) == 4): - raise Exception('Include the data and model folders as arguments, e.g., python reproduce_results.py ./path/to/data/ ./path/to/icbeb/ ./path/to/output/') - else: - main(datafolder = sys.argv[1], datafolder_icbeb = sys.argv[2], outputfolder = sys.argv[3]) \ No newline at end of file + main() \ No newline at end of file diff --git a/code/reproduce_results.py b/code/reproduce_results.py new file mode 100644 index 0000000..44fcb68 --- /dev/null +++ b/code/reproduce_results.py @@ -0,0 +1,59 @@ +from experiments.scp_experiment import SCP_Experiment +from utils import utils +# model configs +from configs.fastai_configs import * +from configs.wavelet_configs import * + + +def main(): + + datafolder = '../data/ptbxl/' + datafolder_icbeb = '../data/ICBEB/' + outputfolder = '../output/' + + models = [ + conf_fastai_xresnet1d101, + conf_fastai_resnet1d_wang, + conf_fastai_lstm, + conf_fastai_lstm_bidir, + conf_fastai_fcn_wang, + conf_fastai_inception1d, + conf_wavelet_standard_nn, + ] + + ########################################## + # STANDARD SCP EXPERIMENTS ON PTBXL + ########################################## + + experiments = [ + ('exp0', 'all'), + ('exp1', 'diagnostic'), + ('exp1.1', 'subdiagnostic'), + ('exp1.1.1', 'superdiagnostic'), + ('exp2', 'form'), + ('exp3', 'rhythm') + ] + + for name, task in experiments: + e = SCP_Experiment(name, task, datafolder, outputfolder, models) + e.prepare() + e.perform() + e.evaluate() + + # generate greate summary table + utils.generate_ptbxl_summary_table() + + ########################################## + # EXPERIMENT BASED ICBEB DATA + ########################################## + + e = SCP_Experiment('exp_ICBEB', 'all', datafolder_icbeb, outputfolder, models) + e.prepare() + e.perform() + e.evaluate() + + # generate greate summary table + utils.ICBEBE_table() + +if __name__ == "__main__": + main() diff --git a/code/utils/utils.py b/code/utils/utils.py index c6d1f45..97378c5 100644 --- a/code/utils/utils.py +++ b/code/utils/utils.py @@ -405,7 +405,7 @@ def generate_ptbxl_summary_table(selection=None, folder: str="../output/"): md_source += '| ' + row[0].replace('fastai_', '') + ' | ' + row[1] + ' | [our work]('+our_work+') | [this repo]('+our_repo+')| \n' print(md_source) -def ICBEBE_table(selection=None, folder:str="../output/"): +def ICBEBE_table(selection=None, folder:str="./your/path/to/icbeb/"): cols = ['macro_auc', 'F_beta_macro', 'G_beta_macro'] if selection is None: From 16b8cb71cc464314bcf018e0fb048dfe64372cbe Mon Sep 17 00:00:00 2001 From: Singstad90 Date: Sun, 4 Aug 2024 20:45:15 +0200 Subject: [PATCH 51/51] change file path names --- code/utils/utils.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/code/utils/utils.py b/code/utils/utils.py index 97378c5..d8bb613 100644 --- a/code/utils/utils.py +++ b/code/utils/utils.py @@ -114,7 +114,7 @@ def apply_thresholds(preds, thresholds): # DATA PROCESSING STUFF def load_dataset(path, sampling_rate, release=False): - if path.split('/')[-2] == 'ptbxl': + if path.split('/')[-2] == 'ptb-xl-a-large-publicly-available-electrocardiography-dataset-1.0.1': # load and convert annotation data Y = pd.read_csv(path+'ptbxl_database.csv', index_col='ecg_id') Y.scp_codes = Y.scp_codes.apply(lambda x: ast.literal_eval(x)) @@ -335,7 +335,7 @@ def apply_standardizer(X, ss): # DOCUMENTATION STUFF -def generate_ptbxl_summary_table(selection=None, folder: str="../output/"): +def generate_ptbxl_summary_table(selection=None, folder: str="./your/path/to/ptbxl/"): exps = ['exp0', 'exp1', 'exp1.1', 'exp1.1.1', 'exp2', 'exp3'] metric1 = 'macro_auc'